Software testing principles.

  • Exhaustive testing is impossible.
    • Testing everything (all combinations of inputs and preconditions) is not feasible except for some important cases. Instead of exhaustive testing, we use risk and priorities to focus on testing efforts. Testers need optimum time to test an application, which is based on the risk assessment of the same. For example: While testing the calculator you can not test all the combinations for addition, subtraction, multiplication, division, square root etc. Instead of this exhaustive testing some combinations can be verified based on priorities.
  • Testing is context dependent.
    • No two systems are the same and therefore can not be tested the same way. Testing is done in different contexts. For example, safety-critical software is tested differently from an e-commerce site. Also while testing a mobile application, it will be tested on different platforms such as Android, iOS etc while testing a web application can be performed on different OS such as Win 8, Win 10 etc.
  • Testing shows the presence of defects.
    • It states that when a project is tested, it is checked for possible defects or bugs by creating different software testing strategies.Testing can show that there are some defects present, but it cannot prove that there are no defects present in the application. Testing reduces the probability of undiscovered defects remaining in the software but, even if no defects are found, it is not a proof of correctness.
  • Early testing.
    • Testing activities should start as early as possible in the software development life cycle, and should be focused on defined objectives. Early testing helps in detecting errors at an early stage of the development process which simplifies error correction (and reduces the costs for this work).  For example, if a problem in the requirements is found after releasing the product, then it would cost 10–100 times more to correct than if it had already been found by the requirements review.
  • Defect clustering.
    • A small number of modules contains most of the defects discovered during pre-release testing or shows the most operational failures. Errors tend to come in clusters. The probability of the existence of more errors in a module of a program is proportional to the number of errors already found in that module, so additional testing efforts should be more focused on more error-prone sections until it is subjected to more rigorous testing.
  • The Pesticide paradox.
    • If the same tests are repeated again and again, eventually the same set of test cases will no longer find any new bugs. To overcome this “pesticide paradox” the test cases need to be reviewed and revised regularly and new , different tests need to be written to exercise different parts of the software or system to potentially find more defects.
  • Absence-of-errors fallacy.
    • Finding and fixing defects does not help if the system that is built happens to be unusable and does not fulfill the needs and requirements of the users. Early integration of users and rapid prototyping prevents unhappy clients and discussions.

Qualities of a good software tester.

  • Good analytical skills:
    • It is easy for any tester to acquire a product knowledge but strong analysis is very much important before testing a product. Question everything around you. This will trigger the analysis process and it will help you resolve many complex problems. A tester must have the ability to analyze the cause and effects of any defect on the application.
  • Desire for quality:
    • A good software tester must have strong desire for quality. Don’t compromise after certain testing stages. There is no limit for testing until you produce a quality product. A test to break attitude is required to hunt escaped defects.
  • Ability to communicate:
    • Communication – both verbal and written – is a vital skill to have since you’ll find yourself in close contact with developers, business analysts, and other major stakeholders in a project. A tester must be able to read and analyze product documentation, write test plans, write clear bug reports and other related documents. A tester must have the ability to listen critically and speak rationally in person-to-person meetings.
  • Negative testing:
    • Testers should have test to break attitude. Concentrating on only positive side will almost certainly create many security issues in application. Tester should also think in a way one hacker thinks. For this Negative testing is equally important. So cover a good chunk of your test cases based on negative scenarios.
  • Technical background:
    • Yes, this is a controversial one.  It is not necessary to be a good programmer.  But some knowledge of the programming language the software is written in.  A functional tester with programming experience can identify the root cause of the defect and can help out the development team in fixing it quickly.
  • Judgmental skills:
    • Working hand-in-hand with prioritization, managing your time wisely is integral in ensuring that you are being effective as possible. First identify important tests and then prioritize execution based on test importance. Never ever execute test cases sequentially without deciding priority. This will ensure all your important test cases get executed early and you won’t cut down on these at the last stage of release cycle due to time pressure.

Software testing golden rules:

  • Test early:
    • Start software testing process as early as possible in SDLC. It can be started as soon as testing team gets the requirement specification document.
  • Develop a comprehensive test plan:
    • Test plan forms the basis for the testing process, hence it should cover all the testing aspects to be considered. Also You should talk about exit and entry criteria.
  • Include following 3 software testing levels:
    • Unit or integration testing (performed by developers or white box testing team).
    • System testing (performed by professional testers).
    • Acceptance testing (performed by end users. Business analyst and test lead may assist end user).
  • Test with real data:
    • It is always good way to use real data. You can not beat the real data. Apart from invalid data entry, testers must test the application with real data, for this help can be taken from Business analyst and Client
  • Use various testing types:
    • In testing process test the application for regression testing, load testing, stress testing. Perform regression testing on application before going live.
  • Keep track of defect:
    • Checking whether the defect is fixed or not is as important as finding defect. Give defects a test severity status as
      • Critical/ Show stopper (must have, no work around)
      • High (must have, work around possible)
      • Medium (not business critical, but wanted)
      • Low (nice to have)
  • Don’t focus on too much automation:
    • Automated testing can be extremely useful and can be a real time saver. But it can also turn out to be a very expensive and an invalid solution. Don’t forget : it ‘s you who has to define the testing process. No tool is going to do that for you ! Think thoroughly about how you are going to organize your testing.

Why software testing is necessary?

  1. Software testing is really required to discover the defects and errors that were made in SDLC.
  2. It avoids user detecting problems. It makes sure of the user’s reliability and their satisfaction in the application.
  3. It is very important to ensure the good Quality of the product. Defects can harm the quality of the software. Quality product delivered to the user helps in gaining their confidence which is good to stay in the business.
  4. As testing avoids buggy software, it will lead to lower maintenance cost.
  5. Testing is required for an effective performance of software application or product.
  6. Cost of fixing the defects will increase if the defect was not found in early phases of SDLC.

Causes of Software Defects.

  1. Miscommunication of the requirements.
    • The software defect can be caused by an incomplete or ambiguous requirement with the resulting assumption differing from the expected outcome. Due to this defect is introduced from the first stage of SDLC itself. If the requirements are incomplete or ambiguous then the development leads to wrong way.
  2. Unrealistic time schedule.
    • Today’s fast moving world every stakeholder wants to implement and deliver the idea as early as possible. It may lead in such a case where too much work is cramped in a little time. So to develop and test the application in unrealistic project deadlines make impact on the quality of the application and can cause to introduce the defects in the application.
  3. Poor architecture design.
    • As there is the era of complex software systems it required to design the architecture to reach a reliable solution. So main core part of the software development is architecture design & how good your design is decides the overall software application development. Poor design leads to poor development and poor development can lead to defects in the application.
  4. Poor coding.
    • Coding plays a very important role in the software development. So the bad coding leads to errors in the code. The code differs from the documented as in design or requirements or there was a syntactic or structural error introduced during coding.
  5. Inadequate testing.
    • For finding defects as early as possible, having skilled testers with domain knowledge is very important. Also if tester is not paying attention in testing activity & doing testing without giving importance to it, so it results poor quality of the product & major bugs remains in the software. Today’s agile world unit tests may lead to poor coding and which may lead to defects in the application.