Integration Testing - Reading Assignment

#21

Why do we write integration tests?

Integration tests are written because they provide an extrememly comprehensive methodology for finding errors before deployment. They combine individual units of code to make sure they work when tested all together.

What problems do integration tests solve?

Integration testing can show us problems with the interfaces in program components before deployment.

What are the differences between top-down and bottom-down approaches?

In Bottoms up testing the smallest parts are tested first with more progressive combinations of parts added until all parts have been tested. In Top down, they begin with larger parts and go down from there to smaller units until the testing gets to the smallest.

#22
  1. Integration testing is to check interactions between all levels of the complete application.
  2. These tests are done to find errors between subsystems.
  3. Top-down begins with testing at the highest level and works down into individual components. Bottom-up begins at the unit level and works up. Top-down is usually done before bottom-up.
#23

1.Why do we write integration tests? A: to test interaction between functional areas/sw-units

2.What problems do integration tests solve? A: they assure interfaces and API’s are correcly used between units/functional-areas.

3.What are the differences between top-down and bottom-down approaches? A: top-down is testing from the overall scope/usecases untill unittesting/whitebox; and bottom-down does not exist but bottom-up if from the unitting tests up to the overall end-2-end application usecases.

#24
  1. Why do we write integration tests?
    To test SW behaves as required on multiple levels of the application, across code units and modules/builds.

  2. What problems do integration tests solve?
    Interface defects, in relational database also the data classes behaviour and querying, can test nondeterministic or multiple threads.

  3. What are the differences between top-down and bottom-down approaches?

** we mean bottom-up

Bottom-up approach starts testing with code units, progressively to higher combinations of units in modules/builds.
Top-down approach testing starts with highest-level of the application like features (Search, Export, Import, etc), down to lower level modules.

#25

Why do we write integration tests?

  • Because is the next natural step when we want to know whether small functions work well together or not.

What problems do integration tests solve?

  • Problems related to the interaction of units of code making up a bigger system, module or builds.

What are the differences between top-down and bottom-down approaches?

  • The differences are related to the initial modules selected to be tested and the subsequent modules to test going down or up respectively the chain of relation between them.
#26
  1. Why do we write integration tests?

They are important to do after unit testing but prior to functional testing.

  1. What problems do integration tests solve?

Integration testing can expose problems with interfaces prior to real-world program execution.

  1. What are the differences between top-down and bottom-down approaches?

In bottom up integration testing, you start with units and combine them in smaller modules and build up (in other words, make the modules bigger by adding units). You continue to test bigger and bigger modules.

In top-down testing, you start testing the biggest modules first, and then work your way down to smaller and smaller modules.

#27
  1. Why do we write integration tests?
    We do integration tests to make sure all the components works together properly and as per expectations. To reduce problems when gone live.
  2. What problems do integration tests solve?
    Integration tests find errors that occurs when the complete use of an application. This is to test if all the interface upstream and downstream works together without issues. This is simulate real work environment when the code is live.
  3. What are the differences between top-down and bottom-down approaches?
    Top-down approach starts with functional test then go to individual unit test whereas for bottom up approach starts with unit test then work up to functional test.
#28
  1. To test program units as groups in multiple ways.
  2. They help to find problems with the program interfaces before product deployment.
  3. Bottom-Up starts with unit testing and works upwards towards modules and builds. Top-Down is the reverse.
#29
  1. Why do we write integration tests?
    to check that all the parts of the software works properly together

  2. What problems do integration tests solve?
    problems with the interfaces among program components before trouble occurs in real-world program execution

  3. What are the differences between top-down and bottom-down approaches?
    In top-down integration testing, the highest-level modules are tested first and progressively lower-level modules are tested after that. Bottom-up integration testing begins with unit testing, followed by tests of of progressively higher-level combinations of units called modules or builds.

