Software Testing Social Network

LoadRunner is a tool, or more accurately a collection of tools, which facilitates in
performing load testing on a system. LoadRunner is used to create a load or stress on a system, and can be used to measure the responsiveness of the system to that load. The key concept behind LoadRunner is the use of virtual users, or vusers.

What is "Virtual Users"?

To perform a load test, a system needs many users to access the system concurrently, often one hundred or more. Performing such a test with people is a logistical nightmare. When considering that the test cycle is generally iterative, this problem is compounded.
LoadRunner overcomes this problem through the use of vusers. A vuser performs the actions that a real user would perform, except that a vuser is controlled by LoadRunner, and the actions are performed automatically.
Vusers are created to perform specific transactions in the system. Once created a vuser can be replicated as many times as required, thus producing an effective load as large as is required. With the exception of GUI vusers, virtual users don’t use the client to perform their actions; they take the place of the client. This allows in many vusers to be run on one workstation, as the overhead associated with the client is not required.
This does mean, however, that non-GUI vusers do not test the performance associated with the client side of a system, only the network and server associated performance.

Static Testing – An Effective Method Between Coding and Testing Phase

Software testing connotes real-time execution of software beta versions. However, real testing already starts even in coding phase, when developers present their initial code for review. The system is being tested statically once the reviewer began to analyze the code, and ends until a satisfactory code has been successfully compiled. In actual practice, static testing purposes are as follows:

Existential Check of Code Implementation for All User Requirements
This is one of the top priorities of code reviewers or static testers. They make sure that all requirements written in software specifications are implemented in the code. It also extends to check if hidden requirements are met.

Syntax Validation
The main focus of this testing is to have a theoretically working source code, and one way to do this is to ensure that code is syntactically correct. Input arguments for both customized and built-in functions can also be included in validation. Syntax checking is very important because having a compiled source code is the first step in acquiring a working prototype.

Improving Code Readability
Various developers have differing programming style. Having various developers in one source code might result to generally unreadable code, that is, logic flow within the code is difficult to follow and to maintain. Verifying the code statically calls for searching for an alternative solution to be lengthy, hard to follow, and difficult to manage code.

Developing Source Code Efficiency
Aside from well-structured design, efficiency is also achieved through proper implementation of the design. One data type will work better than others and choosing the best type for the entire code is crucial. In addition, poor coding implementation results to longer run-time. This problem can be solved by optimizing the code structure during reviews.

Creating Well-Documented Source Code
Code comments are often neglected in actual practice. Having sufficient comments can help developers to modify the work of each other and to have a more understandable source code. Static testers also aim to utilize modern methodologies, like XML tags, for better code documentation.

Modern static testing techniques offer a more benefit to the software development team. The advent of pair programming, a technique used in extreme programming and Agile process, paved the way for shorter development and review time. Some benefits of modern static techniques are higher quality, lower cost, and better knowledge transfer. It also has its disadvantages like intimidation issues when pairing more experienced developer with a newcomer. Such static technique can also help in skill improvement because studies show that developers increase their productivity as much as two times after participating in several pair programming.

The primary problem encountered in the static analysis is the fact that no method can give exact answers on whether the code will have run-time error or not. To resolve this issue, several formal methods have been developed, and some static testing implementation techniques include:

Model Checking
The system is checked if requirements are met by using a simplified model of its structure. It also includes elimination of situations where two different operations temporarily pause for their actions to wait for the other operations to finish, or commonly known as deadlock.

Abstract Interpretation
Computable mathematical representation of software behavior should be acquired to allow static testers to analyze its theoretical results and expected system action. If done efficiently, static analysis can be “sound”, or has the same result for both abstract and actual system.

Assertions
This is actually a programming keyword used in several code checker utilities. Assertions can validate if the output of the static system is the same with the expected value of the developer.

Advanced implementation can include process champions, trainers, and static analysts. They also use materials like policies, logs, metrics, etc.

The only universal statement that will satisfy the diverse software development principles of IT professionals is that the software to be delivered to clients must have the highest accuracy and reliability as possible. Software testing was proven to be a vital part of achieving such results since the early days of IT industry up to present situation when numerous testing methodologies have already been developed. One of the most widely adopted software testing techniques is all-pairs testing.

In this method, input parameters will be combined with one another to create all discrete possibilities that may occur during operation. Contrary to exhaustive testing, or verifying all combinations individually, this method utilizes statistical principles to find software faults and to reduce a number of test cases while maintaining satisfactory test coverage. In actual practice, this often translates to higher productivity and lower cost.

Real-life software testing always faces the dilemma of having thousands of test cases to thoroughly verify internal and external system behavior. However, meeting client needs often restricts project management in having the luxury of time during testing phase to cover all test cases. Thus, different types of all-pairs testing was formed to incorporate both past and modern statistical concepts into test case creation to find as many faults as possible out of minimal cases.

Combinatorial Testing
This testing is the simplest pair testing. In this type, all combinations should be evaluated by tedious approaches like prime-based solutions and brute-force. Such solutions where proven to be tiresome and least reliable because it relies on random probabilities and guesses from previous results. Apart from this, it imposes higher chance of error because of its heavy testing procedures and its similarity with exhaustive testing.

Pairwise Testing
In exhaustive testing, all combinations are being formulated. For example, 243 items should be formulated for a system with five distinct parameters having three possible states. Testers do not have enough resources to cover all 243 items but through the pair wise testing, only minimal test cases will be needed to cover all interactions. Finite field computation, modulo arithmetic, etc. is used to solve the least number of test cases needed. This testing started as early as 1990s and continues to become popular because of its feasibility and high quality despite its low cost.

Orthogonal Array Testing
This type was derived from industrial engineering concepts of manufacturing. It offers robust methodologies in creating efficient test cases. This pair testing is similar with the pair wise but goes further by arranging each combination orthogonal. In the orthogonal arrangement, combinations of values between parameter pairs will only occur once in all sides of the array. This arrangement makes it suitable for more sophisticated software applications because of faster and more reliable bug detection.

Through pair testing is appropriate for most systems, it will not be as efficient when applied in medical equipment, distributed computing, and shared databases. All-pairs testing common mistakes can be summarized into three:

Manual Pair Creation
Using spreadsheets to manually plot pair values is very tedious. It is also difficult to maintain and presents lots of inaccuracies. To avoid such scenarios, test engineers can opt to professional or freeware applications to automate their test case creation.

Wrong Application Usage
This is either using pair testing in wrong application, or using it in correct application but in its wrong area. Pair testing is not applicable to high-risk applications like medical systems. It should be used in collaboration with other testing procedures to ensure its reliability. This is because the high-risk systems encounter fatal errors from useless combinations being ignored by pair testing. Wrong usage also includes employing pair testing in areas where simpler methods with less effort are more applicable.

Wrong Parameter Selection
Success of pair testing depends on how well the parameter interaction is defined. Using wrong parameters in pairing will yield low success rate. Sometimes, choosing the best test parameters calls for involvement of requirements analyst, developer, and test engineers.

Stress Test: In this case we increase the load of the system to check if it can sustain such load and what is the bottleneck point. Also when system fails for such heavy load can it recover gracefully.

  To build a functional testing framework we need to define the following software testing artifacts at the very first stage of the project.

About CSTM Certification: