James P.
James P.

Reputation: 19607

Testing methodologies

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

Upvotes: 6

Views: 1941

Answers (7)

mohit sarsar
mohit sarsar

Reputation: 189

My Suggestion for testing of the java project is to keep it simple.

Steps :- Manual Testing :-Achieve a stable product. Automation Testing :- Maintain the quality of the product. Report Generation and reporting :- Let people know the quality of the product. Continuous Integration :-Make it a complete automated,continuous tool.

When developer will commit the Functionality then Start testing the it module by module.Try to compare the Actual Output with the expected output and against that Log the issues.

When developer resolved with the issues,Start with the Integration Testing and also start testing the resolved state issues and check whether any regression occur due to issue Fixing.

At last when product become the stable one,Then start for automating the the modules. You can also follow automation step by step like:- 1.Automating the modules. 2.Report generation and send mail for product HealthCheck. 3.Continuous Integration and Automation testing on private server on local machine.

Upvotes: 0

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

AUTOMATED TESTING

MANUAL TESTING
As much as I love automated testing it is, IMHO, not a substitute for manual testing. The main reason being that an automated can only do what it is told and only verify what it has been informed to view as pass/fail. A human can use it's intelligence to find faults and raise questions that appear while testing something else.

  • Exploratory Testing
    ET is a very low cost and effective way to find defects in a project. It take advantage of the intelligence of a human being and a teaches the testers/developers more about the project than any other testing technique i know of. Doing an ET session aimed at every feature deployed in the test environment is not only an effective way to find problems fast, but also a good way to learn and fun!
    http://www.satisfice.com/articles/et-article.pdf

Upvotes: 9

hidralisk
hidralisk

Reputation: 706

In the order of most commonly used approach:

  1. no tests at all
  2. manual tests: running the app, clicking or providing input, check results
  3. try to write some JUnits, forget about them, slide to 2 and 1
  4. Start with TDD, see that it's hard then slide to 3, 2 and 1

on the theoretical side there are loads of ways to properly test the code. If you are looking for something practical take a look at Clean Code Talk. Take a look at the whole series, about 5 talks (can't post more than one link).

Upvotes: 2

Johannes Wachter
Johannes Wachter

Reputation: 2735

On the premise of doing testing at all, I would say that testing with JUnit is the common approach to do testing in Java.

Although most tests are written with JUnit mostly tests tend to be more integration tests than unit tests. (meaning not testing one thing in isolation but some things together)

Additionally test are mostly not written in a test first approach but in parallel or after a specific feature has been implemented.

If you go to a team that makes more advanced use of testing you might probably find some CI Server (Cruise Control, Hudson) running the tests at least once a day during a nightly build.

Upvotes: 2

N8g
N8g

Reputation: 636

Personal experience would suggest the most popular approach is none at all.

Upvotes: 7

Borealid
Borealid

Reputation: 98469

Unit testing?

Contract-based programming, a la Eiffel?

Waterfall model?

Different shops do different things. If there were one method to rule them all, you wouldn't be asking this question.

Upvotes: 2

Cambium
Cambium

Reputation: 19392

I've worked with TDD (Test Driven Development) before, and my feelings towards it are mixed. Essentially, you write your tests before you write your code, and write your code to satisfy the requirements of the test. TDD forces you to have an extremely clear idea about your requirements prior to starting. An added benefit is that, once you are done development, assuming you followed closely to TDD procedures, you'd have a complete set of test suites to go with the code. The down side is that it takes an extremely long time, and at times, you'd just want to skip a couple of steps (e.g. maybe writing code before tests like a sane person would prefer to do).

More can be read here (wiki link)

Upvotes: 4

Related Questions