Structural Testing in Software Testing

Structural Testing in Software Testing and Evaluation

Software testing and evaluation is a necessary practice in computing owing to its ability in providing stakeholders with information concerning the effectiveness and quality of products under evaluation. Its capability to present independent and objective view of the software's extends business with the ability to understand and appreciate the risks that may come with the implementation of the products and services in question (Copeland, 2004). The process, which continues to present challenges to the stakeholders in however very significant to the success of software projects. According to Blokdijk (2008), the process of testing and evaluating software come in different fashions with one example being the structural technique. This procedure relates to the testing and exposure of errors during the coding stage has much of its focus on the activities that undergo within applications. This report explores the various aspects of the structural technique of software testing and evaluation and provides an overview of the testing procedure. The work presents the background of the study, providing the substance of the research materials used. It gives an analysis that represents personal opinions on the topic and addressing the means by which the subject areas, potential research areas included, can improve. It summarizes the discussion by reaffirming the research topic and recapping the personal viewpoint. The paper then concludes with a summary of the entire content of the discussion.

Background

Desikan and Ramesh (2006) in the publication "Software Testing: Principles and Practice" illustrate that structural software testing and evaluation take into consideration the internal design of the applications and their coding mechanisms together with the codes and the code structures. This form of testing is automated, run by a computer within the products and this distinguishes them from other forms of testing. Additionally, the structural testing involves running the real products against various pre-structured test cases to exercise the code as much as it is essential or achievable. In order to achieve this, the testing program exercises the code to determine whether a case of a test would lead to the execution of that segment of the code. This occurs while the test is running. One of the mode by which they classify Structural testing encompasses code coverage, code/unit functional testing, and code complexity testing.

The code functional testing phase constitutes the foremost part of software testing and evaluation. It refers to the process by which software developers undertake various speedy checks before exposing the code to tests that are further far-reaching coverage testing or code complexity testing (DeMillo, 1987). This process may undertake diverse forms. The developer, with knowledge of the input variables and the equivalent expected outputs may undertake some apparent operations. This involves quick tasks for checking evident problems. The other approach includes the construction of the productivity's debug version, an operation that is widespread in software with multifaceted conditions or logic (Desikan & Ramesh, 2006). The developer, in this case institutes transitional print statements and certifies that the program goes through the appropriate loops and iterations, the accurate number of times. Another method is the running of the products through the IDE (Integrated Development Environment) or a debugger.

With respect to the code coverage segment, the software developers run test cases with the view of exercising the many segments of the code. The developers follow by testing the portion of the products which the code recognized. This involves structuring and executing test case, besides establishing the portion of the code that the test covers. Determining the code percentage, that test cover's constitutes the adoption the instrumentation of code. This method puts to use a variety of tools and rebuilds the products besides linking it with a set of libraries that the tool vendors produce. In addition to evaluating and inspecting the covered percentage of the code, the instrumentation process allows reporting on the frequently covered parts of the code with the view of identifying the most vital ones. The types of code coverage anonymous with code coverage testing include, function coverage, path coverage, conditional coverage and statement coverage (Desikan & Ramesh, 2006).

Graham (2008), Code complexity testing encompasses among other measures, Cyclomatic complexity and attempts to provide answers to questions that relate to the complexity of the software testing process. The questions that this approach addresses are the independence of the paths and the presence of limits on the number of tests the developers require to run in guaranteeing the execution of all statements. This approach gives the internal view of the code by delivering to stakeholders, an upper leap for the quantity of tests that necessary for the codes.

Different from the other approaches of software testing and evaluation, structural technique presents a wide range of advantages. According to Perry (2006), the effectiveness of this method comes in its ability to establish the types of data, both input and output, which aid in appropriate testing the application. This is because of the fact that the developers have to possess an in-depth understanding of the internal coding structure of the software. Structural testing constitutes a process where testing involves the use of the internal logic knowledge in generating a theoretical test case. The approach, which is also called white box helps the developers attain code optimization and assists in the removal of additional lines of codes, which have the capacity to cause concealed defects to the software. Moreover, this method of testing encourages careful reasoning prior to implementation leading to the production of best possible applications. Because of the benefits that this approach extends to systems and their corresponding developers, this approach aids in the early detection of errors (Desikan & Ramesh, 2006).

No single approach in information technology and software development constitutes purely ideal processes, as there always exist some shortcomings with the processes. This explains why different stakeholders frequently participate in scientific research as a means of finding answers to the existing issues. As such, structural testing also brings to the fore a number of disadvantages and whose need to address is critical. The disadvantages that this approach has, in contrast to other methods like the functional approach, include the heightened cost of undertaking the testing and evaluation procedures. This is in line with the requirement that the professional possesses comprehensive knowledge of the internal design and the codes of the application under test. Only a true expert can qualify, therefore, to explore such an assignment. Besides, situating every bit of the code in as an effort to identify concealed and potentially problematic errors, as the method requires, is a close to impossible operation. These errors have the capacity to cause systems to fail, and in instances where establishing the codes become problematic, this testing approach becomes insignificant (Perry, 2006).

The approach may lead to undesirable structural and operations changes of the applications under evaluation. The fact that almost all test procedures in this method require changes in the program and the modification of values makes the inconvenience, sometimes inevitable. These alterations are necessary for compelling diverse paths of execution in addition to the creation of a full range of inputs to evaluate a particular function. Other disadvantages that associate with the structural testing method are the evasion of the need for considering the code in the runtime environment and the possibility of stakeholders missing the cases, which are already, lost in the application. The former reason eliminates the benefits of software testing because the management of susceptibility relies on all characteristics of the platform, which is under target together with those components' source codes (Copeland, 2004). The third party security apparatus reliant, libraries, the fundamental operating system, and the backend database in use, among other features need consideration when establishing exploitability.

