Getting a software team to figure out their own problems - Part 2

In the previous post in this series (Working with a software team to improve their processes - Part 1), I described a situation where a software team was working in a state of somewhat poor processes; where they had a lot of work and hence were working flat out. As a result, they believed that they were doing great work and were productive (or rather, some of them were worried about whether they were actually working effectively), but they also wanted suggestions about where they could be doing better. For a team that felt that they were productive and doing well, it would not be really useful to try and tell them a lot of stuff about processes and so on, instead it would be better to have a discussion with them and get them to raise such queries by themselves so that they would start driving improvements processes themselves. In this post, I will continue with some of the discussions that we had and post more of the way that the discussion happened:

- One of the initial points in the discussion was about whether they were aware of how defect free their code was ? They had defect metrics in terms of number of defects raised, closed and so on. However, when queried about whether they did some kind of review of the defects raised in the project so that some serious defects were analysed to prevent the occurrence of these defects in the next similar project, there was no answer. One of the team members then volunteered about how some of the more serious defects did occur from time to time, and this set the more senior members to evaluate as to how to make more time for doing such analysis. Even with the speed of their work, many of them did realize that it was serious to try and prevent these kind of high impact defects from recurring.
- It was necessary to keep on drilling further on this side, but in a discussion kind of mode. The next question was about their code practices, So, when the discussion moved to how robust the code was, and how the aim was to prevent defects from occurring in the code, the discussion finally moved onto the process of Code Reviews. There was a realization that Code Review was something that happened when the developer felt that there was time, and a reviewer was available. Members of the discussion team knew that Code Review could help in reduce the defects in the code, and that too right at the source (where the cost of the defect would be the minimum), but the speed and pressure ensured that this practice was not mandatory and did not happen in the hard pressure cases, where it was even more important.
- Discussions also happened in terms of coding guidelines and commenting inside the code. The team had a attrition rate that was increasing, and it was taking time for new team members to understand the code and learn why changes were made from time to time in the code. One of the developers who had joined 6 months back was asked about the code and what took time, and after some discussion with other developers, it turned out that sections of the code were not clear. It turned out that in many cases, previous defect fixes had caused changes in the code which were not clear for later developers, and since commenting in the code had not been drilled into them, there were not many references to the need to provide comments in the code with reference to why the changes were made and defect numbers.

This is proving to be a long post. Read the next section (TBD). If you have been in such a situation, please provide your comments. 

How are unit and integration testing done in EiffelStudio?

- Eiffelstudio provides a development environment that is complete and well integrated.

- This environment is ideal for performing unit testing and integration testing. 

- Eiffelstudio lets you create software systems and applications that are scalable, robust and of course fast. 

- With Eiffelstudio, you can model your application just the way you want. 

- Eiffelstudio has effective tools for capturing your thought process as well as the requirements. 

- Once you are ready to follow your design, you can start building up on the model that you have already created. 

- The creation and implementation of the models both can be done through Eiffelstudio. 

- There is no need of keeping one thing out and starting over. 

- Further, you do not need any other external tools to go back and make modifications to the architecture. 

- Eiffelstudio provides all the tools. 

- Eiffelstudio provides round-trip engineering facility by default in addition to productivity and test metrics tools.

- Eiffel studio provides the facility for integration testing through its component called the eiffelstudio auto test. 

- Sophisticated unit tests and integration testing suites might be developed by the software developers that might be quite simple in their build. 

- With eiffelstudio auto test the Eiffel class code can be executed and tested by the developer at the feature level. 

- At this level, the testing is considered to be the unit testing. 

- However, if the code is executed and tested for the entire class systems, then the testing is considered as the integration testing.

- Executing this code leads to the execution of contracts of attributes and features that have already been executed. 

- Eiffelstudio auto test also serves as a means for implementing the tests as well as assumptions made regarding the design as per the conditions of the contract. 

- Therefore, there is no need of re-testing the things that have been given as specification in class texts contracts by unit and integration testing through some sort of test oracles or assertions.

- Eiffelstudio auto test lays out three methods for creating the test cases for unit and integration testing:

