Instant Approach to Software Testing

Principles, Applications, Techniques, and Practices

Anand Nayyar

• Publisher: BPB Publications
• Year: 2019
• ISBN:
  9789388511162
• Topic: Computer Science
• Subtopic: Software Development
• Index: Computer Science

One-stop Guide to software testing types, software errors, and planning process Key Features

• Presents a comprehensive investigation about the software testing approach in terms of techniques, tools and standards
• Highlights test case development and defect tracking
• In-depth coverage of test reports development
• Covers the Selenium testing tool in detail
• Comprehensively covers IEEE/ISO/IEC software testing standards
• 
  Description
  Software testing is conducted to assist testers with information to improvise the quality of the product under testing. The book primarily aims to present testing concepts, principles, practices, methods cum approaches used in practice. The book will help the readers to learn and detect faults in software before delivering it to the end user. The book is a judicious mix of software testing concepts, principles, methodologies, and tools to undertake a professional course in software testing. The book will be a useful resource for students, academicians, industry experts, and software architects to learn artefacts of testing.Book discuss the foundation and primary aspects connected to the world of software testing, then it discusses the levels, types and terminologies associated with software testing. In the further chapters it will gives a comprehensive overview of software errors faced in software testing as well as various techniques for error detection, then the test case development and security testing. In the last section of the book discusses the defect tracking, test reports, software automation testing using the Selenium tool and then ISO/IEEE-based software testing standards. What will you learn
  With this book, the readers will be able to learn:
• Taxonomy, principles and concepts connected to software testing.
• Software errors, defect tracking, and the entire testing process to create quality products.
• Generate test cases and reports for detecting errors, bugs, and faults.
• Automation testing using the Selenium testing tool.
• Software testing standards as per IEEE/ISO/IEC to conduct standard and quality testing.
• 
  Who this book is for
  The readers should have a basic understanding of software engineering concepts, object-oriented programming and basic programming fundamentals. Table of Contents
  1. Introduction to Software Testing
  2. Software Testing Levels, Types, Terms, and Definitions
  3. Software Errors
  4. Test Planning Process (According to IEEE standard 829)
  5. Test Case Development
  6. Defect Tracking
  7. Types of Test Reports
  8. Software Test Automation
  9. Understanding the Software Testing Standards About the Author
  Dr Anand Nayyar received PhD (Computer Science) in the field of Wireless Sensor Networks. He is currently working in Graduate School, Duy Tan University, Da Nang, Vietnam. A certified professional with 75+ professional certificates from CISCO, Microsoft, Oracle, Google, Beingcert, EXIN, GAQM, Cyberoam, and many more. He has published more than 250 research papers in various National and International Conferences, International Journals (Scopus/SCI/SCIE/SSCI Indexed). He is a member of more than 50+ associations as a senior and life member and also acts as an ACM Distinguished Speaker. He is currently working in the area of Wireless Sensor Networks, MANETS, Swarm Intelligence, Cloud Computing, Internet of Things, Blockchain, Machine Learning, Deep Learning, Cyber Security, Network Simulation, and Wireless Communications. Blog links: http://www.anandnayyar.com
  LinkedIn Profile: https://in.linkedin.com/in/anandnayyar
  

CHAPTER 1

Introduction to Software Testing

Learning Outcomes

After reading this chapter, the students will be able to:

• Understand the History, Concept and requirements of Software Testing.
• Understand the Software Testing Life Cycle, purpose, and approaches of Software Testing.
• Understand the advanced concepts of Software Testing in terms of techniques, characteristics, scope and process.
• Understand the role of Software Tester.
• Understand in detail the concept of Debugging, Debugging Types, Reviews, and Metrics.

History of Software Testing

Software Testing tools are becoming more advanced day by day, feature rich and easy to use. Software testing activity has, till date much evolved and is evolving day by day.

Software Testing is regarded as activity of running a series of dynamic executions of software programs after developing the source code. It is basically conducted to uncover and correct various errors as much as possible, before delivering the final software product to the end user. Software Testing, till date, is considered as Art, as it is regarded as risk management quality assurance technique to correct all sorts of errors in software design and code [1,2].

