Integration Testing

12 Key excerpts on "Integration Testing"

• 

  No longer available |Learn more

  All About Robotics Software & Important Programming tools

  • (Author)
  • 2014(Publication Date)
  • White Word Publications

    (Publisher)

  Unit testing Unit testing refers to tests that verify the functionality of a specific section of code, usually at the function level. In an object-oriented environment, this is usually at the class level, and the minimal unit tests include the constructors and destructors. These type of tests are usually written by developers as they work on code (white-box style), to ensure that the specific function is working as expected. One function might have multiple tests, to catch corner cases or other branches in the code. Unit testing alone ____________________ WORLD TECHNOLOGIES ____________________ cannot verify the functionality of a piece of software, but rather is used to assure that the building blocks the software uses work independently of each other. Unit testing is also called component testing . Integration Testing Integration Testing is any type of software testing that seeks to verify the interfaces between components against a software design. Software components may be integrated in an iterative way or all together (big bang). Normally the former is considered a better practice since it allows interface issues to be localised more quickly and fixed. Integration Testing works to expose defects in the interfaces and interaction between integrated components (modules). Progressively larger groups of tested software components corresponding to elements of the architectural design are integrated and tested until the software works as a system. System testing System testing tests a completely integrated system to verify that it meets its requirements. System Integration Testing System Integration Testing verifies that a system is integrated to any external or third-party systems defined in the system requirements. Regression testing Regression testing focuses on finding defects after a major code change has occurred. Specifically, it seeks to uncover software regressions, or old bugs that have come back.

  Sign up to read

  Learn more about book
• 

  eBook - PDF

  Fundamentals of Software Testing

  • Bernard Homès(Author)
  • 2024(Publication Date)
  • Wiley-ISTE

    (Publisher)

  Component Integration Testing focuses on the interfaces between components and between the different parts of the software and the system (including the hardware). This includes the interface with the operating system, file systems, database systems, hardware (plugs, voltage, etc.) and software (protocol, messages, etc.); interfaces inside the system or between systems. Based on the granularity of the components, there can be many levels of integration: – integration of software components, typically executed during component integration tests; – integration of software components with hardware components, and integration of these components (hardware + software) together in order to create equipment or sub-systems; – integration of equipment or sub-systems within a higher-order system (such as a system-of-systems), typically executed after the system tests for each of these equipment or sub-systems and before the systems tests of the higher-level system. Testing Throughout the Software Life Cycle 67 Characteristics tested at this level can be functional or nonfunctional, such as those linked to resource usage (CPU, memory usage, etc.), to robustness or to performance, and can also include physical characteristics (such as heat generated or radiation). The type of tests executed at this component integration test level can be based on the architecture of the code (white-box tests) or on the specifications (black-box tests). Component integration tests are frequently executed with the help of development teams and their support. The way in which the components will be integrated depends on how they will be delivered by the development team. Depending on component granularity, drivers and stubs will be used. There are many ways to integrate components, each with advantages and drawbacks.

  Sign up to read

  Learn more about book
• 

  eBook - ePub

  Testing in Scrum

  A Guide for Software Quality Assurance in the Agile World

  • Tilo Linz(Author)
  • 2014(Publication Date)
  • Rocky Nook

    (Publisher)

  5 Integration Testing and Continuous Integration

  This chapter explains the differences between unit and Integration Testing, how to design integration test cases and how to embed them in a fully automated Continuous Integration (CI) environment along with the unit tests we have already written.

  5.1 Integration Testing

  A software system is made up of multiple components. For the system to work properly, each component has to function reliably on its own and, most importantly, all the components have to work together as planned. Integration Testing checks whether this is the case.

  Integration tests check the interaction of the individual components.

  Integration tests are designed to discover potential defects in the interaction of the individual components and their interfaces. In order to perform an integration test, two components are connected (i.e., integrated) and activated by appropriate integration test cases. Fig. 5-1 shows a schematic example of an integration test involving two classes.

  Fig. 5–1 An integration test involving two classes

  The interface of Class A is comprised of methodsa 1 , a 2 , …, a n , while Class B comprises the methods b 1 , b 2 , ..., b m . Both classes have passed all their corresponding unit tests. The integration tests that we will now define test whether A and B work together properly. In our example, the interaction takes place between method b 2 and its call from method a 3 1 . We thus need to check whether b 2 is called correctly and whether it then returns the desired result to A.

  5.1.1 Typical Integration Failures and Their Causes

  Although A and B function correctly on their own, there are various defective behaviors that can turn up when they work in concert. The most important of these are interface failures:

  Sign up to read

  Learn more about book