1. A test class is created by the auto test for the tests that have been manually created. This test class contains the test framework. So the user only needs to input the code for the test.
2. The second method for the creation of the tests is based up on the failure of the application during its run time. Such a test is known as the ‘extracted’. Whenever an unexpected failure occurs during the run time of the system under test, the auto test works up on the info provided by the debugger in order to produce a new test case. The calls and the states that cause the system to fail are reproduced by this test. After fixing the failure, the extracted tests are then added to the complete suite as a thing that would avoid the recurrence of the problem.
3. The third method involves production of tests known as generated tests. For this the user needs to provide the classes for which tests are required and plus some additional info that auto test might require to control the generation of the tests. The routines of the target classes are then called by the tool using arguments values that have been randomized. A single new test is created that reproduces the call that caused the failure whenever there is a violation of a class invariant or some post condition.

What is Python Testing? What are system requirements for python testing?

Framework for Python Testing

- A special frame work is used for python testing frame work which is commonly known as the “py unit”. 

- This frame work is nothing but a language version of the Junit which was developed earlier by Erich gamma and Kent Beck. 

- Kent previously had developed a small talk testing frame work. 

- The Junit is a version of this frame work only. 

- Each one of them can be considered to be a standard unit testing frame work representing their own respective language. 

- Test automation is much supported by the unit test. 

- Other things supported by the unit test are:

1.   Sharing of set up

2.   Shut down code for tests

3.   Aggregations of tests in to collections

4.   Keep the tests independent of the reporting frame work

- In addition to all these classes that support qualities for a set of test cases are also provided by the unit test module. 

- But to provide all these, it is necessary that the unit test module should support the following concepts:

1. Test case: Being the smallest unit of testing, it is designed to check the specific response to a certain input. New test cases are created from a base class called “test case” which is again provided by the unit test module.

2. Test fixture: The purpose is to be the representation of the preparation that is very much required for performing one or more than one as well as clean up actions. Some examples are:

a)   Creating temporary data bases

b)   Creating proxy data bases

c)   Creating directories

d)   Starting a server process

3.Test suite: It is a collection of either test cases or test suites or in some cases a mixture of both. Serves as an aggregating tool which collects the tests to be executed in one place.

4.Test runner:This component facilitates the orchestration of the execution periods of the tests and accordingly provides results to the user. Either a graphical interface or a textual interface can be used by the test runner.

The following two concepts are supported by the function test case and test case classes:

1.   Test case and

2.   Test fixture

- The frame work for python testing has been designed in such a way that it will work with any standard python but on versions higher than 1.5.2. 

- Pyunit has been tested on various versions of Linux with python 2.0, 2.1 and so on. 

- Also, the python has been known to work on platforms other than this example mac and windows.  

- The unit test module is actually a content of the standard python library of python 2.1 and above. 

- If in case you are working with an old version of python, you need to obtain this module from a separate distribution of the pyunit. 

- To ensure that the unit test module is being used in your code, you need to ensure that the directory which holds the file unittest.py is included in your code. 

- There are two ways to do this as stated below:

1.   Including the ‘$PYTHONPATH’ environment variable

2. Placing the directory in the current search path of python on linux machines.

- Exceptions are part of every test run. 

- So, in python testing whenever exceptions are raised, in order to format the failure details the resulting trace back objects are saved. 

- The failure details are printed at the end of the test run.

- However, memory usage poses a problem whenever test suites are run with very high failure rates.

What is UML and how to use it for software testing?

Unified modelling language or UML is considered to be the software engineering world’s only standardized general purpose modelling language when it comes to the field of object oriented software engineering. 

This standard was created by the OMG (the object management group) and later on managed by the same organization only. It was wholly adopted by the OMG organization in the year of 1997 and since then had become one of the best standards for the modelling of the software intensive systems. 

The visual models of the object oriented software intensive systems are created using the unified modelling language through a set of pre defined graphic notation techniques. Unified modelling language:

1. Specifies,
2. Visualizes,
3. Modifies,
4. Constructs, and
5. Documents the artifacts of the object oriented software intensive systems that are under the question. 

In a way, we can say that a software system’s or application’s below mentioned elements can be visualized in a standard way using the unified modelling language:

1. Activities
2. Architecture blue prints
3. Data base schemas
4. Logical components
5. Business processes
6. Reusable software system components
7. Statements of the programming language and so on.

Some techniques from the following other modelling standards are incorporated in to the unified modelling language:

1. Entry relationship diagrams from data modelling
2. Work flows from business modelling
3. Object modelling and
4. Component modelling

The best thing about the unified modelling language is that it always works no matter what the platform or the process is being followed throughout the SDLC or software development life cycle. The software engineering world has come to witness the synthesization of the notations obtained from the following techniques or methodologies:

