BLOG

The Kinds of Testing in System Development: Unit, Integration, System and Acceptance

System development testing is divided by the size of the range it checks into four kinds: unit test, integration test, system test and acceptance test. It starts with a small part and widens the range step by step: joined parts, the whole, and then real work.

The first three are done mainly by the development company, and the last, the acceptance test, by the buyer. The buyer checks the company's tests through reports, and checks in the acceptance test whether the system works for their own business.

In this article, "the buyer" means the company that commissions the system. We cover what each of the four kinds of test checks, who runs it, and what the buyer receives and where to look. The model contract cited here is a Japanese one.

If you want an estimate that includes how testing is done, use our free estimate consultation.

A figure of the range each of the four kinds of test checks. The unit test checks one part, the integration test checks joined parts, the system test checks the whole system, and the acceptance test checks the system used in real work

About the author

wesionaryTEAM Editorial Team

The editorial team is made up of wesionaryTEAM's project managers and engineers. Drawing on what we learn every day on business system, AI adoption and digital transformation projects, we publish information people can use when making decisions, with cases and figures.

There are four kinds of test, each with a different range

By the commonly used names, there are four kinds of test.

  • Unit test. Checks that each part of the program works correctly on its own.
  • Integration test. Checks that the parts exchange data correctly when joined.
  • System test. Checks that the whole system works as designed. Things such as processing speed are also checked here.
  • Acceptance test. The buyer checks that the system can be used in real work.

Take an order-taking system as an example. The unit test checks that the part that calculates the amount gives the right answer. The integration test checks that the order screen and the stock part connect. The system test checks that an order goes through to shipping as designed. The acceptance test checks that staff can process an order in their usual way. This is an example for illustration.

A figure of where the cause has to be looked for when a problem appears. In the unit test it is within one part, in the integration test among the joined parts, in the system test in the whole system, and in the acceptance test along the whole workflow

Testing starts from a small range because the cause of a problem is then easier to find. If a problem appears after the whole system is run, it takes effort to pin down which part caused it. A problem found at the level of a part is solved by fixing that part.

The names differ by company

The names of the tests and where they are divided differ by development company. Some companies call the system test a "comprehensive test", and some split the integration test into two stages.

The Model Transaction and Contract for Information Systems, published by the Information-technology Promotion Agency, Japan (IPA) and the Ministry of Economy, Trade and Industry, is a template contract. It uses the names "software test", "system integration", "system test" and "operation test". The template itself points out that the terms have no clear definitions and that the same thing is often expressed in different words.

A figure showing that the tests have two sets of names. The commonly used names are unit test, integration test, system test and acceptance test. The model contract uses software test, system integration, system test and operation test. The boundaries differ by company

If an estimate lists a test with a name you do not know, ask the development company what the test checks. The range it checks matters more than its name.

Each test pairs with a design document

A test is the work of checking that what was written in a design document has been realised. The model contract presents the idea that design and testing come in pairs.

A figure of the pairs of design documents and tests. The requirements document is checked by the operation test, the external design by the system test, the internal design by system integration, and the software design by the software test
  • What was decided in software design is checked in the software test.
  • What was decided in internal design is checked in system integration. Internal design decides the mechanism inside the system.
  • What was decided in external design is checked in the system test. External design decides the parts users see, such as screens and forms.
  • What was decided as requirements is checked by the business units in the operation test.

The last two matter to the buyer. The screens and forms, and the business needs, are things the buyer decided. What is not written in a design document cannot be checked in a test either. The quality of testing is largely set by what was decided, and how far, at the design stage.

Who runs it depends on the test

The earlier tests are run by the development company. The model contract describes the software test and system integration as phases verified on the development company's responsibility.

The system test is a little different. Because the system test extends to tests that include the buyer's business processes, the model contract says that, when it is done under a fixed-price contract, the buyer needs to present clearly the test items, content, method and criteria. A fixed-price (ukeoi) contract is one that promises the completion of a deliverable.

The buyer sets the criteria because the development company cannot decide alone what counts as a pass. Whether something is right along the flow of work can only be judged by the side that knows the work.

A figure of who carries each test. The software test and system integration are run on the vendor's responsibility. In the system test the buyer takes part by setting the criteria. Acceptance testing is run by the buyer, with the vendor's support

The final acceptance testing is done by the buyer, and the development company supports it. The model contract also says that the development company supports the buyer's acceptance review and test.

What the buyer receives is the specification and the result report

The buyer does not need to check, one by one, the tests the development company ran. What the buyer receives is the test specification and the result report.

As examples of deliverables, the model contract lists a "software test specification and result report" and a "system test specification and result report". A specification is a document that states what is checked and how.

