Skip to main content

What is software testing and why it is so hard?

What is software testing?

Software testing is a process of identifying the correctness of software by considering its attributes (Reliability, Scalability, Portability, Re-usability, Usability) and evaluating the execution of software components to find the software bugs or errors, or defects.

Software testing provides an independent view and objective of the software and gives surety of the fitness of the software. It involves testing of all components under the required services to confirm that whether it is satisfying the specified requirements or not. The process is also providing the client with information about the quality of the software.

Testing is mandatory because it will be a dangerous situation if the software fails any of the time due to lack of testing. So, without testing software cannot be deployed to the end-user.


types of software testing
Types of software testing


Types of Software testing:

  • Manual testing

The process of checking the functionality of an application as per the customer’s needs without taking any help of automation tools is known as manual testing. While performing the manual testing on any application, we do not need any specific knowledge of any testing tool, rather than have a proper understanding of the product so we can easily prepare the test document.

Types of manual testing:

  • White box testing

  • Black box testing

  • Grey box testing

 

  • Automation Testing

Automation testing is a process of converting any manual test cases into the test scripts with the help of automation tools, or any programming language is known as automation testing. With the help of automation testing, we can enhance the speed of our test execution because here, we do not require any human efforts. We need to write a test script and execute those scripts.

Why software testing is so hard?

  • This is mainly because the programs to be tested are usually complex, and the actual behavior to be checked is impossible to be checked completely. The combinations of all possible inputs to the program are almost infinite, and you cannot possibly check them all in a lifetime. So you have to make a decision on what to test, so that you uncover as many existing bugs as possible, and which corrections will improve the quality of the software. And this decision can be hard sometimes.
  • Even it could seem counterintuitive, another reason for testing to be hard is the determination of what is the expected behavior of the software. You should know very well the business behind the software and know what it is supposed to do at all times. In theory, this is supposed to be explained in the specs, but in practice, specs are rather a high level, and you cannot extract all your use cases from them. You must ask many questions to the developers to make sure that you understand very well the tested functionality.
  • Another reason is the patience and observational skills that you must show when doing tests. Say you have decided which tests you will perform, you know what the expected result is, and you have started performing them. Very often it happens that a bug shows up, but it is almost unnoticeable. For example, you perform a test aimed at testing a feature. And the expected result of this test corresponds to the actual result. However, if you are good at observing, you may notice that something completely irrelevant to this test is wrong in the result. You test, say, a calculator, and you calculate 2+2. You get the correct result of 4, but the display of one of the other buttons of the programs changes after the calculation. You should notice this too, and it is not easy sometimes.
  • Another thing that can sometimes be hard is to report the bugs found in a way useful for the developers so that they can be able to fix the bug. You have to report in the log all pertinent information, including all steps needed to reproduce the problem. Sometimes it is very hard to reproduce a problem that appeared and logging a bug that does not give all the information needed to reproduce it is almost useless. The reproduction of the bugs is sometimes an art by itself.

When a bug is corrected by the developers, you have to check if it is really corrected. In this case, you start by doing the exact steps needed to reproduce the bug and make sure that this does not lead to the problem anymore. However, this is not enough, you have to do more checks around the problem, to make sure that it is completely gone, and not just changed in some way. It can be hard sometimes to determine what supplementary checks to be performed.

So yes, software testing can be very hard sometimes, but it can be very rewarding too when you see with your own eyes the improvement of the quality of the software that you test.



By: Kuldeep Rawat
Labels:

Comments

Post a Comment

Popular posts from this blog

Graph Theory | Cyclomatic complexity

What is Graph Matrix? A graph matrix is a square matrix whose size represents the number of nodes in the control flow graph.  Each row and column in the matrix identifies a node and the entries in the matrix represent the edges or links between these nodes. Conventionally, nodes are denoted by digits, and edges are denoted by letters. Example: Graph Examples Since the graph has 4 nodes , so the graph matrix would have a dimension of 4 X 4 . Matrix entries will be filled as follows : (1, 1) will be filled with ‘a’ as an edge exists from node 1 to node 1 (1, 2) will be filled with ‘b’ as an edge exists from node 1 to node 2. It is important to note that (2, 1) will not be filled as the edge is unidirectional and not bidirectional (1, 3) will be filled with ‘c’ as edge c exists from node 1 to node 3 (2, 4) will be filled with ‘d’ as edge exists from node 2 to node 4 (3, 4) will be filled with ‘e’ as an edge exists from node 3 to node 4 Connection Matrix A connection matrix is a ma...
Post a Comment
Read more