Reusing Component Test Cases for Integration Testing of Retarding Embedded System Components

2009 ◽  
Author(s):  
A. Marrero Perez ◽  
S. Kaiser
Keyword(s):  
Embedded System ◽  
Test Cases ◽  
Integration Testing ◽  
Component Test ◽  
System Components

scholarly journals Testing embedded systems using test cases generated through combinatorial techniques

2018 ◽  
Vol 7 (2.7) ◽  
pp. 146
Author(s):  
Lakshmi Prasad Mudarakola ◽  
J K.R. Sastry ◽  
V Chandra Prakash
Keyword(s):  
Embedded Systems ◽  
Embedded System ◽  
Traffic Control ◽  
Nuclear Reactor ◽  
Test Cases ◽  
Critical Systems ◽  
Daily Lives ◽  
Intelligent Devices ◽  
Wireless Infrastructure ◽  
Combinatorial Methods

Thorough testing of embedded systems is required especially when the systems are related to monitoring and controlling the mission critical and safety critical systems. The embedded systems must be tested comprehensively which include testing hardware, software and both together. Embedded systems are highly intelligent devices that are infiltrating our daily lives such as the mobile in your pocket, and wireless infrastructure behind it, routers, home theatre system, the air traffic control station etc. Software now makes up 90% of the value of these devices. In this paper, authors present different methods to test an embedded system using test cases generated through combinatorial techniques. The experimental results for testing a TMCNRS (Temperature Monitoring and Controlling Nuclear Reactor System) using test cases generated from combinatorial methods are also shown.

scholarly journals Evolutionary Cost-cognizant Test Case Selection and Prioritization for Object-Oriented Programs

2019 ◽  
Vol 8 (6S3) ◽  
pp. 149-153
Keyword(s):  
Unit Cost ◽  
Object Oriented ◽  
Arbitrary Point ◽  
Regression Testing ◽  
Test Case ◽  
Test Cases ◽  
Test Case Prioritization ◽  
Integration Testing ◽  
Maximum Benefit ◽  
Regression Test

Test case prioritization (TCP) is a software testing technique that finds an ideal ordering of test cases for regression testing, so that testers can obtain the maximum benefit of their test suite, even if the testing process is stop at some arbitrary point. The recent trend of software development uses OO paradigm. This paper proposed a cost-cognizant TCP approach for object-oriented software that uses path-based integration testing. Path-based integration testing will identify the possible execution path and extract these paths from the Java System Dependence Graph (JSDG) model of the source code using forward slicing technique. Afterward evolutionary algorithm (EA) was employed to prioritize test cases based on the severity detection per unit cost for each of the dependent faults. The proposed technique was known as Evolutionary Cost-Cognizant Regression Test Case Prioritization (ECRTP) and being implemented as regression testing approach for experiment.

Direct-Indirect Link Matrix

2020 ◽  
Vol 11 (4) ◽  
pp. 56-69
Author(s):  
Saurabh Rawat ◽  
Anushree Sah ◽  
Ankur Dumka
Keyword(s):  
Software Development ◽  
Software Testing ◽  
Source Code ◽  
Black Box ◽  
Test Cases ◽  
Unit Testing ◽  
Integration Testing ◽  
Testing Technique ◽  
Testing Unit ◽  
Black Box Testing

Testing of software remains a fundamentally significant way to check that software behaves as required. Component-based software testing (CBST) is a crucial activity of component-based software development (CBSD) and is based on two crucial proportions: components testing by developers with the source code (e.g., system testing, integration testing, unit testing, etc.) and components testing by end users without source code (black box testing). This work proposes a black box testing technique that calculates the total number of interactions made by component-based software. This technique is helpful to identify the number of test cases for those components where availability of source code is questionable. On the basis of interaction among components, the authors draw a component-link graph and a direct-indirect-link matrix, which helps to calculate the number of interactions in component-based software.

Test Case Generating for Integrated Modular Avionics Software Health Monitoring

2014 ◽  
Vol 494-495 ◽  
pp. 873-880
Author(s):  
Hui Nan Zhang ◽  
Shi Hai Wang ◽  
Xiao Xu Diao ◽  
Bin Liu
Keyword(s):  
Embedded System ◽  
Health Monitoring ◽  
High Reliability ◽  
Life Cycle Costs ◽  
Test Case ◽  
Test Cases ◽  
Model Driven ◽  
Test Methodology ◽  
Maintenance And Inspection ◽  
Integrated Modular Avionics