• 

  No longer available |Learn more

  Software Testing

  A Self-Teaching Introduction

  • Rajiv Chopra(Author)
  • 2018(Publication Date)
  • Mercury Learning and Information

    (Publisher)

  TEST is one of the CASE tools for unit testing (Parasoft) that automatically tests classes written in MS.NET framework. The tester need not write a single test or a stub. There are tools which help to organize and execute test suites at command line, API, or protocol level. Some examples of such tools are:

  7.2. Integration Testing

  A system is composed of multiple components or modules that comprise hardware and software. Integration is defined as the set of interactions among components. Testing the interaction between the modules and interaction with other systems externally is called Integration Testing.

  It is both a type of testing and a phase of testing. The architecture and design can give the details of interactions within systems; however, testing the interactions between one system and another system requires a detailed understanding of how they work together. This knowledge of integration depends on many modules and systems. These diverse modules could have different ways of working when integrated with other systems. This introduces complexity in procedures and in what needs to be done recognizing this complexity, a phase in testing is dedicated to test their interactions, resulting in the evolution of a process. This ensuing phase is called the Integration Testing phase.

  7.2.1. CLASSIFICATION OF INTEGRATION TESTING

  As shown in Figure 7.4 Integration Testing is classified as follows:

  FIGURE 7.4

  We will discuss each of these techniques in the following sections.

  7.2.2. DECOMPOSITION -BASED INTEGRATION

  When we talk of decomposition-based Integration Testing techniques, we usually talk of the functional decomposition of the system to be tested which is represented as a tree or in textual form. It is further classified as top-down, bottom-up, sandwich, and big bang integration strategies. All these integration orders presume that the units have been separately tested, thus, the goal of decomposition-based integration is to test the interfaces among separately tested units.

  7.2.2.1. TYPES OF DECOMPOSITION-BASED TECHNIQUES TOP-DOWN INTEGRATION APPROACH

  It begins with the main program, i.e., the root of the tree. Any lower-level unit that is called by the main program appears as a “stub.” A stub is a piece of throw-away code that emulates a called unit. Generally, testers have to develop the stubs and some imagination is required. So, we draw.

  Sign up to read

  Learn more about book
• 

  eBook - ePub

  Instant Approach to Software Testing

  Principles, Applications, Techniques, and Practices

  • Dr Anand Nayyar, Anand Nayyar(Authors)
  • 2019(Publication Date)
  • BPB Publications

    (Publisher)

  So, the main question is how the organizations develop these stable software systems and how the software systems are contributing effectively in businesses for attaining success by working correctly? The answer is Software Testing. Software Testing ensures that the software systems are efficient, without errors, scalable and as per the organizational requirements. So, nowadays, every small to large scale industries have separate and effective software testing department to test software products before implementing and delivering at the client side.

  Software testing is regarded as the most important component in Software Development Life Cycle (SDLC). It primarily performs the tasks of verifying the software under development to meet the requirements of Verification and Validation and delivering the software within the budget and time frame.

  Software testing is termed as well-laid and defined procedure of detecting and correcting bugs in the software.

  Testing Definition’s & Overview

  In 1979, Glenford Myers defined, “Testing is the process of executing a program or system with the intent of finding errors ” in his book titled “The Art of Software Testing ”.

  In 1983, Bill Hetzel defined “Testing is any activity aimed at evaluating an attribute of a program or systems. Testing the measurement of software quality ” in his book titled “Complete Guide to Software Testing ”.

  Other definitions of testing are as follows:

  • Testing is a concurrent lifecycle process of engineering, using and maintaining testware in order to measure and improve the quality of the software being tested.
  • As per IEEE 610 (Software Engineering Terminology): “The process of operating a system or component under specified conditions, observing or recording the results, and making an evaluation of some aspect of the system or component” .
  • As per IEEE 829 (Test Documentation): “The process of analysing a software item to detect the difference between existing and required conditions (i.e. Bugs) and to evaluate the features of the software items”.

  Sign up to read

  Learn more about book