1. The booch method
2. OOSE or object oriented software engineering and
3. OMT or object modelling technique etc.

The notations are synthesized by carrying out a fusion process among them in order to produce a common, single and widely usable modelling language and so we have UML today.  

Software testing does not just consists of one phase only rather there are so many like:

1. Unit testing
2. Function testing
3. Regression testing
4. System testing
5. Solution testing and the list goes on. 

A different class of UML diagrams are used for each and every kind of testing:

1. Unit testing:  The type of uml diagram that is used is the class and state diagrams. For unit testing the code coverage criteria is used and the fault model is used for checking the following:

a)   correctness, invariants,

b)   pre/ post conditions.

2. Functional testing: The type of uml diagram that is used is the interaction and class diagrams. For functional testing the functional coverage criteria is used and the fault model is used for checking the following:

a)   Functional behavior

b)   API behavior

c)   Integration issues etc.

3. System testing: for system testing the operational scenarios coverage criteria and the fault model is used for checking the following:

a)   Work load

b)   Contention

c)   Synchronity

d)   Recovery etc.

       Here many types of uml diagrams are used like:

a)   Use cases

b)   Activity diagrams and

c)   Interaction diagrams

4. Regression testing: For regression testing the functional coverage criteria is used and the fault model is used to check the following:

a)   Unexpected behavior from new or changed functions.

      Two kinds of uml diagrams are used here namely:

    a)   Interaction diagrams and

    b)   Class diagrams

 We can say that the need of uml diagrams here is same as of the functional testing.

5. Solution testing: For solution testing, inter communication coverage criteria is used and the fault model helps in detecting the inter operating problems. The uml diagrams used are:

a)   Use case diagrams and

b)   Deployment diagrams. 

What is an Agile Process?

Agile process is a process that is taking up the field of software engineering for the good. In this article the topic of the agile process has been taken up in depth. 

Agile processes or agile software development processes constitute a group of processes that are based up on the principles of the agile values and principles and follow up the idea of the iterative and incremental development for developing the software products. 

Here the solutions to the software problems are meant to be evolved via the collaboration between the development teams having characteristics like:

     1. Self organization and

     2. Cross functioning

The agile process are known world wide for the promotion of the following features:

     1. Adaptive planning

     2. Evolutionary development

     3. A time boxed iterative approach

     4. Flexible and rapid response to the change in requirements.

     

What is an Agile Process?

- Agile processes can be thought of as a conceptual frame work promoting the above mentioned aspects plus the foreseen interactions that take place throughout the development cycle. 

- The term “agile processes” came in to existence by the virtue of the agile manifesto in the year of 2001. 

- The concept of the agile processes is not so new to the software industry. 

- The incremental software development aspect of the agile development can be dated back to the year of 1957.  

- The category of the light weight software development methodologies houses all the agile software development methodologies. 

- The agile processes were first mentioned in the “manifesto for agile software development”. 

Principles that govern Agile Process

There are 12 principles that govern the agile processes as mentioned below:

1. Rapid delivery of the software that is useful to the customer.

2. To accept the changes in the requirements in all the phases of the development process.

3. Frequent delivery of the working software.

4. A principal measure of the progress is the working software.

5. The development takes place at a constant pace known as the sustainable development.

6. Daily co- operation takes place between the developers and the clients.

7. Face to face conversation is maintained.

8. The project is centered around the motivated individuals who are trust worthy.

9. Regular attention is paid to the design and the technical excellence.

10. Simplicity is maintained.

11. Self organizing teams.

12. Ability to adapt to the changing circumstances.

Till date so many agile software development methods have come up and they are known to promote the following elements:

1. Team work

2. Collaboration

3. Process adaptability

- These elements are promoted all along the development process and throughout the development cycle of the software project.

- The main methodology of the agile processes is that the problem is broken down in to small increments or iterations and is developed according to the short term planning rather than using the long term planning. 

- These iterations are nothing but kind of short frame works having duration of development ranging from one to four weeks. 

Activities in Agile Process

Full agile software development iteration includes the following activities:

1. Planning

2. Requirements analysis

3. Design

4. Coding

5. Unit testing and

6. Acceptance testing

More about Agile Process

- The agile processes are known for their typical strategy that works on minimizing the risk to a great extent. 

- The documentation is produced by the stake holder as and when required.

- The goal here is develop a release that is available as a sample but not for market release. 

