Integration Testing - Reading Assignment

[marc.berchtold]

1. Why do we write integration tests?

To guarantee the functionality of the system.

2. What problems do integration tests solve?

The detection of errors in the interaction of the individual components and systems.

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

The primary difference between the top-down and bottom-up integration testing is that the top-down integration testing utilizes the stubs for calling the submodules subordinated to the main function while in bottom-up
integration testing the stubs are not needed instead drivers are used.

[laserkavajen]

Why do we write integration tests?

To expose faults in the interaction between integrated units.

What problems do integration tests solve?

A lot of benefits see the list:

It makes sure that integrated modules work properly as intended

The tester can start testing once the modules to be tested are available

It detects errors related to the interface between modules

Helps modules interact with API’s and other third-party tools

Typically covers a large volume of the system, so more efficient

Increases the test coverage and improves the reliability of tests

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

Top-down approach is to break a complex problem into smaller segments called modules. How to do this is with step-by-step process of breaking down the problem into chunks for organising and solving the sole problem. In the bottom-up approach developer works exactly opposite from the most basic level of problem solving and moving in conjugation of several parts of the solution to achieve required result.

[Raf.PV7]

1. Why do we write integration tests?

Because Integration testing can expose problems can expose problems with the interfaces among programs components before trouble occurs in real-world program execution.

2. What problems do integration tests solve?

Problems with interfaces among components

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

• Bottom-up begins with unit testing then by modules form bottom to top.
• Top-down the highest-level modules are tested first and progressively lower level modules after that.

[doodesville]

1. Why do we write integration tests?
   We write integration tests to test the individual components and make sure everything is running properly, before the product goes out to customers in the real-world application.
2. What problems do integration tests solve?
   Integration testing can expose problems with the interfaces among the components before trouble occurs in real-world program execution.
3. What are the differences between top-down and bottom-up 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 progressively higher-level combinations of units called modules or builds.
   In a comprehensive software development environment, bottom-up testing is usually done first, followed by top-down testing.
   The process concludes with multiple tests of the complete application, in scenarios designed to mimic those it will encounter, in customers computers, systems and networks.

[ANV81]

1. Why do we write integration tests?
   To make sure all units of the program work as a whole before launching in real world use.

2. What problems do integration tests solve?
   It tests to see if all parts of the program work together, and also tests to see if it works in conjunction with other interfaces.

3. What are the differences between top-down and bottom-down approaches?
   Top-down testing begins at the highest level modules first and then progressively downward into the separate units. Bottom-up testing begins with unit testing, followed by higher level testing combining the units.

[ThreeHeadsUp]

1. testing an application or whatever kind of code one writes in order to confirm it works as intended is probably self explanatory, unless it is by design to choose to make something that does not work as intended; integration tests allow us to see where points of failure in a code occur, if future tests need to be done, how certain functions might provide false positives and how different modules interact with one another, or how they perform as a complete chain of a multitude of modules
2. they can point to points of failure between different modules inside the code as the tests are focused on the chain of events between them, checking connections and integration of all the required subsystems or modules
3. top down approaches of testing start with the last layer of integration or the whole picture and gradually moves down to smaller modules, which sometimes gives valid, but also completely wrong test-answers; bottom up testing first tests smaller modules and progressively moves up the chain to confirm each smaller part work as intended, as then usually, also the higher-up parts will work afterwards; it would be wise to use a hybrid approach when testing, utilizing both

[Danieljd]

1. Why do we write integration tests?
   With integration testing, program units are combined and tested as groups in multiple ways. We do this as it can expose problems with the interaction of all of the units together.
2. What problems do integration tests solve?
   The errors from the interaction of the units
3. What are the differences between top-down and bottom-down approaches?
   Top down: Highest level (most important) modules are tested first and thereafter lower level modules are tested
   Bottom down: Begin with unit testing and work your way up to higher level combination of units called modules

[sto]

1 To see if units are fully collaborating

2 Integration tests aim is to expose problems with inn the program components before they appear in use

3 Bottom-down, stock on the bottom.

Bottom-up, runs a unit test first then proceeds to higher level combined modules

Top-down, runs the highest level modules first

[Marc-C]