Analysis

The need for the development of more and increasingly effective application in the information-oriented society is quite extensive. The increasing sophistication in the face of the globe together with the demand for systems, which can achieve all purported tasks effectively, is increasing and as such, serious measures of evaluating these systems is a prerequisite. The availability of different mechanism of software testing, to a considerable length, complements this need. Further, the use of highly automated approaches, says the structural testing method goes a long way in enhancing the effectiveness of software application in the field of information technology. Structural software testing and evaluation mechanism, in itself presents a variety of advantages as addressed in this paper. The fact that this mechanism allows for the an automated and more accurate process of automation in addition to complementing what the functional test can do provides the stakeholder with closer to the best approach of ensuring system functionality (DeMillo, McCracken, Martin, Passafiume, 1987). This however, has not made it the most ideal mechanism for software testing and explanation. More researchers are conducting studies in filling the gaps that the approach has not filled, especially with reference to the disadvantages that it presents.

As Graham (2008), demonstrates, Self-managed applications requires evaluation and changes of codes in program execution. This in a way indicates that the capacity structural testing has in achieving this goal is rife. Considering the level of effectiveness that this procedure has, the assumption that many developers use it as part of software development is not out of the ordinary. It is evident that the development of useful applications, say those associated with dynamic code optimization and code vulnerability checkers has this process embedded in their development and application. Additionally, the process of instrumentation appears widely in the development of these applications. This however limits the functionality of the application owing to the fact that the aspect of instrumentation is usually, custom made to an explicit application and infrastructure. What the structure therefore, lacks encompass flexible and scalable instrumentation framework with the ability for utilization in different applications. Current research studies focus on improving such limitations.

It could not be wrong for anyone to note that Software testing procedures constitute have critical problems, which are undecidable. However, the improvements made in the field with respect to the same feature are notable and therefore should not be underestimated. The initiatives that different researchers take in concentrating on diverse testing techniques, coupled with the identification of coding errors, gets credit for these sorts of improvements.

Since time immemorial, Realistic software ventures have adopted the notion of a statement and branch coverage and uncomplicated test strategy for structural testing. There is substantial research activity in the areas of data flow testing, in which these simpler coverage processes are in discriminated to increasingly influential data flow coverage standards. Considering the fact that these features have to date, not reached their full potential, there need to be more experimental activities with them with the participation numerous software professionals very imperative.

With the structural testing procedures, we have witnessed limitations. This is irrespective of the fact that it constitutes one of the most effective software testing and evaluation procedures accessible to different application developers. One of the approaches advanced with this respect is the introduction of evolutionary testing. According to Wegener, Baresel and Sthamer (2001), this mode of testing makes use of evolutionary algorithms with practical testing being widespread in Object Oriented Programming like C. programming. This fear categorizes structural testing into four portions and include node -- node oriented, path oriented, node oriented and node-path oriented approaches. The invention also incorporated the concept of fitness function which is based specific applications which can be used in evaluating individuals developed in line with test objects branching conditions. The evolutionary approach is believed to have the capacity for enhancing more goal oriented activities in software development and the elimination of as many errors as possible. The fact that the structural method of testing constitutes a variety of disadvantages, its high position among other programs notwithstanding, makes the application of the likes of evolutionary approaches considerable effective.

The identification of the specific problem area in structural testing is a very key element in dealing with the problems that limit the benefits that the procedure offers to the world of software development. Addressing each and every limitation in the procedure would help not only make it the best ever software testing technique but will enhance its application all though the practice of software development. Some of the problem areas that require addressing include, the need for extensive coding and structural knowledge of the applications, the requirement that each and every bit be considered in testing and the modification of the program. Considering that the use of high expertise cause the process to be so costly, training more and more experts in the field would solve the problem. The increasing demand for better developers of the day will however not make this approach quite effective. The other means through which solution to this problem can be achieved is to institute a procedure where, not so much knowledge of the structures of the codes is required in enabling individuals to undertake the required test, this however should take into consideration the maintenance of the quality of the mechanism. Creating room for the elimination of such requirement should therefore, neither compromise the quality of the approach nor inflate the cost of performing the tests. Additionally, the researchers should focus on measures that make this testing approach practical without the need of the elimination or modification of certain components in the mechanism and including the capability the practitioners can examine the code in a runtime environment among other corrections.

Summary

In the contemporary world, every activity is becoming, fast paced and stakeholders express the need for applications that can help them achieve their goals speedily and without compromising quality. The frequent advancements that occur in the world of information technology and software development seem to take this need very seriously. The developments of software testing and evaluation mechanism extensively complement the satisfaction of these needs. Furthermore, the focus of developers in generating test mechanisms that provide a wide variety of advantages is very prominent. Structural software testing approach constitutes one of the best practices in software testing and evaluation. As Desikan & Ramesh (2006) demonstrate, this automated approach to testing applications has a great a capacity in debugging the programs, limiting the errors, and facilitating the production of the state of the art software applications.

Structural testing, for developers takes three main stages namely, code coverage, code/unit functional testing, and code complexity testing. These categories serve different purposes in the testing process and operate at different levels in the structural testing. Additionally, they constitute sub-categories, which entail the steps, and procedures that cumulatively describe the structured approach to software testing and evaluation. The code or unit functional evaluation relates the initial, speedy, and simple task and constitutes checking of obvious issues, creation of debug version, and the institution of transitional print statements (DeMillo, 1987). The code coverage segment, on the other hand constitutes the running of test cases, testing recognized portions and instrumentation while the code complexity test relates to the provision of explanations over the independence of the paths and the availability of limits on the number of tests to run in guaranteeing the statement's execution (Desikan & Ramesh, 2006).