Software Testing Tools

There are many software testing tools available in testing industry. They can help us in various aspects such as cost reduction project management and performance testing.

Here is list of type of software testing tools that I have experienced.
1. Automated functional GUI testing tools
This software testing tool takes the major role in Regression Testing; especially for Agile. However, this software testing tool is not suitable for every project. The break even point calculation should be conducted to evaluate if it is worth to do.


2. Software testing project management tools
This software testing tool supports many software testing aspects during testing life cycle such as bug management test management and test suite management. This tool make software testing project reliable and traceable.

3. Performance testing tools
This software testing tool supports performance testing activity such as load generator and resource usage analysis. This activity cannot be performed without testing tool.

Actually, there are other tools that I have not mentioned. So, keep in mind that you should make your life easier by applying any available tool. Good luck!!!:)

Read More

Outsourcing For Software Testing

Outsourcing is the process of contracting a business function to another organization. There are many possible reasons for outsoucing e.g. cost and knowledge.

The outsoucing has been used in Software Testing as well. My organization has contracted to an outsouce for some software testing projects. Here is things that I have learned from this activity.

Pros.
1. We can leave the routine task to outsource. So, we can have more time for improving our skill and analysis.
2. We can improve project management and co-ordination skill by managing and monitoring outsource.

Cont.
1. When the time for removing outsource comes, some tasks are hard to returned to us. This means that when you use outsouce, uses them smarter and managable. Not give them everything.
2. Without good project management, the quality of software is uncontrolable.

Read More

Risk Based Testing

Risk Based Testing is a method for prioritizing the tests based on the risk of their failure because tester cannot test everything within available resource.

To use Risk Based Testing, we normally use following factor to prioritize tests:
- Usage frequency.
- Cost of failure.
- Impact module from change.

We should work closely with business and developer to get this information. We should do other testing techniques (e.g., black box testing technique, automation, regression testing) to optimize the cost of testing as the supplementary tool. After you prioritized the tests, you have to communicate to all of stakeholder about the risk from this testing project because of out of scope tests.

Read More

What is Regression Testing? Why should we use Regression Testing?

What is Regression Testing?

Regression Testing is software testing activity that is used to ensure that existing functionality has no impact from change in a system, such as functional enhancements, patches or configuration/environment changes. Regression Testing is activity that rerun previously run tests (Existing functionality) and check whether existing behavior has change.

Why should we use Regression Testing?

There are many kinds of change that cause impact to an existing functionality. The simplest change that can have impact is the new version of Operating System. I am quite sure that you used to try to install an application but it was not allowed because of supported Operating System. The reason is that there is possibility that developer have to code in different way for a specific Operating System. So, the new version (change) of Operating System can impact the existing functionality and Regression Testing is required to check if we can support.

The Operating System is not only one thing that can impact your existing functionality. Everything that stays around existing functionality can impact (e.g., web browser, web service, database, another functionality change in the same software package).

From above issue, the Regression Testing is used widely to ensure that the quality of software is good when there is change in software environment.

Read More

Pair Testing in Agile

Pair testing is a practice which two team members are sitting together to test the software application on the same machine. The two team members can be between one tester and developer/business analyst/another tester.

My team has applied this practice and these are benefits that I have found from Pair Testing.
1. Developers will know how testers do software testing. So, developers can apply test strategy for their own testing during coding.
2. Testers will have more idea about how the software works. This will make testers improve their test strategy and see the risk or impact in this code.
3. Tester can use it for on-the-job training to teach new tester by working together between experienced tester and new tester.
4. Face-to-face communication is used follows the Agile method.

This practice is time consuming activity so we should apply this practice if we see the benefit from this knowledge sharing.

Read More

Software Testing in Agile

Software Testing in Agile is a software testing practice which follows the rules of the Agile Manifesto. This agile testing practice involves testing from the customer perspective as early as possible, testing early and often because software will be released very often. To optimize the regression test effort and reduce the number of escaped bugs because of incremental development in agile testing, the automated testing should be used.