1. Why do we write integration tests? Integration testing can expose problems with the [interfaces]among program components before trouble occurs in real-world program execution.
2. What problems do integration tests solve? problems in how components interact with each other
3. What are the differences between top-down and bottom-down approaches? Bottom-up integration testing begins with [unit testing]followed by tests of of progressively higher-level combinations of units called modules or builds. In top-down integration testing, the highest-level modules are tested first and progressively lower-level modules are tested after that.

[jostrings]

1. Why do we write integration tests? - To expose problems in the interface

2. What problems do integration tests solve? - You have a good chance if done right to avoid unnecesary problems when your application or software are used by your customers

3. What are the differences between top-down and bottom-down approaches? -
   Top-down is about testing the higher module first and ending up with the units, but in the Bottom-up method, you will start with the units and end with the higher modules

[Ernesto]

1.In order to test larger modules of functionality. It might introduce conditions that unit tests can not anticipate.
2.Unexpected interactions between programming functions.
3.Top down starts with high-level functionality and works towards to unit tests and Bottom-Up is the opposite.

[Beasley23]

1. Why do we write integration tests?
   —So that it can highlight issues that occur with the interfaces in the program components before real world problems occur with the program
2. What problems do integration tests solve?
   —to identify issues in the program and how the units interact with each other
3. What are the differences between top-down and bottom-down approaches?
   —bottom up testing starts at unit testing and they moves up to testing a combination of units (modules/builds)—top down testing starts with testing the highest level of modules followed by smaller ones

[Laszlo_Leonardo]

1. integration test are used to verify performance and a clean running of the software…units of software are getting added together, than I believe you start testing the different modules and this is the process to integrate the software
   2 helps to improve broken database, mistaken cache integration…it is easier to locate and find the failures
2. top down is from big to small components testing so main functions are written first than the subroutines get called from it and bottom up is starting with unit testing, modules get created and then get integrated to the main function…In my understanding bottom up you are working to and testing from the smallest unit to modules to integration and in top down you actually do it the opposite way

[Crista]

Why do we write integration tests?
In order to detect problems in a program before they unfold in real world use.
*** What problems do integration tests solve?
The tests can expose problems with the interfaces in the components of a program.
*** What are the differences between top-down and bottom-down approaches?
Bottom-up testing begins with unit testing before moving on to higher level combinations of units. Top-down testing tests the highest level modules first before moving on to the lower level ones.

[VICBTC]

1. **Why do we write integration tests?
   These tests are written to expose problems with the interfaces among program components before trouble occurs in real-world program execution.
2. What problems do integration tests solve?
   They identify problems with the way different program components interact with each other.
3. What are the differences between top-down and bottom-down approaches?
   In top-down testing, the highest-level modules are tested first and progressively lower-level modules are tested after. The bottom-up process starts with unit testing followed by progressively higher level tests of combinations of units otherwise known as builds.

[minimull]

• Why do we write integration tests?

1. To expose problems with the interfaces among program components before issues occur in the real-world program execution.

• What problems do integration tests solve?

2. Can expose problems with the interfaces and the code in them.

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

3. Bottom up starts with the parts and then the whole.
   Top down starts with higher level modules first, then to the lower level ones.

[Crypto_Daddy]

1. It can expose interface problems and program components before they have real world problems

2. solves real world issues that can happen when actual users and using the interface and components

3. bottom up tests units followed by high level combinations of units and then texts modules to test bugs while developing and then top down can be tested

[vezuchiy]

1. Integration tests confirming that all units work together and continue to work when new units are added/removed/changed.
2. Integration testing can expose problems with the interfaces among program components before trouble occurs in the real world program execution.
3. Top-down starts by testing of main functions and modules and works downward. Bottom-up starts with units testing individual functions and works upward.

[Hirbed]

Reading Assignment: Integration Testing

1.Why do we write integration tests?

To test all software parts together to find out problem between different components in the chain, before they will exposed in the open world.

2.What problems do integration tests solve?

Integration testing can expose 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

[Zachary21]

1. So we can take care of any possible issues before things actually go live in a real world application.

2. It finds interaction problems of source code components.

3. Top down - Start with high level complexity and then works back into the smallest unit looking for errors.

Bottom down - Starts at the unit level and expands in scope as the testing progresses.