Avionics software is safe-critical embedded system and its architecture is evolving from traditional federated architecture to Integrated Modular Avionics (IMA) to improve resource usability. As an architecture widely employed in the avionics industry, supports partitioning concepts. To insure the development of the avionics software constructed on IMA operating system with high reliability and efficiency Health Monitoring (HM) has been shown to be a key step in reducing the life cycle costs for structural maintenance and inspection. In this paper , we propose a model-driven test methodology using Architecture Analysis &Design Language (AADL). It proposes modeling patterns of IMA errors to support the test case generating mechanisms of the HM module, proposing 3 kinds of test cases that can be injected in the HM to stimulate these kinds of errors, and we present the preliminary results that can meet the satisfactory from a ongoing project based on IMA system.

scholarly journals A Neural Network Based Strategy (NNBS) for Automated Construction of Test Cases for Testing an Embedded System using Combinatorial Techniques

2017 ◽  
Vol 7 (1.3) ◽  
pp. 74
Author(s):  
Lakshmi Prasad Mudarakola ◽  
J. K. R. Sastry
Keyword(s):  
Neural Network ◽  
Embedded Systems ◽  
Embedded System ◽  
Test Case ◽  
Test Cases ◽  
Paper Test ◽  
Testing Tools ◽  
System A ◽  
The Neural Network ◽  
Important Concern

Testing an embedded system is required to locate bugs in software, diminish risk, development, repairs costs and to improve performance for both users and the company. Embedded software testing tools are useful for catching defects during unit, integration and system testing.   Embedded systems in many cases must be optimized by engaging crucial areas of the embedded systems considering all factors of the input domain.  The most important concern is to build a place of test cases depend on design of the requirements that can recognize more number of faults at a least rate and point in time in the major sections of an embedded system. This paper proposes a Neural Network Based strategy (NNBS) to generate optimized test cases based on the considerations of the system. A tool called NNTCG (Neural Network Test Case Generator) has been build up based on the method proposed in this paper. Test cases are generated for testing an embedded system using NNTCG and the same are used to determine the expected output through the neural network and the output generated from the actual firmware. The faulty paths within the firmware are determined when the output generated by the neural network is not same as the output generated by the firmware.

scholarly journals On the correlation between testing effort and software complexity metrics

2018 ◽  
Author(s):  
Adnan Muslija ◽  
Eduard P Enoiu
Keyword(s):  
Embedded System ◽  
Execution Time ◽  
Test Cases ◽  
Code Size ◽  
Software Complexity ◽  
Test Execution ◽  
Complexity Metrics ◽  
Cyclomatic Complexity ◽  
Testing Effort ◽  
The Relationship

Software complexity metrics, such as code size and cyclomatic complexity, have been used in the software engineering community for predicting quality metrics such as maintainability, bug proneness and robustness. However, not many studies have addressed the relationship between complexity metrics and software testing and there is little experimental evidence to support the use of these code metrics in the estimation of test effort. We have investigated and evaluated the relationship between test effort (i.e, number of test cases and test execution time) and software complexity metrics for industrial control software used in an embedded system. We show how to measure different software complexity metrics such as number of elements, cyclomatic complexity, and information flow for a popular programming language named FBD used in the safety critical domain. In addition, we use test data and test suites created by experienced test engineers working at Bombardier Transportation Sweden AB to evaluate the correlation between several complexity measures and the testing effort. We found that there is a moderate correlation between software complexity metrics and test effort. In addition, the results show that the software size (i.e., number of elements in the FBD program) provides the highest correlation level with the number of test cases created and test execution time. Our results suggest that software size and structure metrics, while useful for identifying parts of the system that are more complicated, should not be solely used for identifying parts of the system for which test engineers might need to create more test cases. A potential explanation of this result concerns the nature of testing, since other attributes such as the level of thorough testing required and the size of the specifications can influence the creation of test cases. In addition, we used a linear regression model to estimate the test effort using the software complexity measurement results.

Sign in / Sign up

Export Citation Format

Share Document