The art of software testing wasn’t given much attention in the past because of a lack of followership. The condition of a software tester is even grimmer. Rather than employing those who aim for a software testing job, companies manage with people just settling for it.
Many software testing departments are filled with those who resort to testing only because of their inability to write codes. The growth of this field was also seriously hampered by the misconception about the costs of conducting such tests. Besides hiring and training testers, companies were also worried about scheduling their valuable time for testing.
But the rapid change in technology demanded more from less and hence agile testing started becoming a trend. Gradually the need for testing became important as companies found that they could save more with the implementation of a testing process. To thrive as a great tester, one needs these 5 qualities at their disposal:
1. A Thirst to Seek Improvement
Everyday there is a new technology in the market. A tester must stay updated about these technologies. He should constantly keep improving his skills which will help him gel with the emerging trends in software testing. A tester should be willing to come out of his own comfort zone in order to push the boundaries of his testing knowledge.
Learning about constant growths in a product domain should be part of every tester’s routine. Together with knowing the product, he should also have a good idea about the domain, whether he is a software tester or a game tester. Having no clue about the domain of a test system can lead to improper testing.
2. Programming Skills
A person lacking the skills to write even the basic program code cannot be an effective software tester. Developers and system engineers are greatly benefitted during the testing phase if the tester is able to relate and imagine the code structures.
3. Need for Innovation
Testers must constantly think of how they can do things in different ways and still produce an effective result. Varying the testing scenarios and seeking improved testing methods will surely bring some innovative thoughts. Being a good tester is one thing, but having the capability to innovate can take you a long way.
4. Communicate
Being able to communicate clearly, accurately and demonstrate a high capacity of comprehension are great qualities for a tester. Communication skills can be different, depending on the need of the hour. A tester might be required to read and understand specifications, translate those into structured test cases, report bugs and to write a clear and concise report to management.
A tester must be able to convey their findings during meetings in a logical and unambiguous way so as to make others understand their ideas. This requires the software tester to have exceptional spoken and written skills.
5. Accountability
There are two forms of accountability that a software tester has to deal with.
a) Accountability to the test product
Most testers are content with completing their tasks for the day and put no effort in trying to learn a bit more about the product at hand. They fail to understand where their product fits and how it influences the economy, markets, businesses, consumers and end users. Having such an idea will help testers to put in better effort towards the work that they do. This will help cultivate a sense of ownership which makes him closer to his work.
b) Accountability to Errors or Mistakes
Making errors is part of working in a high stress environment and focus should be given to prevent these from recurring. Testers should own up to their mistakes instead of finding someone else to blame it on.
You need to have the courage to admit these and push forward for a solution. Apart from gaining the respect of co-workers, this will also help maintain a good working condition within the team. Hence, moving away from blame and focusing on the solution is what matters. As the saying goes “To err is only human”.
Month: June 2015
10 Simple Ways You Can Improve as a Tester
Being a software tester is no easy task. The ones who strive hard to continuously improve on their skill sets and keep themselves updated about the need of the hour achieve success in this profession. It isn’t just enough to be good tester; you need to be the very best.
Whether you are into mobile application testing or web application testing, the following tips are sure to help you.
1. Always Go For Quality
Identifying the most important bugs and glitches is a talent that needs to be nurtured. This is what companies look for rather that messing it all up by testing for some 10,000 bugs. This talent can alone ensure a fruitful career with the company you work for.
2. Prioritization
This is similar to finding bugs. Know what is of extreme importance and test these critical areas of the application before going into the minute details. This will help you identify the most valuable bugs first thereby allowing the development team to get rid of these as soon as possible.
3. Develop Your Written Communication Skill
A good written communication skill is part of a software tester’s job description. Why? Because more often than not a software tester will have to write a good test case, bug reports and so on. This is an essential part of QA and should be detailed but at the same time simple to understand.
4. Have a Thirst For Knowledge
Learning from your own and others mistakes can help you go a long way. Each time you commit an error, ask yourself; how can I prioritize better during the next test cycle? How can I communicate with the development team better? Your search for the answers will lead you to a better career as a software tester. Also be ready to ask questions to your fellow testers.
5. Professionalism
Having more than one perspective to a problem can help you become an expert at software testing. Test the software without bias and don’t let any past experience with the software make you cocky. Remember!!! No bugs are too big or too small for you to handle.
6. Be Innovative With Your Thoughts
Don’t just test the software in front of you and think that your job is done. Having your own opinion about the software is welcomed by the developers, provided you don’t deviate from the core concept.
7. Question Yourself
Does this work as planned? Does it support all devices? Does it work under every possible use-case, every time? Keep asking these questions at every level of your test to ensure that you get maximum output from the software.
8. Think as a User
Having a user’s mindset helps you to imagine his expectation and experiences of the software. This will help to evaluate the software from a user perspective, even before its launch at a consumer outlet. It will also help you identify the most valuable bugs.
9. Improve Bug Report
To ensure that the developer gets proper information which he/she needs to understand the bug and fix it, try attaching screen shots and providing detailed bug reports. Where, when, how many times, on what devices, which operating system and under what circumstances will throw light on the bug. A bug is useless to a development team without the right details.
10. Let Your Passion Drive You
Passion is the key to succeeding in any field. Always be a step ahead of you competition and be informed, seek new training opportunities, engage with your fellow testers, attend testing conferences and classes. Try getting close to all things QA.
5 Most Common Software Testing Methodologies
Software testing services offer a number of testing models. But for you to choose the right testing model, you need to be aware of the capabilities and shortcomings of each model. In this blog, we help you to choose the testing methodologies that best suits your software testing needs.
Various approaches are used by software testers in software development processes. A software development process is also called a Software Development Life Cycle (SDLC). Here we will discuss 5 of the most frequently used testing methodologies and the advantages and disadvantages of using them in a Software Development Life Cycle.
1. Waterfall Model
Developed by Winston Royce in the early 1970s, it is one of the most basic life cycle models. It was the first successful process model with a sequential development phase. The process flows progressively like that of a waterfall through multiple phases and hence the name waterfall model. The model as such is divided in into the following phases:
- Requirement Gathering and Analysis phase
- Software Design
- Implementation and Testing
- Maintenance
All the phases are sequential and each step is dependent on the previous one. This means that for a particular phase to begin, all the defined set of objectives and goals belonging to the previous step needs to be completed. This can sometimes become a disadvantage, but the simplicity in implementation and ease of maintenance is what fuels the popularity of this model.
The amount of resources required is minimal when compared to other models. A document is created after every phase of the model which helps to better understand and design the system. Creating deadlines for each stage helps to develop the system within a predetermined time frame. This model is rigid and lacks flexibility. It is impossible to make changes in the development of the system.
Advantage
- Simple and easy
- Since the model is rigid, it’s easy to manage
- Clearly defined
- Minimum client intervention
- The only completion can lead to the next phase
Disadvantage
- Can’t be used for a complex project
- Highly risky
- Not meant for big projects
- Changes in the project are not possible
2. V-Model
To overcome the disadvantages of the Waterfall Model, an alternative called V Model was introduced. It enables testing at each phase of SDLC, while the Waterfall Model supports testing only in the end phase. This helped testers to find issues at the earlier stages rather than at the end.
Before the start of actual testing, the testing team works on various activities like preparing the Test Strategy, Test Planning, Creation of Test cases and Test Scripts. These work in parallel with the development activity, helping to get the test completed on time. It is also called the verification or validation model.
In this process, the “Do-Procedure” is handled by the developer team whereas the “Check-Procedure” is followed by the testing team to meet the requirements. The V-model typically consists of the following phases:
1. Unit Testing: Preparation of Unit Test Cases
2. Integration Testing: Preparation of Integration Test Cases
3. System Testing: Preparation of System test cases
4. Acceptance Testing: Preparation of Acceptance Test Cases
Advantage
- Systematic progress
- Extensive functional area coverage
- Works for small projects
- High usage of resources
- Detailed information about the problem with the software
Disadvantage
- The process comes to an abrupt end when the project is finished, in short, re-usability is less
- Not suitable for big projects
- Risk management and risk mitigation is not possible
- Not suitable if there is frequent change in requirement
3. Agile Model
The agile development model is a type of incremental model where the software is developed in incremental, rapid cycles. This produces small incremental releases with each release building on previous functionality. These releases are thoroughly tested to ensure software equality and the model is commonly used for time-critical applications.
It helps in the rapid and continuous delivery of useful software which ensures customer satisfaction. This model promotes constant interaction between customers, developers, and testers, and even facilitates face-to-face conversation.
Such a model demands a clear cut idea about the output or else the project can easily be taken off track. It is difficult for a newbie programmer and constantly requires the services of an experienced hand.
Agile welcomes changes that need to be implemented. This can be done at an affordable cost because of frequent increments that are produced. Unlike the waterfall model, the agile model requires very limited planning to get started with the project.
Advantage
- Rapid continuous delivery
- Changes in requirement will not be an issue
- Concentration on the process
- More focus on customer satisfaction
Disadvantage
- Lengthy documentation
- Cannot be used for small projects
- If the customer is not sure about the project it can derail
- Only experienced testers can be a part of the process
4. Spiral Model
It is similar to the incremental model but gives more emphasis on risk analysis. The spiral model has four phases:
- Planning
- Risk Analysis
- Engineering
- Evaluation.
A software project repeatedly goes through these phases in iterations and in the baseline spiral, starting in the planning phase, requirements are gathered and risk is analyzed. Each subsequent spiral builds on the baseline spiral.
There is a high amount of risk analysis taking place which helps to better avoid them. Additional functionalities can be added at a later stage of development. In spite of the advantages, this is a costly model to use and also the process of risk analysis requires highly specific expertise.
This model is widely used when costs and risk evaluation is of prime importance, especially in those medium to high-risk projects. For users who are unsure of what they need, this model can be quite helpful.
Advantages
- Scope for extensive risk analysis
- High documentation control
- Accurate capturing of requirement
- User can see the system clearly
Disadvantages
- So complex
- End of the project will not be known early
- Only experts can do risk management
- Objectives are hard to define
- Can’t be practiced for small projects
5. RUP
It is an object-oriented and web-enabled program development methodology and is like an online mentor that provides guidelines, templates, and examples for all aspects and stages of program development. RUP is a comprehensive software engineering tool that combines the procedural aspects of development with other components of development within a unifying framework.
Advantage
- An iterative process which is better than the waterfall model in many processes
- Accurate documentation
- Integration requires less time
Disadvantage
- Relies heavily on experts
- Complicated model
- Since the process welcomes integration, it can lead to confusions
RUP establishes four phases of development:
· Inception phase: Developers define the scope of the project and its business.
· Elaboration phase: Developers analyze the project’s needs in greater detail and define its architectural foundation.
· Construction phase: Developers create the application design and source code.
· Transition phase: Developers deliver the system to users.
Why Software Testing isn’t Complete without Test Coverage?
Test coverage or code coverage is a term widely used in software testing services and is considered a part of software maintenance. It is a very useful tool that lets software testers identify untested areas of a code base. By providing data on different coverage items it helps in evaluating the effectiveness of testing.
Together with covering those areas that have not yet been tested, test coverage also helps to monitor and maintain the quality of testing. Measuring test coverage quantitatively will help to determine its quality, as they are indirectly related. It also helps to identify redundant test cases that prevent any increase in coverage thereby providing better software testing services.
How can the output of test coverage help?
- Test Coverage helps to measure traceability between requirements and test cases.
- With the availability of a proper Test mechanism, change tracking and impact analysis will become more effective.
- With proper Test Coverage, defect leakages can be easily prevented.
- It gives an easy way to find gaps in requirements, test cases and defects at unit level.
Read Also : 10 Must-have Tools for Software Testing Services
Tools for Test coverage
The Test Coverage tools are useful as they can easily locate application functionalities and allows exercising the functionalities of interest. What part of the application code is executed will be indicated by the test coverage tool. This helps to easily locate functionality in a very effective manner, especially those in a large, difficult to understand system. Coverage tools help in checking how thoroughly testing has been done.
Tool Features:
- Helps to identify coverage items.
- It lets you calculate the percentage of coverage items that were tested by a set of tests.
- It reports on the coverage items that haven’t yet been tested.
- Generate stubs and drivers.
It is very important to know that achieving 100% statement coverage doesn’t mean that your software is completely tested and error free. This is because coverage tools can only measure the coverage for those items that they can identify. Coverage tools needs to be run often to look at these bits of untested code.
Benefits of Test Coverage
- Helps identify defects during the early stages of a project life cycle.
- In order to increase coverage, additional test cases are created.
- Provides a considerable reduction in UAT defects and production defects which helps achieve a better ROI.
- It helps in finding areas of a program that are not exercised by a set of test cases
- Full control over time, cost and scope.
- Managing the Risk based testing approach makes testing life smoother.
- Determining the quantitative measure of code coverage measures quality of the application or product indirectly.
Recommended Read : Role of Software Testing in Software Development
Drawback of code coverage measurement:
- It can measure only the coverage of what has been written. This means that the code itself cannot say anything about the software that has not been written.
- It can only look at a structure which is already there. If a specified function was omitted or function has not been implemented, then structure-based techniques cannot say anything about them.
Best practices to follow for iOS mobile app testing
There is no doubt about what iOS has done for mobility gaming. The exquisite functionalities coupled with a simple user experience have paved way for the ‘mobile era’. In spite of this, working with the iPhone/iPad mobile application for software testing and monitoring can be challenging.
Challenges and complexities surrounding iOS mobile testing continues to interfere with development even as iOS app market continues to produce a record growth. One of the greatest challenges is in Apple iOS being a closed operating system when compared to an Android OS. The development and app testing stages for a closed system is far more complex, since extracting the necessary data from low level objects is impossible for users. This is crucial for test automation.
The best approach to get the necessary access to these levels of an iOS app testing are rooting (jail-breaking) and compile-time source instrumentation. But nothing can match a cloud-based hybrid approach which can offer developers and software testers the necessary coverage, capabilities and flexibility to deliver better iOS apps.
Rooting (jail-breaking)
These are the two common methods used in today’s mobile testing industry to address the challenges of inadequate access to the low level objects. These are rooting and source instrumentation.
The process of removing the limitations placed by Apple on the iOS devices is called jail-breaking. This helps achieve low level (root) access to the operating system, thus allowing testers to recognize objects within the application being tested.
Source Instrumentation (compile-time)
Compiling the application that is being tested with an additional piece of code to get a back door access to the low level OS for object recognition is referred to as source instrumentation. These codes help testers to execute low level calls and get the Object ID’s from the operating systems without the need to root or jailbreak the device.
The decision on what approach should be adopted depends on several considerations like SDLC process used, corporate policies, application under test, frequency of testing and many more.
Comparison
The jail-breaking approach is less suited in situations where customers need a quick test for a new iOS version or a new iOS device. In such cases, even though additional codes in the test application will complicate the SDLC, compile-time method is preferred.
The advantage of jail-breaking a device is that it lets you test the application with the exact same code by which it will be released. In compile-time before store submission, the “back-door” will have to be removed or they will be exposed to serious security issues. Jail-breaking therefore eliminates the need for compilation and intrusive operations which avoids any risk to quality.
While using a compile-time approach companies should also consider possible regulations (such as HIPAA) which implements testing on the final binary version and not on debug or test friendly version.
The Hybrid Approach
The combined (hybrid) approach lets you choose your iOS app testing methods depending on the nature of your application, project needs, and policy. Deploying and securely managing the test devices in a “private cloud” guarantees that a jailbreak does not introduce any risks or abuse to the platform for non-testing purposes. Such jail-broken devices are used only in a closed and secure testing environment for testing purposes only.
Since the use of visual analysis may pose to be insufficient, a strong object recognition capability is mandatory for testing a mobile application. For example, the OCR technology can detect UI issues and glitches on the test devices while its heuristic nature makes it incapable of ensuring 100% accuracy. On the other hand, a low level object can easy miss the obvious qualifications that a visual analysis could easily detect. That’s why an analysis using a hybrid approach incorporating both visual and native object can be instrumental for covering all mobile business cases.