Automated Testing of Software Testing in Agile

The test cases are created and will be submitted to the developer before starting of actual development work. This allows the developers to get better understanding of the requirements. Software Testing in Agile requires tester to have more technical knowledge for interacting with developer and business knowledge for interacting with business analyst. The knowledge of testers will be improved continuously because the team will work together daily throughout the project.

Read More

Localization and Globalization Testing

Globalization Testing

Globalization Testing is the software testing process for checking if the software can work properly in various culture/locale settings using every type of international input.

Localization Testing

Localization Testing in the software testing process for checking the localized version of a product (e.g., Japanese product for Japanese user). Localization Testing checks the quality of a localized version for a particular that culture/locale setting. Localization Testing is based on the results of Globalization Testing which verifies the functional support for that particular culture/locale setting. We should invite the local staff to help our localization testing by checking the quality of translation as well.

You can test on localized OS build (e.g.,Windows XP Japanese version) or MUI on English OS Build. I suggest you to start with MUI version for Globalization Testing because MUI can help you switch to other language settings easier and faster. From my software testing experience, most bugs occur with German and Japanese culture/locale setting.

Here are the common bugs found from Testing
Cannot display the correct format
The software cannot display the format as defined by the regional setting of OS (e.g., numbers, dates, time, currency, and calendars). I have found that developers often display the static format as English culture/locale setting although it is international software.

Functionality is broken
The functionality which works properly on English setting may not work on other settings. I have found that one root cause of this problem is the communication problem between the API's owner and consumer. They forgot to make an agreement for the data format; one party uses the local format but another uses the English format.

Now we understand the importance of Localization Testing and Globalization Testing and the risk if we don't have this type of software testing. So, it is good idea to implement this testing type for your international software.

Read More

Static Testing and Dynamic Testing

The difference between Static Testing and Dynamic Testing is as below.

Static Testing

Static Testing is a software testing method that software is not really executed. It normally checks defects for the deviations from standards, missing requirements, design defects, test plan, non-maintainable code and inconsistent interface specifications.

Dynamic Testing

Dynamic Testing is a software testing method that software is really executed. Software is executed using a set of input values and its output is compared to the expectation.

Read More

Verification and Validation

Verification

Verification is the process used for evaluating the system if it meets the requirements set. It focuses on the question "Are you building it right?"

Validation

Validation is the process used for evaluating the system if it meets the user needs. It focuses on the question "Are you building the right thing?"

Read More

Process When Testing A Software

Here are basic activities of testing process that I normally use when I need to execute testing a software. The process will start from planning and end with evaluation the process.

1. Test Planning and Control

First of all, we set the goal and scope of testing when we plan to do testing a software. This goal is based on the objective of the project. We define approach and plan for software testing. Then, we define the test approach which includes coverage, test resources, schedule of all the tasks, exit criteria and so on. We will control and measure project's progress against the plan continuously.

2. Test Analysis and Design

After we have a plan from the first step, we start building test design and test procedure. Evaluate the requirement and system. Identify test condition, required test environment and tools for software testing.

3. Execution

We build the test cases by using Black Box Testing Techniques and set up the test environment and tools for software testing. The test cases will be reviewed if it is required. Then, we execute software testing and recording the test result. If there are difference between expected result and actual result, we will analyze them to see the root cause of defect and record them.

4. Evaluating and Reporting

We use the exit criteria to check if software testing can be done. If it is done, we can make a summary report for stakeholders.

5. Project Evaluation

Evaluate and analyze the lesson from this project. Implement action plan if it is need for continuous improvement. Please keep in mind that we always need to evaluate when we do testing a software.

Read More

Black Box Testing

Black Box Testing is a software testing method which testers use when they have no idea about software's internal algorithm. Testers only know the input and its expected output from the software which is based on specification.

Test Design Techniques

