91

Static Testing

In this section, we are going to understand Static testing, which is used to check the application without executing the code. And we also learn about static Testing, why we use static Testing, how to perform it, a different technique for static Testing, advantages of static testing, and various Static Testing tools.

Introduction to Static Testing

Static testing is a verification process used to test the application without implementing the code of the application. And it is a cost-effective process.

To avoid the errors, we will execute Static testing in the initial stage of development because it is easier to identify the sources of errors, and it can fix easily.

In other words, we can say that Static testing can be done manually or with the help of tools to improve the quality of the application by finding the error at the early stage of development; that is also called the verification process.

We can do some of the following important activities while performing static testing:

• Business requirement review
• Design review
• Code walkthroughs
• The test documentation review

Note: Static testing is performed in the white box testing phase, where the developer checks every line of the code before giving it to the Test Engineer.

Static testing also helps us to identify those errors which may not be found by Dynamic Testing.

Why do we need to perform Static Testing?

We can perform static testing to fulfill the below aspects:

• We can use static testing to improve the development productivity.
• If we performed static testing on an application, we could find the detects in the earlier stages and easily fix them.
• The usage of static testing will decrease the testing cost, development timescales, and time.

What are the different features we can test in Static Testing?

We can test the various testing activities in Static Testing, which are as follows:

• BRD [Business Requirements Document]
• Functional or system Requirements
• Unit Use Cases
• Prototype
• Prototype Specification Document
• Test Data
• DB Fields Dictionary Spreadsheet
• Documentation/Training Guides/ User Manual
• Test Cases/Test Plan Strategy Document
• Traceability Matrix Document
• Performance Test Scripts/Automation

When we performed Static Testing?

To perform static testing, we need to follow the below steps:

Step1: To review the design of the application entirely, we will perform the inspection process.

Step2: After that, we will use a checklist for each document under review to make sure that all reviews are covered completely.

We can also implement several activities while performing static testing, which are discussed in the following table:

Activities	Explanation
Architecture Review	The architecture review activities contain all business-level processes such as network diagram, load balancing, server locations, protocol definitions, test equipment, database accessibility, etc.
Use Cases Requirements Validation	It is used to authenticates all the end-user actions along with associated input and output. If the use case is more comprehensive and detailed, we can make more precise and inclusive test cases.
Functional Requirements Validation	The functional requirement validation activity is used to make sure that all necessary elements identify correctly. And it also took care of the software, interface listings, network requirements, hardware, and database functionality.
Field Dictionary Validation	In the field dictionary validation, we will test each field in the user interface specified to create field-level validation test cases. And we can check the fields for error messages, minimum or maximum length, list values, etc.
Prototype/Screen Mockup Validation	The prototype validation activity contains the authentication of requirements and uses cases.

Why we need Static Testing?

We required Static testing whenever we encounter the following situation while testing an application or the software:

• Dynamic Testing is time-consuming
• Flaws at earlier stages/identification of Bugs
• Dynamic Testing is expensive
• Increased size of the software

Dynamic Testing is time-consuming

We need static testing to test the application as dynamic testing is time-taking process even though the dynamic testing identifies the bug and provides some information about the bug.

Flaws at earlier stages/identification of Bugs

When we are developing the software, we cannot completely rely on Dynamic testing as it finds the bugs or defects of the application/software at a later stage because it will take the programmer’s plenty of time and effort to fix the bugs.

Dynamic Testing is expensive

We need to perform the static testing on the software product because dynamic testing is more expensive than static testing. Involving the test cases is expensive in dynamic testing as the test cases have been created in the initial stages.

And we also need to preserve the implementation and validation of the test case, which takes lots of time from the test engineers.

Increased size of the software

Whenever we test the software, it will increase the size of the software product, which we cannot handle because of the reduction in the productivity of code coverage.

That is why we require static testing to get free from the bugs or defects earlier in the software development life cycle.

Objectives of Static testing

The main objectives of performing static testing is as below:

• Static testing will decrease the flaws in production.
• Static testing will identify, anticipate and fix the bugs at the earliest possible time.
• It is used to save both time and cost.
• It is used to identify defects in the early stage of SDLC, where we can fix them easily.

Some useful points for Successful Static Testing Process

The following guidelines help us to perform a successful static testing process in Software testing.

• We can train participants with examples.
• The testing cost and time can decrease if we delete the major delays in test execution.
• We can retain the process formal as per the project culture.
• We can make emphasis only on things that matter.
• As we know that a software walkthrough and review are usually merged into peer reviews; therefore, we can plan explicitly and track the review activities.
• We can resolve the client’s problems.

Static Testing Techniques

Static testing techniques offer a great way to enhance the quality and efficiency of software development. The Static testing technique can be done in two ways, which are as follows:

• Review
• Static Analysis

Review

