Test methods

Question

What is the most commonly used approach used for testing in Java projects (iterative development)?

Answer 1

My suggestion is that you should have a healthy mix of automated and manual testing.

AUTOMATED TEST

• Device testing
  Use NUnit to test your classes, functions, and the interactions between them.
  http://www.nunit.org/index.php

• Auto Functional Testing
  If possible, you should automate a lot of functional testing. Some framework works have functional testing built into them. Otherwise, you should use a tool for this. If you are developing websites / applications, you can look at Selenium.
  http://www.peterkrantz.com/2005/selenium-for-aspnet/

• Continuous integration
  Use CI to make sure that all of your automated tests run every time someone from your team makes a project commit.
  http://martinfowler.com/articles/continuousIntegration.html

MANUAL TESTING
As far as I like automatic testing, IMHO, and not a replacement for manual testing. The main reason is that the automated method can only do what they say, and only check what has been informed, to view it as pass / fail. A person can use it to detect flaws and pose questions that arise when testing something else.

• Research testing
  ET is a very cheap and effective way to find flaws in a project. It takes advantage of human intelligence and teaches testers / developers more about the project than any other testing method I know of. Performing an ET session for each function deployed in a test environment is not only an effective way to quickly find problems, but also a good way to learn and have fun!
  http://www.satisfice.com/articles/et-article.pdf

Answer 2

Personal experience suggests that the most popular approach is absence at all.

Answer 3

I used to work with TDD (Test Driven Development), and my feelings for it are mixed. Essentially, you write your tests before you write your code, and write your code to meet the requirements of the test. TDD makes you have a clear idea of ​​your requirements before launching. An additional advantage is that as soon as you finish development, assuming that you carefully follow the TDD procedures, you will have a complete set of test suites for working with code. The downside is that it takes a lot of time, and sometimes you just need to skip a couple of steps (for example, maybe write code before tests are preferred by a normal person).

Read more here (wiki link)

Answer 4

Module testing?

Contract programming, a la Eiffel?

Waterfall model?

Different shops do different things. If there was one method to manage them all, you would not ask this question.

Answer 5

In the premise of testing, I would say that testing with JUnit is a general approach to testing in Java.

Although most tests are written using JUnit, most tests usually have more integration tests than unit tests. (which means not testing one thing in isolation, but some things together)

In addition, the test is generally not written in the first approach to testing, but in parallel or after the implementation of a certain function.

If you go to a team that makes more advanced use of testing, you may find that CI Server (Cruise Control, Hudson) runs tests at least once a day during nightly builds.

Answer 6

In order of the most commonly used approach:

• no tests at all
• manual tests: launching an application, clicking or providing input, checking Results
• try to write some JUnits, forget about them, move to 2 and 1
• Start with TDD, make sure it's hard then move it to 3, 2 and 1

on the theoretical side, there are many ways to test the code correctly. If you are looking for something practical, take a look at Pure Code Conversation . Take a look at the whole series, about 5 conversations (you can’t post more than one link).

Answer 7

My suggestion for testing a java project is to simplify it.

Steps: - Manual testing: - Consider a stable product. Automation Testing: - Maintain product quality. Reporting and reporting: - Tell people about product quality. Continuous Integration: - Create a complete automated continuous tool.

When the developer completes the Functionality, begin testing the module modulo. Try to compare the actual output with the expected output and against it. Ask for problems.

When the developer has solved the problems, start by testing the integration, and also start testing the problems of the resolved states and check if there is any regression due to the fix problem.

Finally, when the product becomes stable, then start automating the modules. You can also follow the automation step by step as: - 1. Automation of modules. 2. Create a report and send mail for the HealthCheck product. 3. Continuous testing of integration and automation on a private server on the local machine.