Integration Testing - Reading Assignment

[tchel]

• Why do we write integration tests?
  Verify the functionality, reliability of units and performance.

• What problems do integration tests solve?
  Solves confirmation between the interactions between a programs integrated components.

• What are the differences between top-down and bottom-up approaches?
  Top down starts with end product and works down. Top up starts with the unit testing to end product.

[Crypto-Dylan]

1. It can be considered almost an extension of unit testing. After a unit is tested, integration testing can determine any problems with the implementations of the feature (unit)
2. integrations tests find errors that occur during the complete use of an application. They test whether all the subsystems and interfaces are working individually and together without producing errors. Integrations testing should be simulating real world use of an application.
3. the bottom-up process starts with unit testing followed by progressively higher level testes of combinations of units otherwise known as modules are tested first and progressively lower-level modules are tested thereafter.

[TomasN]

Why do we write integration tests?
A: in order to test numberof units as a group and see how they are working together and if there are any problem once we integrate units together.

What problems do integration tests solve?
A: Integration testing can expose problems with the interfaces among program components before trouble occurs in real-world program execution. It can also point oit to some designs flaws that are not visible in the unit testing.

What are the differences between top-down and bottom-up approaches?
A: Bottom-up integration testing begins with unit testing, while In top-down integration testing, the highest-level modules are tested first and progressively lower-level modules are tested after that.

[Shanghaistu]

1. Why do we write integration tests?
   Integration tests are written to test and evaluate different components of the code individually and in combination with other components
2. What problems do integration tests solve?
   Integration tests can determine if the different functions /procedures /components of the application or code are working together and interfacing appropriately
3. What are the differences between top-down and bottom-up approaches?
   Top-down testing starts with testing of the application in its total / expected solution capacity and then testing in smaller and smaller modules /components of the code to ensure that there are no hidden bugs at the lower level. Bottom-up testing takes the opposite approach and tests the smallest individual components (units) of the code first for errors, then combines into progressively larger modules and combinations of code all the way to the total application in entirety.

[Restford]

1. To try a set of software modules and check their compliance with functional requirements. That is, how well they work with each other.

2. They help identifying problems that occurs when components interact with each other.

3. Top-down starts form higher level functional cases and works then down to smaller components, vice-versa for bottom-up where they test the small components first and then works up towards larger aggregates of code and modules.

[pmgoff]

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? 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? Bottom-up testing is starting at the lowest level units of code and scale upwards the testing to larger modules of code. Top Down testing is start with the highest-level modules first and progressively lower-level modules are tested after that.

[Ozarkshrub]

1. Why do we write integration tests?
   A. To ferret out bugs and issues with different parts of the program not working with others.
2. What problems do integration tests solve?
   B. they make sure each unit, module or build works appropriately with each other.
3. What are the differences between top-down and bottom-up approaches?
   C. Generally you run bottom-up first to ensure each unit works, then each module, and so on. Then you run top-down for proper interfacing.

[Zaqoy]

1. Why do we write integration tests?
   To ensure that our unit tested code function correctly when used together.
2. What problems do integration tests solve?
   Unexpected interactions between different programming functions.
3. What are the differences between top-down and bottom-up approaches?
   Top-down is testing larger sections of code first, while bottom-up is the opposite.

[TuomoP]

@ivan

• Why do we write integration tests?
  To make sure interfaces and other program components work together as intended.

• What problems do integration tests solve?
  Problems in how different (bigger) program components fit together before setting the app live in production.

• What are the differences between top-down and bottom-up 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 then lower-level modules are tested after that.

[rishibehl4]

1. Integration Tests are written to thoroughly test individual units as a whole (group) in multiple ways.

2. Since these tests are meticulous, they expose any issues with the interfaces, which then can be revised, before they happen in the real world. Also, IT allows developers to get an overall view of how all the units are operating together as a whole, which is crucial for the optimal functioning of the software.

3. Bottom-up approach starts with unit testing and then tests modules - combination of units - as a whole. On the other hand, Top-down approach starts with testing higher-modules and then tests lower-level modules.

[AndrewM]

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

integration issues between the units

Bottom up starts with unit testing and works to higher level modules or builds. Top down is the opposite.

[kyliemerk]

Hey guys!

1. Why do we write integration tests?
   Because it can expose problems with the interfaces among program components before coming into problems with real-world program execution.
2. What problems do integration tests solve?
   They identify problems that may occur between components as well as the whole function of the program.
3. What are the differences between top-down and bottom-up 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.”

[BlissBang]

1. Why do we write integration tests?
   I&T can expose problems with the interfaces among program components before trouble occurs in real-world program execution.

2. What problems do integration tests solve?
   Any problems with the program components and units from smallest to biggest component can be checked.

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

Bottom-down usually is done first with the testing of the smallest unit to module to builds and then testing from biggest to the smallest.

[ksmith78]

1. Why do we write integration tests?

To combine and test programs units as groups in multiple ways.

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?

“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.”

[thenode369]

1. Why do we write integration tests?
   To test and evaluate the functional requirements and compliance of a component after testing the units but before testing on a live system.

2. What problems do integration tests solve?
   Poor user experience, loss or incorrect use of data and bad system interoperability. By testing the units and then the integration of these units into larger components, confidence and evidence of required functionality can and performance can be demonstrated.

3. What are the differences between top-down and bottom-down approaches?
   Bottom-up testing starts with each individual units being tested, these are then used to facilitate the higher level component testing. This is repeated again and again until the top level is reached, then integrated with other modules to test and repeat.

Whilst Top-down testing the top level is tested first with each module of each branch being tested step by step until all have been completed.

[Marzio]

1. Components that worked fine with Unit test might still have troubles working together
2. It finds interaction issues between the code of the different components that might also have been developed by different developers
3. Top down test larger modules first and then individual units, bottom-up the other way round

[mitja]

1. Why do we write integration tests?
   To predict what can go wrong with the interfaces among program components.
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?
   The bottom-up process starts with unit testing followed by progressively higher level tests of combinations of units otherwise known as modules or builds.
   In top-down integration testing, the highest-level modules are tested first and progressively lower-level modules are tested thereafter.

[Shinde]

1. It tests all of the components as a single application

2. It solves problems that may arise from components not functioning as a single unit

3. Top-down involves designing the overall application as a whole, then designing the individual units. Bottom-down involves designing the individual units then getting these units to work together.

[ItsCreyzi56]

@ivan

• Why do we write integration tests?
• What problems do integration tests solve?
• What are the differences between top-down and bottom-up approaches?

1. It’s to test the entire code of the application and how the different parts work together. Helps us see if the different parts of the create errors or faults when they work together.
2. It finds errors when the entire application is running. It can find errors in individual interfaces and parts of code, or when the different parts are working together. Essentially it wants to create irl simulation of the usage, and see if it breaks or not.
3. Bottom-up starts from the basic blocks whilst top-down uses bigger parts of the code in testing. Generally better to start with bottom-up, since it shows problems on a “floor” level, which can then be complimented with top-down to get a full picture.

[Emmerich]

1. To test that the app works as a whole.
2. They find errors that Unit Testing did not and they make sure that units comunicate via their interfaces.
3. Top-down goes from the highest level module to the lowest level, and bottom-up does the opposite. Every time a unit is succesfully tested it’s integrated intot he system and tested as a whole.