In static testing, the review is a technique or a process implemented to find the possible bugs in the application. We can easily identify and eliminate faults and defects in the various supporting documents such as SRS [Software Requirements Specifications] in the review process.

In other words, we can say that a review in Static Testing is that where all the team members will understand about the project’s progress.

In static testing, reviews can be divided into four different parts, which are as follows:

• Informal reviews
• Walkthroughs
• Technical/peer review
• Inspections

Let’s understand them in detail one by one:

• Informal reviews
  In informal review, the document designer place the contents in front of viewers, and everyone gives their view; therefore, bugs are acknowledged in the early stage.
• Walkthrough
  Generally, the walkthrough review is used to performed by a skilled person or expert to verify the bugs. Therefore, there might not be problem in the development or testing phase.
• Peer review
  In Peer review, we can check one another’s documents to find and resolve the bugs, which is generally done in a team.
• Inspection
  In review, the inspection is essentially verifying the document by the higher authority, for example, the verification of SRS [software requirement specifications] document.

Static Analysis

Another Static Testing technique is static analysis, which is used to contain the assessment of the code quality, which is established by developers.

We can use the different tools to perform the code’s analysis and evaluation of the same.

In other words, we can say that developers’ developed code is analyzed with some tools for structural bugs, which might cause the defects.

The static analysis will also help us to identify the below errors:

• Dead code
• Unused variables
• Endless loops
• Incorrect syntax
• Variable with undefined value

In static testing, Static Analysis can be further classified into three parts, which are as discuss below:

Data Flow: In static analysis, the data flow is connected to the stream processing.

Control Flow: Generally, the control flow is used to specify how the commands or instructions are implemented.

Cyclomatic Complexity: It is the measurement of the program’s complexity, which is mostly linked to the number of independent paths in the control flow graph of the program.

Tools used for Static Testing

In static testing, we have several tools in the market, but here we are discussing the most commonly used tools, which are as follow:

• CheckStyle
• SourceMeter
• Soot

CheckStyle

It is a development tool that is used to help the developers write Java code, which follows a coding standard. The CheckStyle tool automates the process of checking Java code.

It is a highly configured tool, which is made to support almost any coding standard. The Google Java Style, Sun code conventions are those configuration files, which is supported by CheckStyle.

Feature of CheckStyle

Following are the most common features of CheckStyle:

• It can check various characteristics of our source code.
• The CheckStyle code has the capability to verify the code layout and formatting issues.
• It can also help to identify the method design problems, class design problems.

SourceMeter

It is an advanced tool for the specific static source code analysis of various programming languages such as C/C++, C#, Java, Python, and RPG projects.

With the SourceMeter tool’s help, we can easily identify the vulnerable spots of a system under development from the source code.

The free version with partial functionality of SourceMeter can be accessible for all programming languages.

In SourceMeter, we can use the output of the analysis, the quality of the analyzed source code to enhance and developed both the short and long term in a directed way.

Feature of SourceMeter

The most commonly used features of the SourceMeter tool are as follows:

• It provides the most precise coding error detection.
• The SourceMeter tool will provide a deep static code analysis.
• It improved the user interface with the help of third-party integration.
• It will provide platform-independent command-line tools.

Soot

It is a Java optimization framework, which means that it is a framework for analyzing and transforming Java and Android applications where we can test the following aspects:

• Named module and modular jar files.
• Automatic modules, which means the modules are repeatedly created from jars in the module-path.
• Exploded modules
• Resolving modules in Soot’s

And a Soot can also produce possibly transformed code in the various output formats such as Android bytecode, Java bytecode Jasmin, and Jimple.

Advantages of Static Testing

The advantages of static testing are as follows:

• Improved Product quality
  Static testing will enhance the product quality because it identifies the flaws or bugs in the initial stage of software development.
• Improved the efficiency of Dynamic testing
  The usage of Static testing will improve Dynamic Testing efficiency because the code gets cleaner and better after executing Static Testing.
  As we understood above, static Testing needs some efforts and time to generate and keep good quality test cases.
• Reduced SDLC cost
  The Static Testing reduced the SDLC cost because it identifies the bugs in the earlier stages of the software development life cycle. So, it needs less hard work and time to change the product and fix them.
• Immediate evaluation & feedback
  The static testing provides us immediate evaluation and feedback of the software during each phase while developing the software product.
• Exact location of bug is traced
  When we perform the static testing, we can easily identify the bugs’ exact location compared to the dynamic Testing.

Overview

In the Static testing section, we have learned the following topics:

• Static testing is used to identify the faults in the early stage of the Software development cycle [SDLC].
• We have understood that Static Testing is not a replacement for dynamic Testing because both testings identify different bug types.
• We have understood the objective of Static Testing.
• In static testing, the reviews are the productive approach to test the application because the reviews help identify the bugs and recognize the design flaws, missing requirements, and non-maintainable code, etc.
• We have understood several static testing tools, which help us enhance testing performance for the software product.

---