• 

  eBook - ePub

  Foundations of Software Engineering

  • Ashfaque Ahmed, Bhanu Prasad(Authors)
  • 2016(Publication Date)
  • Auerbach Publications

    (Publisher)

  Once the units of the source code are complete and they are unit tested, they need to be integrated either with the main build of the application or with a branch build where the related units will be integrated. Several issues may arise when one tries to integrate many units of the source code with each other. The interfaces may not be compatible with each other; thus, the components may not be integrated. Integration of different units can happen only when the interfaces are compatible. Interfaces can be incompatible for many reasons. Nowadays, a large number of applications are developed by geographically distributed teams. Each team develops its own piece of application in isolation to the other teams. This leads to some variations in the way the components of the application are implemented at different locations. Similarly, each developer, even inside the same team, implements the units of source code in his or her own way. This, again, causes differences in the implementation of different components. By testing each component for integration, before these components are actually integrated, we can make sure that they will in fact be integrated without problems.

  Figure 9.6 Integration Testing is all about testing the interfaces of the class.

  Unit testing ensures that the business logic is implemented correctly in each class. Unit-tested classes now need to be integrated with other classes that are present in the software build. Integration Testing is done to ensure that your unit-tested classes integrate properly with other classes. Integration of classes happens through their interfaces. A class may have methods that are called inside a method contained inside another class. If the parameters of the called method do not match the method that called it, then there will be integration issues between these two classes. Using Integration Testing, it is possible to determine whether the interfaces of two classes are compatible with each other. Thus, Integration Testing is all about testing the interfaces. Figure 9.6 depicts this reality.

  For example, if you look at the class interest_compute in Section 9.7, you can find that it has the interest_compute method. This method takes a float parameter and returns an integer value. During unit testing, we found that this was giving wrong results. Hence, it was corrected by changing the variable type of the computed result from integer to float. After correction, it takes a float parameter and returns a float value as well. Now, you can create another method where you call this class. Here is the called class:

  Sign up to read

  Learn more about book
• 

  No longer available |Learn more

  Software Testing

  A Self-Teaching Introduction

  • Rajiv Chopra(Author)
  • 2018(Publication Date)
  • Mercury Learning and Information

    (Publisher)

  C H A P T E R 7 Inside this Chapter: 7.0. Introduction 7.1. Unit, Integration, System, and Acceptance Testing Relationship 7.2. Integration Testing LEVELS OF TESTING 7.0. INTRODUCTION When we talk of levels of testing, we are actually talking of three levels of testing: 1. Unit testing 2. Integration Testing 3. System testing The three levels of testing are shown in Figure 7.1. FIGURE 7.1 Levels of Testing. Generally, system testing is functional rather than structural testing. We will now study these testing techniques one-by-one. 236 • SOFTWARE TESTING 7.1. UNIT, INTEGRATION, SYSTEM, AND ACCEPTANCE TESTING RELATIONSHIP We can categorize testing as follows: FIGURE 7.2 We will explain unit or module testing next. Consider the following diagram of unit testing as shown in Figure 7.3. Unit (or module) testing “is the process of taking a module (an atomic unit) and running it in iso- lation from the rest of the software product by using prepared test cases and comparing the actual results with the results predicted by the specification and design module.” It is a white-box testing technique. Importance of unit testing: 1. Because modules are being tested individually, testing becomes easier. 2. It is more exhaustive. 3. Interface errors are eliminated. FIGURE 7.3 Unit Testing. LEVELS OF TESTING • 237 TEST is one of the CASE tools for unit testing (Parasoft) that automati- cally tests classes written in MS.NET framework. The tester need not write a single test or a stub. There are tools which help to organize and execute test suites at command line, API, or protocol level. Some examples of such tools are: S. No. Kind of tool Software description Platforms 1. Deja Gnu testing framework for interactive or batch- oriented applications. Framework designed for regression testing and embedded system testing. UNIX machines 2. E-SIM-Embedded software simulation and testing environment. E-SIM is a native simulator for embedded software. Win 32, Solaris 5, and LINUX 3.

  Sign up to read

  Learn more about book