- A market release is facilitated by multiple iterations.

- The work burden is divided by the individual team members among themselves. 

- For the agile development the team needs to be in the same region and size of the team is typically small at the most ten members. 

What is the use of a mock object in test driven development?

Over the years the idea of the mock object was materialized and today they are being used in numerous testing and development methodologies. Nowadays mock objects find their use in many testing methodologies like the unit testing and also in development processes such as the test driven development process. 

This article is focused up on the use of a mock object in the test driven development process. But, before moving further we shall give a brief discussion regarding the concepts of the mock object so that understanding the use of mock object in the test driven development becomes easy for you. 

Mock objects are known as the fake objects that in a way simulate the behaviour of an original or to say a non mock object whenever any of the following conditions are prevalent:

     

     1. If the non mock supplies non deterministic output.

     2. If the non mock object is difficult to be reproduced or recreated.

     3. If the non mock object is quite slow i.e., is using a complete data base.

     4. If the non mock object tends to change its behaviour.

     5. If the non mock object does not yet exists.

     6. If the non mock object demands information and methods exclusive to the testing purposes.

   

What are Mock Objects?

- Mock objects are nothing but fake objects but with a little more purpose of testing the other non mock objects with the method implementations having assertions of their own. 

- They are employed for the examination and verification of the context of each and every method call.

- Apart from this, they are also used to determine the order in which the methods are called and implemented using data that was passed as the arguments in the method calls.

- Mock settings are an effective means for ensuring that an exception is generated by the software system or application when the subsequent calls to it are made like it may hang, fail or crash etc. 

- With the mock settings, it has become possible to test the client behaviors against all the realistic faulty conditions as well as they can be developed also in the back end sub systems. 

- Without the use of mock objects it will be too difficult to test these conditions. 

- The mock system provides a simple and flexible way to test the realistic fault conditions since proper consideration is given to them.

- With the mock methods it has become easy to add entries to a public log string. 

Use of Mock Object in TDD

Now coming to the use of mock objects in the test driven development, mock objects are used in 

the test driven development during the writing of the software. 

- With the help of mock objects the programmers and developers are able to write and unit test functionality in a defined area by using the mock objects that provide all the interface requirements of the complex real objects rather than using the complex collaborating and underlying classes and objects. 

- With the help of mock objects the programmers are able to focus properly on the testing of the behavior of the SUT or system under test. 

- They don’t have worry about the objects on which it is dependent. 

- There are some practical speed issues also involved with the use of mock objects in the test driven development apart from the complexity issues.

- To develop a realistic piece of software employing the test driven development may require hundreds of unit tests. 

- If any communication is developed between these unit tests and the data bases, networked systems and web services, then it is possible that the suite of unit tests will become quite slow. 

What are the advantages and limitations of a mock object?

Mock objects are nowadays quite popular with the testers. The mock objects are now being used widely for conducting unit testing and also in many software development processes like the test driven development.

- The mock objects are known for their mimicking behaviour of the other non mock or original objects for which they have been created.

- The mock objects are used under the context of the object oriented programming.

- They are nothing but the fake objects that are simulated in a way as to mimic the behavior of the real objects in a way that is properly controlled and defined.

- The behavior of most of the non mock or real objects is tested against the behavior of a mock object.

- You can compare the mock object with a crash test dummy that is used by the car designers to the impact of the vehicle on the human body.

Reasons for Use

Few of them have been mentioned below:

1. The real object provides non deterministic result like current temperature and time.
2. The real object has the states that cannot be easily recreated or reproduced such as a network error.
3. The real object is quite slow such as a data base that needs initializing before the commencing of the test.
4. The real object does not exist currently.
5. The real object tends to change its behaviour.
6. The real object is to include the information for the testing purposes.

Advantages of Mock Object

- One of the characteristic of the mock objects is that they possess the same interface as that of the real objects that they mimic.

- With such an arrangement the client stays unaware of whether he is using the real object or the mock object.

- With the use of mock objects it becomes easy for the programmer to specify which and all methods will be invoked and in what order and it can also be specified which parameters are to be passed to the mock objects.

- All this is done by using the mock object frame works.

- The mock objects can even mimic the behaviour of the complex objects, for example the network socket.

- The use of mock objects can help the programmer in various ways.

- The programmer can determine whether the object that is under test responds well to the variety of situations it is put in works properly or not.

Limitations of Mock Object

