What is Software Testing?
Tags: testing, webdev, beginners, career
Published: 2022-09-18 07:49:46

As we all know what software is so basically whenever you have a problem in real world, we see that with the help of a virtual world solution. We are solving a life issue with the help of software and then to build that we have certain steps to follow and we all know about [**_Software Development Life Cycle (SDLC)._**](https://en.wikipedia.org/wiki/Systems_development_life_cycle)

![SDLC](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/5oq1hcuzomdetkfdwtws.png)

Now based on what model you follow let’s talk about the waterfall model we have certain steps to follow the first one is where you take the requirements then you have to design the software. Designing means that we use different designing tools to design the user interface and then we code the software and then the next step is very important which we normally miss which is testing.

![Waterfall Model](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/pe36weglckvmz1fi9dix.png)

**_Testing_** is a phase in the software development life cycle. So, what do we do in testing?

Whenever you say that you are building software of course it’s for the client. The client will make sure or you have to make sure that you are building the right product and you are building the product right and that’s why we have these two words, _validation_ and _verification_ in testing in fact there is also a _V model_ available but that simply means _validation_ and _verification_.

**_Verification_** is more about whether are you building the project/product right it simply means whatever you are doing should work right. It should perfectly work there should not be any bugs in that.

For example, if you say you want to add two numbers it should be two plus two equals fours, it should not give you five.

On the other hand, we have **_validation_** is more of what you are building should match with the client requirement.

For example, If the client wants two plus two should be equal to five then you have to write software which says that two plus two equals five. In validation, we have to match client requirements.

When we build software the software should work and it should work efficiently and correctly but then at the moment, you said testing you know a lot of people who don’t like this word as well testing why you have to test. We love development but testing is important.

There are two types of testing:

- Manual Testing
- Automation Testing

**_Manual Testing_** means you are testing everything manually. You are checking the outputs; you are giving some inputs.

**_Automation testing_**, means you write scripts to automate your testing using different programming languages and testing frameworks.

There’s one more classification of testing which is _functional testing_ and _non-function testing_.

**_Functional testing_** means you are testing the code let’s say if you write multiple classes or multiple methods, you are testing them so you’re basically testing the actual working of the software that’s the functional testing of the code part and then input parts.

But what about the performance and the scalability? For example, when you say performance when you run the software it should work smoothly right. Scalability, let’s say can you scale your application like if you deploy an application on the cloud can you scale it that’s also important rights so don’t just build a software which cannot scale but it works no one’s wants that so your software should be scalable. These things come under **_non-functional_**.

What about load balancing or loads can your software takes loads?

For example, let’s say a streaming application had 25 million users at the same time watching a football match can your application handle that load that’s also important that’s comes under _non-functional testing_. So, how do we test it? We have two techniques which are _black box testing_ and _white box testing_.

**_Black box testing_** means if you want to test a mobile phone now but you don’t know how this phone works internally so what will you do when you buy a new phone or when you go to mobile to buy a new phone what you do you unlock the phone you check okay so unlocking work you want to test the cameras. You test the screen and everything. You will test the phone outside. You don’t know how it is what is going on inside and that’s called _black box testing_. You give the input and expect the output.

**_White box testing_** means we don’t just test the outer working of the software but internally, we will open this and we will check each and every component how that works. That is _white box testing_ so in coding terms you will check the actual code.

Okay so, we have talked about testing types and techniques now it’s time for different levels of testing.

Let’s take an example of Java, in Java we write a lot of classes and each class will have certain methods. Now you want to test the smallest part of your software which is a class so you will test a class and you will test them as units. So basically, you will test each class which is a unit and we will class them as _unit testing_ in Java if you want to achieve that we have JUnit. Then once you test each and every component now you will combine all the components to test this as software which is _integration testing_ so you will combine a lot of different classes and then APIs and now once you have that you will do _system testing_ it’s the overall testing of your system if you deploy it how that works with other software or about and with the actual data now once you have your _system testing_ next step will go for is _acceptance testing_. Now this is where you will try to match your software with the user requirement you will have the business requirement with you and you will try to match - hey is it matching if that matches that’s your acceptance testing.

So, these are the four-level available and then to do the actual testing we have different types of people. For example, when you use a developer, we normally focus on the _unit testing_ and _integration testing_ as well so nowadays things are changing initially, we used to have two different groups but now we have an _agile_ team where everyone does everything as a developer it’s your responsibility at least to do the first part which is _unit testing_ because when you write a class you have to make sure that class works. If you make a change in one class it should not affect the other classes you have to make sure that as well.

---

## Let's connect 💜

You can follow me on [Twitter](https://twitter.com/MrDanishSaleem), [Instagram](https://www.instagram.com/mrdanishsaleem/), [LinkedIn](https://www.linkedin.com/in/mrdanishsaleem/) & [GitHub](https://github.com/mrdanishsaleem/)

If you like this post. Kindly support me by [Buying Me a Coffee](https://www.buymeacoffee.com/mrdanishsaleem)