• 

  eBook - PDF

  Introduction to Scientific and Technical Computing

  • Frank T. Willmore, Eric Jankowski, Coray Colina, Frank T. Willmore, Eric Jankowski, Coray Colina(Authors)
  • 2016(Publication Date)
  • CRC Press

    (Publisher)

  Another note on ambiguity and terminology: software is a fairly young discipline, so some literature or online guides invert the scale of functional and integration tests such that integration tests are proposed as a finer granularity than functional tests, or use “func-tional test” in place of “system test” as the largest scale of test. Presented here, is the more common notion that the major types of tests, ordered from smallest scope to largest scope, are unit, followed by functional, then integration, and finally system tests. 17.4.1 Unit Tests A unit test typically exercises a single function. The goal is to have the finest granularity possible. For object-oriented systems, the unit may be a class, especially if that class has a limited public interface. Many unit test enthusiasts will adhere to a rule of one assertion per test case, but this is not a strict requirement for a test case to be considered a unit test. It is nonetheless preferable to limit the number of assertions in each case and only group together those assertions that are truly related within the project’s domain. Judicious divi-sion of assertions across multiple cases provides the most fine-grained, and thus most informative, feedback. This is particularly true when edge cases for a function or module are involved. 242 Introduction to Scientific and Technical Computing Another important aspect of well-written unit tests is isolation of the test cases from other units of code in the project. In high numbers, unit tests are the most powerful and useful tests to have, as they provide high levels of insight and confidence into the workings of each component of a project. Isolation is one key aspect of this power. As a simple example, imagine a module that issues a greeting to persons in the language of their current location.

  Sign up to read

  Learn more about book
• 

  eBook - PDF

  Software Testing as a Service

  • Ashfaque Ahmed(Author)
  • 2009(Publication Date)
  • Auerbach Publications

    (Publisher)

  So these device drivers are tested against their intended functionality, performance related to memory and processing power usage, and integration with the operating system. Kinds of Software Testing Projects ◾ 27. 2.7. Stage of Software Life Cycle Most people are familiar with software testing activities that are done in regu-lar software development projects. In most books and literature, these activities have been covered in detail. But few books have covered testing activities per-formed in the production environment. Internet applications need to be tested regularly when they are in production. They have become mission-critical applica-tions for the companies who run them. Similarly enterprise applications that are Web based, which many users from customers and suppliers along with company employees use to do their work, also need to be tested periodically to ensure that users are able to use the applications and that there is no downtime due to any hardware or software problems. This is more critical for hosted applications, as the company who owns the hosted application earns its revenue from subscrip-tions. They charge their users by the number of transactions performed in a week or month. Downtime is a complete no-no for these hosted application vendors. So they periodically check functionality and availability of their application to users. 2.8. Outsourced Software Testing An independent software verification and validation service is a new trend that has gained momentum over the last 10 years. Here any software application is to be tested by a software testing service provider. It has been felt that using outsourcing and offshoring coupled with consolidation of projects can bring about tremendous benefits to customers. With mature models, software testing has become an inde-pendent component in the software development which can be outsourced sepa-rately from software development.

  Sign up to read

  Learn more about book
• 

  eBook - ePub

  Software Testing Foundations, 4th Edition

  A Study Guide for the Certified Tester Exam

  • Andreas Spillner, Tilo Linz, Hans Schaefer(Authors)
  • 2014(Publication Date)
  • Rocky Nook

    (Publisher)

  Any nonincremental integration—also called →big bang integration—should be avoided. Big bang integration means waiting until all software elements are developed and then throwing everything together in one step. This typically happens due to the lack of an integration strategy. In the worst cases, even component testing is skipped. There are obvious disadvantages of this approach:

  • The time leading up to the big bang is lost time that could have been spent testing. As testing always suffers from lack of time, no time that could be used for testing should be wasted.
  • All the failures will occur at the same time. It will be difficult or impossible to get the system to run at all. It will be very difficult and time-consuming to localize and correct defects.

  3.4 System Test

  3.4.1 Explanation of Terms

  After the integration test is completed, the third and next test level is the system test. System testing checks if the integrated product meets the specified requirements. Why is this still necessary after executing component and integration tests? The reasons for this are as follows:

  Reasons for system test

  • In the lower test levels, the testing was done against technical specifications, i.e., from the technical perspective of the software producer. The system test, though, looks at the system from the perspective of the customer and the future user.12 The testers validate whether the requirements are completely and appropriately implemented.
  • Many functions and system characteristics result from the interaction of all system components; consequently, they are visible only when the entire system is present and can be observed and tested only there.

  Example: VSR-System tests The main purpose of the VSR-System is to make ordering a car as easy as possible.

  While ordering a car, the user uses all the components of the VSR-System: the car is configured (DreamCar ), financing and insurance are calculated (Easy-Finance , NoRisk ), the order is transmitted to production (JustInTime ), and the contracts are archived (ContractBase ). The system fulfills its purpose only when all these system functions and all the components collaborate correctly. The system test determines whether this is the case.

  The test basis includes all documents or information describing the test object on a system level. This may be system requirements, specifications, risk analyses if present, user manuals, etc.

  Sign up to read

  Learn more about book