A figure of an example test result report with three numbered places: the number of items planned and run, the number of defects found and fixed, and the defects still open and how they will be handled

In the report, look at three things.

  • Whether all the planned items were run.
  • How many defects were found, and how many of them were fixed.
  • Whether any defects are still open, and if so, when and how they will be handled.

That defects were found is not bad news in itself. Testing is the work of finding defects. What you check is how the defects that were found were settled.

Decide before the contract when you will receive the reports and where they will be explained. A document alone does not help if you do not know how to read it. Ask the development company to explain it in person.

What the buyer need not look at, and what the buyer should

The buyer does not need to read the inside of the programs or the records of tests on each part. That is the range the development company carries on its own responsibility.

A figure of what the buyer looks at and what is left to the vendor. Left to the vendor: the inside of the programs and the records of tests on each part. The buyer looks at the test result report, how the screens and forms behave, and whether the system is usable at work

What the buyer looks at is the part that concerns what the buyer decided: whether the screens and forms are as decided, and whether the system can be used along the flow of work. The development company cannot judge this, because the buyer is the one who knows the work.

Cutting the testing period brings more defects after go-live

When the schedule gets tight, the testing period is often the first thing to be cut. But what is cut comes back later.

The Software Metrics Survey 2025 of the Japan Users Association of Information Systems (JUAS) compares projects whose planned period was at or above the standard with those below it. The average number of defects found in the buyer-side system test was 27.5 and 28.3, with no large difference. Yet the average number of defects found in early operation after go-live was 5.94 and 11.2.

A figure of the planned period and the number of defects. The average found in the buyer-side system test was 27.5 for projects planned at or above the standard period and 28.3 for those below it. The average found in early operation was 5.94 at or above the standard and 11.2 below it

In the projects with a short period, defects that testing did not catch came out after the system went into use. The figures are averages over the responding companies' projects, but the tendency is a useful guide.

In the same survey, the buyer-side system test took 16% of the whole development schedule. The buyer, too, needs to set aside time and people for testing in advance.

How we work

We manage quality in line with international standards. On the quality screen of our project management tool, projectAI, we share the following with you.

  • Overall quality. A dashboard shows the quality score, readiness for release and open bugs by severity.
  • Quality accounting. We cross-tabulate the phase where each bug was introduced against the phase where it was found, to check that bugs introduced in early phases are caught early. Test density and bug density are compared with reference values published by IPA.
  • Bug reports. Defects found are registered and followed until fixed. You can register them too.
  • Test cases. We write and submit a test specification for each function, and every test case can be seen on this screen.
  • Incident management. Failures after go-live are recorded and followed through cause and countermeasure.
How we work: on the projectAI quality screen you can switch between the quality score and open bugs, the tally of the phase where bugs were introduced against the phase where they were found, bug reports, test cases and incident handling

We do not wait until every function is ready: once a function has finished testing, we send an acceptance request through projectAI. You can run the acceptance test while seeing what has already been checked. Early comments are applied to the functions still being built, which keeps rework small. We explain how we manage quality in our free estimate consultation.

FAQ

What is the difference between a unit test and an integration test?

The range they check. A unit test checks the parts one by one, and an integration test checks the exchange between parts once they are joined. Even when each part is correct on its own, a problem can appear when they are joined.

Are the system test and the acceptance test the same?

No. The system test checks that the whole system works as designed. The acceptance test checks that the buyer can use it in real work. The person checking and the criteria differ.

Who writes the test specification?

The development company writes the specifications for the tests it runs. The model contract, too, lists the software test and system test specifications and result reports among the items the company delivers. What to check in the acceptance test is decided by the buyer.

Does the buyer need to attend every test?

No. For the tests the development company runs, you confirm the results in the report. What the buyer does itself is the final acceptance testing.

Summary

Tests are divided into four kinds by the size of the range they check: a part, the joints, the whole, and the work. The development company runs the earlier ones, and the buyer confirms the results in the report. At the end, the buyer checks in its own work.

We manage quality in line with international standards and share test cases and the status of defects with you in projectAI. Even if what you want to build is not yet settled, please use our free estimate consultation.

Related articles and pages

Sources

Reviewed by

Ichiro NagataCEO and Representative Director

A former engineer at Yahoo! JAPAN. For more than 18 years at startups and large companies, he has worked on a wide range of projects, from new consumer and business ventures to the digital transformation of operations. Alongside hands-on development as an engineer, he has built and managed teams, designed businesses and tested hypotheses, gaining broad experience in launching and growing businesses. He has been through three business sales. Convinced that co-creation makes products better and lets ideas be tested in the market, he founded wesionaryTEAM to offer a co-creation platform.