Test Design Techniques are used for test case design. They include:
- Equivalence Partitioning
- Boundary Value Analysis
- Pairwise Testing (All-pairs testing)
- Decision Table
- Error Guessing

Advantages of Black Box Testing

- Test Cases can be designed as soon as specifications are ready.
- Programming skill is not required. Business user can involve easily.
- Help to identify ambiguity and contradiction in specifications.

Disadvantages of Black Box Testing

- It is hard to identify all possible cases.
- There is possibility of duplicated test which have been done by developer.

Tools for Black Box Testing

Test Design Tools
- CTE XL

Automation Tools for Regression Test
- QTP
-----------------------------------------------------------------

Related topic: White Box vs Black Box Testing

Read More

No resource for testing everything !!!

Most issue that QA or tester faces is that the limitation of resource (time and manpower) for software testing. With this constraint, we need to decide what is the proper software testing scope and find the way to execute testing a software faster.

Prioritize software testing scope

The first thing that we need to do is to prioritize the software testing scope. We can use the software feature's  importance and likelihood / impact of failure to prioritize. Then, make a commitment about the software testing scope with stakeholder

Reduce the test cases

After we have the list of software testing scope, we can reduce the number of test cases by designing the test cases for software testing. This can be done by the Black Box testing technique; Equivalence partitioning, Boundary value analysis and Pairwise testing (All-pairs testing).

Use the software testing tools

There are many software testing tools available for using in many activities in software testing. Using them to make the software testing activities done faster and easier. For example, CTE XL tool for generating test cases and Quick Test Pro for Test Automation.

This is the basic guideline that can help you to do software testing activities when you would like to do this tasks faster.

Read More

Methods of software testing: White Box vs Black Box Testing

White Box vs Black Box Testing

When someone is assigned to execute software testing (Both web testing and windows application testing), they sometimes have question for me about the type of methods of software testing, my answer usually is "2 types the White Box and Black Box Testing". Then, the next question will be "What is different?". Here is the answer...

	White Box	Black Box
Require knowledge of software's internal algorithm?	Yes	No
Sample of Test design technique	Path testing Branch testing	Equivalence partitioning Boundary value analysis Pairwise testing (All-pairs testing
Software Testing Phase	Unit Testing	Integration/System/Acceptance Testing

Each methods of software testing has different purpose and are suitable for different testing phase. I will focus only on the Black Box method for this blog.

The Black Box method is suitable for tester who would like to design testing but has no idea about software's internal algorithm. However, they know only the input and output of this software. If they have to select input for execute software testing, the test design technique will help them. There are some software testing tools for design which make our life easier also.

I will explain the detail of Test design technique of Black Box method in the next articles.

Read More

The earlier a bug is found, the cheaper it costs

This is the key message showing why we need to do software testing activity as early as we can.

Let's find the reason by starting with following SDLC model (V Model). It shows us that there are many phases during implementation. It starts from Requirement Phase and ends with Acceptance Testing Phase.

If a problem from Requirements phase is found during System Testing phase, then it would cost more to fix than if it had been found during the Requirements phase. The reason is that we need to rework everything again instead of just changing the detail of requirement.

From my experience, most bugs which are found during software testing can be removed at the requirement phase. So, we should spend more effort at the beginning of project. Don't wait until software testing phase which is too late.

Read More

What is Software Testing? Why do we need it?

What is Software Testing?

Software Testing is the process of checking if the software can meet the user's expectation. This process can be used for testing a software for both web testing and windows application testing.

Why Software Testing?

Without Software Testing Process,

1) The software has poor quality.

2) The software may contain the critical error or bug.

3) The cost of error or bug may be too high. 

Why do I say that "The cost of error or bug may be too high."?  Let's see the sample of high cost bug: A hospital uses the computer-assisted surgery technology and we don't have the proper software testing activity in SDLC during implementing this tool. Unfortunately. this tool contains a bug that can cause the problem with patient's safety. Let's think what will happen next.

Read More