You are here

Discover the Testing Principles of Tremend

Testing is a crucial part of the software development process. In order to achieve the optimum and maximum test results without deviating from the goal and to be sure we are following the right strategy for testing, our team needs to apply seven testing principles that ensure best practices.


Tremend’s Testing Principles

Principle #1: Testing shows the presence of defects

There is a common misconception that software testing will show the absence of defects. However, the goal of software testing is to make the software fail. Testers will find issues so that they can be fixed before they are deployed to live environments. Testing helps significantly reduce the number of undiscovered bugs, but it does not prove that the software will be 100% bug-free. A good testing strategy with an in-depth test plan, reports, and release plan can help test progress and even provide confidence in the software.

Principle #2: Exhaustive testing is impossible

When is it enough? Testing every scenario, every test case, every type of input valid or invalid, every precondition is impossible, and attempting to do so will take more cost, effort, etc., which is impractical. But, one of the skills in testing is assessing risks and planning the testing process around these so you can cover vast areas and the most important functions. Rather than attempting to test exhaustively, risk analysis, test techniques, and priorities should be used to focus test efforts.

Principle #3: The absence of errors is a fallacy

As the above principles state, it is a mistaken belief that testers can run all possible tests and find all the bugs within a product. Finding and fixing defects does not guarantee that the software will be usable if the user requirements are not followed. So even if the software has a low number of defects, that does not mean that it is shippable. It is not only necessary that the software is 99% defect-free, but it is also mandatory to fulfill the clients’ requirements and business needs.

Principle #4: Testing is context-dependent

As stated before, the testing approach differs from software to software. It is important to meet client requirements and needs, and so testing context may change. Testing a Music app is different from testing an IM application.

Principle #5: Early testing

Starting testing as early as possible in the SDLC (Software Development Life Cycle) will help prevent defects in the requirements or design phase. A fundamental Agile principle is that testing is an ongoing process rather than a phase because it offers continuous feedback. If encountered in the early stages, the team will be able to solve any impediment or obstacle much more quickly and easily. Early testing can help prevent defects in the first place!

Principle #6: Defects cluster together

The Pareto Principle or the 80/20 rule states that roughly 80% of consequences come from 20% of causes for many outcomes. This can also be applied to software testing. 80% of the major flaws may be found in the same part of the system because of complex coding. One other skill of a tester is the ability to identify early on the main areas that can contain a cluster of defects.

Principle #7: Pesticide Paradox

Just like with insects that develop immunity to pesticides, so goes for testing the same test cases again and again. Always using the same test cases will not find new bugs; therefore, test cases must be regularly reviewed and revised, adding new data or new test cases to help find more defects. Testing using the same methods and test cases may yield ineffective results because although they might confirm the software is working, they may fail to find new issues.


Bonus Principles

Testers are not the Bad Guys

Testers should not be considered as enforcers but should be perceived as mediators between developers and business owners. Testers should work as collaborators right along with developers, business analysts, business owners to create and ensure a quality product that is fit for the user’s needs.

Keep it simple

In the beginning, testing should focus on the happy paths with the highest risk and the highest priority requirements. Once these are covered, testing can focus on the rest. In order to easily achieve these, the testing documentation should be practical to the point. There is no need for tens of pages if one or two pages of thorough documentation are enough and efficient.


Real-Life Applications

E-Commerce Platform - Defect Cluster Together

On one of our e-commerce platforms, we’ve noticed that the majority of bugs were encountered on the Checkout sections. While the rest of the application was properly tested, we’ve concentrated more of our efforts on this particular defect cluster and ran more diverse and complex tests on it.

Hospitality(HoReCa) Web Application - Exhaustive Testing

There are so many flows on a Hospitality (HoReCa) web application that it would be impossible to test every possible combination. Using risk analysis and having a thorough test strategy, we were able to focus on the most important test cases, the ones that have the most business value, in order to deliver a working web application.

All of our projects - Pesticide Paradox

To combat the pesticide paradox on our project, we use the Fresh Eyes method, where we assign two to six people that have never seen the project to test it. They will test the project without looking at the previously written test cases. This way, their experience will be brand new and will test from different perspectives. Based on this kind of session, we are able to come up with new test cases that can reveal more defects in the product.


In conclusion, although the QA process may look like a complex activity and hard to structure correctly, following the above principles will yield great results with maximum efficiency! You can learn more about our testing software services, or you can contact us right away to get a quote.

CONTACT US

Find out how we can generate value for your business

2 + 2 =
Solve this simple math problem and enter the result. E.g. for 1+3, enter 4.