• 

  eBook - ePub

  Software Engineering for Embedded Systems

  Methods, Practical Techniques, and Applications

  • Robert Oshana, Mark Kraeling(Authors)
  • 2019(Publication Date)
  • Newnes

    (Publisher)

  Perhaps more importantly, a fundamental requirement of software testing is to provide an objective, independent view of the software. The very intimate code knowledge required to manually construct a harness compromises the independence of the test process, undermining the legitimacy of the exercise.

  6.5 The Legacy From High-Integrity Systems

  In developing applications for the medical, railway, aerospace, and defense industries, unit test is a mandatory part of a software development cycle—a necessary evil. For these high-integrity systems, unit test is compulsory and the only question is how it might be completed in the most efficient manner possible. It is therefore no coincidence that many of the companies developing tools to provide such efficiency have grown from this niche market.

  In more mundane environments, perceived wisdom is often that unit testing is a nice idea in principle, but commercially unjustifiable. A significant factor in that stance is the natural optimism that abounds at the beginning of any project. At that stage why would anyone spend money on careful unit testing? There are great engineers in the team, the design is solid, and sound management is in place. What could possibly go wrong?

  However, things can and do go wrong, and while unit test cannot guarantee success it can certainly help to minimize failure. It therefore makes sense to consider the principles proven to provide quick and easy unit tests in high-integrity systems in the context of less demanding environments.

  6.6 Defining Unit, Module, and Integration Test

  For some the terms “unit test” and “module test” are synonymous. For others the term “unit” implies the testing of a single procedure, whereas “module” suggests a collection of related procedures, perhaps designed to perform some particular purpose within the application.

  Using the latter definitions manually developed module tests are likely to be easier to construct than unit tests, especially if the module represents a functional aspect of the application itself. In this case most of the calls to procedures are related and the code accesses related data structures, which makes the preparation of the harness code more straightforward.

  Sign up to read

  Learn more about book
• 

  eBook - PDF

  Software Testing

  • Yogesh Singh(Author)
  • 2011(Publication Date)
  • Cambridge University Press

    (Publisher)

  This is manual testing and involves only looking at the documents in order to ensure what comes out is what we expected to get. Validation: As per IEEE [IEEE01], “It is the process of evaluating a system or component during or at the end of development process to determine whether it satisfies the specified requirements.” It requires the actual execution of the program. It is dynamic testing and requires a computer for execution of the program. Here, we experience failures and identify the causes of such failures. Hence, testing includes both verification and validation. Thus Testing = Verification + Validation Both are essential and complementary activities of software testing. If effective verification is carried out, it may minimize the need of validation and more number of errors may be detected in the early phases of the software development. Unfortunately, testing is primarily validation oriented. Introduction 21 1.3.3 Fault, Error, Bug and Failure All terms are used interchangeably although error, mistake and defect are synonyms in software testing terminology. When we make an error during coding, we call this a ‘bug’. Hence, error / mistake / defect in coding is called a bug. A fault is the representation of an error where representation is the mode of expression such as data flow diagrams, ER diagrams, source code, use cases, etc. If fault is in the source code, we call it a bug. A failure is the result of execution of a fault and is dynamic in nature. When the expected output does not match with the observed output, we experience a failure. The program has to execute for a failure to occur. A fault may lead to many failures. A particular fault may cause different failures depending on the inputs to the program. 1.3.4 Test, Test Case and Test Suite Test and test case terms are synonyms and may be used interchangeably. A test case consists of inputs given to the program and its expected outputs.

  Sign up to read

  Learn more about book