- Use of mock objects can lead to close coupling of the several unit tests similar to that in the actual implementation of the code that is under testing.

- If a programmer is using the mock object frame work, the order of and number of times the mock methods are to be invoked on a mock object can be specified.

- If the code is subsequently refactored, it may fail even though the contract of the previous implementation is followed in the method.

- The unit tests are known to test only the external behaviour of the mock methods rather than testing its internal implementation.

- Therefore, maintenance needed for the tests increases if there is an overuse of the mock objects.

- Mock objects need to model the real objects perfectly well which becomes difficult if the real object has not been written yet.

What is the entry and exit criterion for unit testing?

First let us brief up ourselves with what the concepts of the unit testing and then we shall proceed further in discussing about the entry and exit criterion for unit testing.

About Unit Testing

- Unit testing is a self explanatory term.

- It involves the testing of the smallest units or modules of the software system or application in order to determine whether or not they are working properly and in the desired manner.

- Since this testing methodology is employed for testing the smallest individual unit of the software system or application, hence it got the name “unit testing”.

- If the program or application has been developed using procedural programming oriented language then the entire module is treated as units in the unit testing or else in general, the individual procedures and functions are the units.

- For the applications and softwares in which objected oriented programming has been implemented, the entire application’s interface.

- The test cases for the unit testing are created by the white box testers since they have an in depth knowledge of the software system or application.

- Sine the units are tested in isolation with the other units and independently, hence the test cases created for unit testing are also independent in nature.

Unit Test Case

- A unit test case can be assisted in unit testing by using substitutes like those mentioned below:
1. Mock objects
2. Methods stubs
3. Test harnesses
4. Fakes and so on.

- The test cases for the unit testing are both written and executed by the software developers.

- This ensures that the source code is at par with the design and architecture of the software system or application and works as accordingly as specified.

- The test cases can be implemented in two ways i.e., manually or through the use of automation tools as a part of build automation.

Entry Criterion for Unit Testing

- The functional specifications requirements of the software system or application under test need to be frozen.

- The technical design specifications need to complete and approved. They should have been released.

- The system specifications document also should be complete, approved and released.

- No issue should be pending in the query issue register regarding the requirements under the unit testing.

What else unit testing involves?

- Apart from just testing the modules, the unit testing involves the verification of the requirement specifications in regard with the finalized design and functional specifications requirements.

- For harnessing the maximum benefits of the unit testing, all of the requirements specifications should be signed off.

- Unit testing is said to be complete when the source code is complete and that too according to the specifications.

- All the design specifications should meet the design standards and the entire unused variable, code files should have been removed from them.

- The code documentation including the commenting and AOT documentation must also be complete and approved.

- To put it simple the code should be in such a state so as to be released to the customers or the clients.

Exit Criterion for Unit Testing

- All the units have successfully passed the unit test.

- The code is complete according to the requirements.

- No elements and features are missing.

- The possible errors and warnings have been resolved. This criterion is optional since most of the times it’s not possible to remove all of the errors.

- Code optimization for all the three tiers has been done.

- There is no error in the performance optimization.

- All label files have been created.

- All unused files have been removed.

- Redundant code is removed.

What is the entry and exit criterion for integration testing?

Integration testing as we know is the second main software testing methodology in the software testing life cycle or STLC after unit testing. It is succeeded by the system testing and system integration testing substantially.

Like for every other testing methodology, a software system or application can undergo testing only after passing some pre- defined entry criteria and for exiting the testing phase also it needs to pass some pre- defined exit criteria in integration.

This article is focussed up on the entry and exit criterion for the integration testing. But, let us brief up ourselves with the concepts of integration testing so that it becomes easy for us to define with the entry and exit criteria defined for integration testing.

About Integration Testing

- Integration testing is sometimes abbreviated as I & T i.e., integration and testing.

- Integration testing has been named so because it involves the integration of the software system or application modules before carrying out the testing on them.

- Thus, we can say that the it is contrary to the unit testing since here it involves the testing of the system modules as groups of two or more modules rather than carrying out testing on them as individual modules like in the case of unit testing.

- Integration testing is often carried out after the unit testing but before the validation testing.

- Only those individual system modules which have passed the unit testing with successful grades can be considered as a valid input for the test cases created for the integration testing.

- Though, in some cases there might be some exception if error present in any individual module can only be rectified in the later stages of the testing cycle.