Considering the history of software development, various definitions and terminologies evolved over time. The figure 1.1 illustrates the history and advancements in software testing which has laid to significant turning point in area of software testing.

In 1950’s, Software testing was defined by various computer programmers as Practice to rectify the source code and make it error free.

In 1960’s, the software testing area has gone through significant changes and revision in real-time practise. Considering the size of the software, exhaustive testing was not possible due to various reasons: large number of program inputs; too many possible input paths and very difficult to see the design and specifications.

With the advancements in area of software development between 1960’s and 1970’s, it became a significant area of computer science. Software Testing was defined as activities performed to make the program perfectly correct in execution.

The concept of software testing looks great theoretically but in terms of real-time practise, it is seen quite time consuming and expensive. For simple and short software, testing seems to work correctly, but for most of the software’s in large size, large number of errors remain, and software struggles for stability in real-time implementation. However, till today, lot needs to be improvised especially with regard to Acceptance Testing.

Figure 1.1: History and Evolution of Software Testing

In 1970’s, it was stated by professionals, testing is regarded as activity with an intention to locate an error, not proving that it actually works. Another definition was proposed, A Good Test Case has high probability to locate a significant error.

The two definitions stated above has the following main underlying objectives:

1. Determine that the product is working in normal manner.
2. To discover the errors in software development before the end-product is delivered to end-user.

Today, considering the objective of testing, tester is primarily interested in removing all sorts of bugs, till the last end, before delivering the product to the customer.

In 1970’s, software testing has following principles:

• Test case should be defined in significant manner with proper output.
• Programmers should avoid testing their own written programs.
• Depth inspection should be done for each test case.
• Test cases, should be properly written for invalid and unexpected as well as valid and expected input conditions.
• Strict plan should be made for not making any throwaway test cases.
• No testing should be performed in such a manner where there is no probability of determining any sorts of error.

In 1980’s, testing was integrated with new concept called Defect Prevention. In order to perform testing, a suitable methodology is required, and testing should be performed throughout Software Development Life Cycle with proper management.

Testing in 1980’s was defined as System Testing-performing changes to the system once the code is delivered. Once the coding of the software is finished and delivered for testing to tester, the testing should be performed rigorously to each and every module, and if any error is located, the development phase is to be investigated in proper manner. Studies show with high research, that most of the bugs which were created during requirement phase, create more bugs and make the software unstable at later stages of development. It is also proved, that rather than testing the product at final stage, it is utmost necessary to test the requirements in comprehensive manner so that no further errors can be generated in the software.

In mid-1980’s, various testing tools entered the market to overcome the phase of manual testing which improvised the overall quality and working of the software. It was observed that computer-based automation testing program performs more series of tests and classify more errors as compared to human beings.

In 1990’s, more advanced testing tools with high end rich scripting languages entered the market. Test management tools helps in managing all the artefacts from the requirements stage and test all sorts of scripts and defects. These tools were highly effective in testing stress and load-test the target system to determine all sorts of backdoor errors.

In mid-1990s, with the increasing popularity of Internet, software was developed without any software testing standard, making it more complex for testing. Like documents cannot be tested without any designing each end result of each step of the review, in the same manner tests could not be carried out in advance. The new approaches defined for testing this scenario are called Agile Testing Approaches.

In 2000’s, HP proposed a new testing definition with broader scope with introduction of the concept called Business Technology Optimization (BTO). It suitably monitors the priorities, people, and process of organization especially IT. The basic objective is to measure, maximize value across IT delivery life cycle to ensure all the end-software products meet the desired quality, performance, and goals. It provided end-to-end visibility in almost everything so that it can be observed that all IT business process are well mapped to IT Infrastructure. The test cases in software testing is a way that this technique was produced to work to gauge the estimation of the program and augment it by improving the way the program works.

Future of Software Testing

Considering the past history of software testing, it laid the foundation to introduce various advanced testing tools like Selenium. Example: Continuous delivery, put tremendous weight on developers to test and refresh code on a progressing premise. Software regression testing never again work in the time of continuous delivery.

Luckily, developers are presently better prepared to deal with these pressures. The cloud has made it simple to offload testing from nearby situations and influence it to scale.