#30
  1. Why do we write integration tests? With integration testing, we can expose problems with interfaces among program components before trouble occurs in the real world use. This is why we write integration tests, for software products to do their intended use.
  2. What problems do integration tests solve? It solves problems between interfaces of units, modules and systems.
  3. What are the differences between top-down and bottom-up approaches? Top-down method is testing from higher level modules down to smaller ones. Bottom-up on the other hand is the opposite, starting with unit tests before going up to higher level combinations.
#31

3rd question contains typo, there is no bottom-down approach in integration testing, but there is bottom-up!

  1. Why do we write integration tests?

Integrations test are written to identify problems between interfaces among program components.
In other words to test if parts of software are still working correctly when they work together.

  1. What problems do integration tests solve?

Problems when complete software is not working correctly, when smaller parts of software are working correctly as standalone units, but complete software fails when smaller units are working together.

  1. What are the differences between top-down and bottom-up approaches?

Top-down approach start testing from highest modules of complete software and continues to lower level/standalone modules. Bottom-up starts testing on lover/standalone modules and continues to highest modules of complete software.

#32
  1. Why do we write integration tests? The goal of the integration tests is to verifiy the presence of problems with the interfaces between the components of the program.
  2. What problems do integration tests solve? They locate the presence of errors in the integration of two or more units of the program.
  3. What are the differences between top-down and bottom-down approaches? In the bottom-up approach the testing start with each single unit of the program, and then with single groups of units before to test the whole solution. Instead the top-down approach start to test the whole solution, then single parts and the single units of the entire program.
#33
  1. Why do we write integration tests?
    We do integration tests to test the bigger picture. First units (smallest possible objects to test) then the higher levels that are composed of a bigger number of smaller units. The smallest units eventually have to work together to provide functionality for the bigger picture.
    For example, an application can have different modules / 1 module can contain 25 functions and/or subprograms. Those functions/subprograms could be the smallest units, but all together they are the “module”. The module has to work correctly too, not only the functions and subprograms.

  2. What problems do integration tests solve?
    They make sure the smaller units combined, also behave as intended.

  3. What are the differences between top-down and bottom-down approaches?
    Top down: testing of the bigger picture is done first, then they go down into deeper detail step by step, eventually ending at the level that contains the smallest units possible

bottom-up: it’s the other way around, testing starts with the smallest units possible (unit-testing) and go to a higher next level and repeat it until the testing reaches the top level.

@ivan in the question bottom-down has to be changed to bottom-up

#34

One. Because unit testing is not enough. Once all code goes together it can produce unforeseen problems so you have to test it all together.

Two. Makes your software work as intended, all as a whole. Before launching.

Three. Bottom up testing starts by unit testing and progressively moves to wider combinations of units called modules or builds. Top down starts at a higher level and moves down.

#35
  1. Why do we write integration tests?
    To ensure that the system as a whole is operating as it should be.

  2. What problems do integration tests solve?
    Integration testing finds problems with the interactions between units.

  3. What are the differences between top-down and bottom-down approaches?
    Top down starts from the program as a whole and tests all systems together and then starts testing smaller components of the program. Bottom up testing starts with unit testing and gradually tests multiple components together until you are testing the entire program.

#36
  1. Why do we write integration tests?
    To make sure that the system, as a whole, works as intended.

  2. What problems do integration tests solve?
    It can determine whether or not changing code in one location impacts code in elsewhere. It ensures that all the code works as intended.

  3. What are the differences between top-down and bottom-down approaches?
    Top-down is to determine whether the code as a whole works as intended and then works its way down into the smaller components of the program
    Bottom-up is testing each individual code section separately and then working its way up to the entire program.

#37
  1. Integration tests are written to expose problems with the interfaces among program components before trouble occurs in real-world program execution.
  2. Integration Tests identify problems with the way different program components interact with each other.
  3. Bottom-up testing usually is done first, followed by top-down. Bottom-up is more granular and tests specific units, while Bottom-down tests the highest-level modules.
#38
  1. To test the integration of the program
  2. See if the programs works as a part of the system
  3. Top down is testing the program from bigger part of the code going down to the smaller ones, and the bottom down is the other way around, starting from smaller pieces and adding up