- When the groups or aggregates of the modules pass the integration testing, then only they can be moved further for the system testing and system integration testing.

- The reliability requirements, performance requirements and the functional requirements that have been specified for the major design items are what are tested by the integration testing.

- By major design items, here we mean the group of units or modules or assemblages.

- These assemblages or groups of units are put together via their interfaces by implementing the black box testing techniques and the faults and errors are simulated according to the proper defined parameters and the input data values.

- The inter process communication occurring as a result of the integration between the several unit groups is also tested apart from just testing the above mentioned requirements.

- The implementation of these small sub systems takes place through the interface of the input.

- A verified base is prepared on which the various assemblages are placed which is then used as a support to the integration testing test cases for the testing of the other assemblages.

- This approach has been termed as the “building block approach”. Integration testing can be implemented via any of the below mentioned approaches:
1. Big bang approach
2. Usage model testing
3. Top down approach
4. Bottom up approach
5. Sandwich testing

Entry criteria for Integration testing

- The system units or modules needed for the integration must be ready to be integrated.
- Unit testing must have been completed and closed.
- All the issues discovered during the unit testing must have been addressed and closed.
- The test scripts for the integration testing should be ready.
- The testing should be commenced as per the schedule and the plan.
- The test environment should be ready.

Exit criteria for Integration testing

- Issues discovered during the integration testing must be addressed, fixed and closed..
- 10 percent of the benchmark as decided by the QA people is supposed to be allowed for the issues that outstand.
- All the test cases must be executed and passed.
- Transition meeting should be signed off.

What are Application Testing Methodologies?

First of all, lets be clear with what is application testing actually.
- It is simply the testing of application software. But, it is not so easy to carry out as it sounds like.
- To develop good application software, great efforts and skills are required both of development and testing.
- Testing is needed to check the quality status of application software.
- This is indeed very important for quality assurance and to see that if the application software is meeting the expectations of the consumers or not.

WHY IS TESTING METHODOLOGY IMPORTANT?
- It is obvious that all the aspects of application software cannot be discovered by following just one testing methodology.
- One has to employ many testing methodologies in order to discover most of the hidden bugs and errors.
- Many methodologies have been developed for testing application software.
- Discovery of flaws is the primary aim of any software testing methodology.
- Criticism is yet another aim.

APPLICATION TESTING METHODOLOGIES

1.BOX TESTING TECHNIQUES
- White Box Testing
It includes techniques that are used to test the program or algorithmic structures and working of that particular software application in opposition to its functionalitY or the results of its black box tests.
a) API testing
b) Fault injection
c) Code coverage: Code coverage can be defined as a measure to measure the extent to which the source code of a software system has been tested.
d) Mutation testing
e) Static testing

- Black Box Testing
a) Equivalence partitioning
b) Boundary value analysis
c) Pair wise testing
d) Fuzz testing
e) Exploratory testing
f) Model based testing
g) Specification based testing

- Grey Box Testing
As the grey colour is made from the combination black and white colours, so does grey box testing is made from a combination of both white box testing as well as black box testing.
- Visual Testing
As the name suggests, non destructive testing techniques do not involve vigorous checking of the software structure.
- Unit Testing
- Integration Testing
The units or modules are combined and tested.
- System Testing
- System Integration Testing

- Regression Testing
It basically discovers and unhide the hidden and new errors and flaws.

- Acceptance Testing
There should be some kind of testing that looks in to the contract and verifies whether or not all the requirements have been met. Acceptance testing serves the purpose right. Acceptance is a composition of 3 kinds of tests namely Physical tests, Chemical tests and Performance tests.

- Alpha Testing
The purpose of checking the application software before the release is served by alpha testing on the basis of:
a) Service level agreement or SLA as it is abbreviated.
b)Requirements
c)Specifications
d)Defect rate efficiency (known as DRE in short form).

- Beta Testing
Beta testing is carried out after the successful completion of the alpha testing.
- Performance Testing

- Usability Testing
Usability testing can be defined as a technique which is used in interaction design. This designing is centred around the user and accounts for the evaluation of the software system, application or product by testing it out on the software product users.

- Security Testing
Security testing as its name suggests can be defined as a process to determine that whether or not a software or information system or application is capable of protecting data and keeping it secure.

- Internationalization
Internationalization can be defined as a process of coding and designing a product. This coding is done in such a way that it can perform well almost on any platform after modification for use in different regional standards and languages.
- Localization