Software Testing For Developers

These days Software touches every aspect of our lives. Not only does it runs on personal computers like Smartphone or Smartwatches, but it is also present in every industry.

As vital as software has become, it's not perfect. After all, it's built by humans, and we are known to make mistakes from time to time.

To correct those mistakes in the software world we have software testing.

So what is Software Testing anyways?

Software testing is the process of analysis conducted to provide information about the quality of the product or service under test.

It can also provide an objective, independent view of the software to allow the business to appreciate and understand the risks of software implementation. Test techniques include, but are not limited to, the process of executing a program or application with the intent of finding software bugs errors or other defects.

Making mistakes it's not the problem everyone does it, we are not machines that eat pizzas and write perfect code, we (the developers) are human beings too. We have software testing to address those mistakes. But the problem starts when developer finishes coding his/her software and says it is DONE! Without even considering testing as the part of the development life cycle.

Why I should care about testing?

No matter how good you are, you are not Chuck Norris! Sometimes you may end up working with other people's software and APIS that will not always work as intended, but you will assume that it does, or should, leading to a defects in your "perfect" case. In any of this cases we need to check everything and anything we produce because things can always go wrong.

  

The ABC of testing for Kids!

To get started with testing let's get a look at smoke testing, which is the very basic set of fundamental test cases  that you will need to run to make sure at least the basic functionality of the software remains rock-solid.  It does not guarantees software as release worthy but failing a smoke test will confirm that the software is certainly not release worthy.  Since you want to do the smoke test on regular basis, it makes sense to automate it.

It is always challenging to create a piece of a software system that fulfills the client needs, ready for use. Especially when it should be done in a very short amount of time, from an idea to a fully functional and tested piece of the application. Achieving the Definition of Done is hard but not impossible. Below are some of the tips that may help you in achieving the impossible.

Focus on your client, think: "Where the presence of bugs would hurt your client the most?", then let your answers drive your testing.

Keep the Bigger picture in mind: While testing needs to be meticulous and thorough, there is no point being fanatical about it. If you get bogged down by trying to achieve high coverage over one part of the system, you might end up not testing some other parts at all.

Increase communication with client to avoid misunderstandings: In the meeting, discuss all points whichever unclear or need some additional information. These communications will resolve the problem easily and quickly and will help to avoid any misunderstandings. Once you discuss these points, it should be communicated over email as well. Basically, simple rule is that don’t keep verbal communications.

Start writing early test cases: If you start writing test cases during early phase of Software Development Life Cycle then you will understand whether all requirement are testable or not. While writing test cases first consider Valid/Positive test cases which cover all expected behavior of application under test. After that you can consider invalid conditions/negative test cases.

Make a Test Plan: Start testing by first writing a Test Plan. It's a document describing the testing scope and activities. It is the basis for formally testing any software/product in a project.

Start with obvious and simple tests:

"Make everything as simple as possible, but not simpler" -Albert Einstein.

If any such case fails, developers will want to know it sooner rather than later. While you need to check invalid and unexpected input, check valid and expected input first. Make sure you do sufficient testing i.e. unit and integration testing before you release your code to the client. 

Note that debugging is not software testing.

Start testing with positive mindset: Start with a positive attitude and don’t think that there will not be a bug in the code. If you are testing application with intention of finding bug then you will definitely get bugs in the code.

Test broadly before you go deep: Check all parts of the program quickly before focusing. Start with core/primitive functions. You may have to fix those before you test the rest.

2 heads are better than 1:

Involve someone, may be a team mate to assist you with your testing. In this way there is a good chances that you may be able to get better results.

Happy Coding and Testing!