Historical Cases-demonstrating Failure due to Software Failure

Today, software is everywhere, even from small gadget to High End Space Shuttles are controlled by a software running at the heart of hardware and controlling things [4]. However, To err is Human, we know that software is written by human beings and it’s not perfect, so sometimes a small error in piece of code can lead to disaster. The following examples critically demonstrate it:

• Disney’s Lion King (1994-95)
  In 1994, Disney released its first multimedia CD-ROM game for children titled “The Lion King Animated Storybook”. Disney highly promoted and advertised, and huge copies of CD-ROMs were sold as Game to Buy for holiday season. What happened was a huge disaster. On December 26, the day after Christmas, Disney’s customer care phone calls were flooded with calls that children were not able to make the game to work. The story also appeared in newspapers and TV news. It was figured out that Disney released the software without any testing and was not properly tested on various PC models. So, as a result, the software turned to be a Huge Failure in Disney Entertainment series.
• Intel Pentium Processors- Floating-Point Division Bug-1994
  Considering the methodology of Calculator, a number when divided by zero should give error, but if it gives something else, it is regarded as Floating-Point bug which was the case happened to Intel Pentium Processors with floating-point division bug.
  On 30 October, 1994, Dr. Thomas R. Nicely traced a serious bug in Intel Pentium Processors which gives totally wrong answers on division on his Pentium PC. He posted the problem on Internet and that problem went viral on Internet and lots of other people also posted reporting the same on the problem. This type of bug, reports errors when doing high-end maths and engineering-based calculations.
  The problem when reported to Intel, they responded that: Software Engineers had found the problem, even before releasing the chip, and management didn’t find this problem as highly critical and they released the chip with this issue. When Intel was pressurized, Intel planned to change the chips if user proved being critically affected by the bug. This led to public outcry. Intel, at last, admitted and accepted to change all the processors and ready to bear the loss of $400 million to replace the faulty chips.
• NASA- Mars Polar Lander Failure-1999
  Software Bug also caused even NASA to pay a huge price for their Mars Polar Lander. On December 3, 1999 NASA Mars Polar Lander was supposed to land on the surface of MARS. But during the landing attempt, everything got failed and shuttle exploded and disappeared from the RADAR. The primary reason behind this was the malfunction of unexpected setting of single data bit.
  In order to save the cost, NASA simplified the mechanism of landing by determining when to shut off the thrusters. Instead of using high end radar, they put an inexpensive contact switch on the leg’s foot that set a bit in the computer commanding it to shut off the fuel. Simply, the engines would burn until the legs, touched down.
  It was an utter mechanical failure. The lander was tested by multiple teams. One team tested the leg fold-down procedure and another team tested the landing procedure. The testing performed separately by both the teams was correct but when both of the modules combined together, led to bugs and resulted in catastrophic failure.

The Y2K (Year 2000) Bug

The Y2K bug was a computer flaw, or bug, that may have caused problems when dealing with dates beyond December 31, 1999. The flaw, faced by computer programmers and users all over the world on January 1, 2000, is also known as the millennium bug. (The letter K, which stands for kilo (a unit of 1000), is commonly used to represent the number 1,000. So, Y2K stands for Year 2000.) Many sceptics believe it was barely a problem at all.

When complicated computer programs were being written during the 1960s through the 1980s, computer engineers used a two-digit code for the year. The 19 was left out. Instead of a date reading 1970, it read 70. Engineers shortened the date because data storage in computers was costly and took up a lot of space.

As the year 2000 approached, computer programmers realized that computers might not interpret 00 as 2000, but as 1...

Table of contents

• Cover Page
• Title Page
• Copyright Page
• About the Editor
• List of Authors
• Acknowledgement
• Preface
• Errata
• Table of Contents
• 1. Introduction to Software Testing
• 2. Software Testing Level, Types, Terms and Definitions
• 3. Software Errors
• 4. Test Planning Process (According to IEEE Standard 829)
• 5. Test Case Development
• 6. Defect Tracking
• 7. Types of Test Reports
• 8. Software Test Automation
• 9. Understanding the Software Testing Standards