Author Archives: Talented Tester Support
Author Archives: Talented Tester Support
Back in 2006 I studied for the ISTQB Foundation Level testing certificate. Fortunately the company I was working for at that time paid for my course, which included some instructor led training. This training included ISTQB mock exam questions that helped me prepare.
Back then it would of been good to read a few books to help me prepare. There are now quite a few good books available on this topic, which I will review for you today.
Nowadays, we live in a world where everyone has a tight schedule and we have forgotten to dedicate some time for personal growth, whether you are a working professional or seeking a testing apprenticeship. Just like a healthy balanced diet and exercise are important to our bodies, reading and acquiring knowledge is crucial to our profession.
Therefore, find some time and improve your skills; it will take you to the next level. Don't say you don't have time. Everyone has 24 hours; the difference is how we manage it.
ISTQB stands for the International Software Testing Qualification Board. It is an international software testing organisation with local exam providers.
Each local testing examiner is licensed to issue exams both locally and internationally. A candidate who passes the exam receives an ISTQB certified tester certificate.
ISTQB is found in seventy nations but the names of each Member Board changes from one country to another. For instance, the member board in the United States is known as the American Software Testing Qualification Board (ASTQB) while in India it is Indian Testing Board (ITB). Nevertheless, the exam syllabus, pattern, questions among other details are the same.
Here are some benefits of the ISTQB testing certification:
ISTQB is classified into three levels, as follows:
Note: our interest here is foundation level certification
It is an entry-level certification and it is designed for individuals who wish to move up the ladder of software testing certification. The main goal of this certification is to ensure you understand key software testing concepts and practices.
Its syllabus covers 6 major topics namely: static techniques such as reviews, black box and white box, test management and testing tools, testing fundamentals, software testing lifecycle.
This is how to enrol for the ISTQB Foundation Certification exam. You will agree with me it is an intuitive, simple and short procedure:
Foundation of Software Testing ISTQB Certification is a good guide to software testing and qualification. This is because covers the fundamental principles as well as syllabus in depth. It also comes with many learning aids.
The Software Testing: An ISTQB-BCS Certified Tester Foundation guide is another ISTQB foundation test analyst study book with basic steps of software testing. It also explains how to do tests effectively. This is because offers an overview of several dynamic and static techniques.
Approximately 300,000 people have done the ISTQB certification examinations. Thanks to contributions of experienced authors like Andreas Spiller, Hans Schaefer, and Tilo Linz with the Software Testing Foundation book.
Andreas Spiller is a computer science professor at Hochschule University where he teaches programming, software engineering, and quality assurance. Tito Linz is the founder and chairman of imbus AG, a big player in the software quality assurance industry. While Hans Schaefer is a consultant who has been teaching and consulting software testing techniques since 1984.
This revised edition covers the entry-level and important software testing techniques. It covers topics like fundamentals of testing, test tools, test management, static and dynamic testing techniques, and testing and software lifecycle.
The Agile Testing Foundations: An ISTQB Foundation Level Agile Tester guide is specifically for the Agile extended certification. It is a simple software development approach that is quickly gaining popularity in the information technology industry. It has many benefits such as offering a wider flexibility scope and enhancing the overall product quality. Back to the ISTQB Foundation level syllabus, this book covers Agile basic principles, techniques, and tools crucial in software testing.
Rex Black, the editor has more than 30 years of software and system engineering experience. He is the former president of ASTQB and ISTQB and a co-author of numerous ISTQB syllabi.
The ISTQB Foundation Exam Sample Question Papers by Katie Graner is another important study tool, it has very many challenging questions.
I have researched many books on software testing and for an entry-level person, I found some too hard to read and with a lot of jargon. This was not until a good friend of mine recommended Foundation of Software Testing. This book covers all software testing areas without using hard language that would make reading hard.
Foundation of Software Testing is a very important book in both software testing and qualification. Currently, in the third edition, the book is completely updated and it includes the latest changes in the ISTQB Foundation syllabus. It also adopts a hand-on and practical approach and covers all important topics that you should know as a software and system tester.
Its authors are developers of the syllabus. They are also renowned and experienced international authors, teachers, authorities and exam setters and markets in software testing field.
All the best in your exams!
I remember my grandad explaining how he worked from an apprenticeship up to a working professional in his trade. In his day that was the norm. Nowadays these apprenticeships are quite rare.
Therefore, if you are lucky enough to be considered for an apprentiship role, you need to absolutly nail the interview!
The best way to do that, is to be 100% prepared, so to help you get prepared I have created an article to help you identify the 5 common questions asked in these interviews. This will be beyond generic questions like what is route cause analysis? and what is software quality? These are real word questions that can help you.
This is a fairly general and basic question that most apprenticeship interviews will begin with. Mainly because interviewers prefer, contrary to what we may believe, to make sure you are comfortable and this is a safe question to ask.
But more importantly, they ask this question to determine your level of interest in the job because as a test analyst your biggest asset is your ability to think critically and have a sharp eye for detail . And neither of these traits will reflect from your work if you don’t enjoy the work you do.
Now that we’ve established why you may come across this question, it is now time to contemplate over how you’ll answer it. You need to be honest. Your answer must show your love and enthusiasm for software testing. I would suggest you narrate an anecdote that pushed you towards this field. And as long as your answer reiterates that becoming a testing analyst was your true calling, you’re good!
This is effectively a question that is judging how badly you want to work with this certain company as well as your expertise in their area of operations. Since, companies prefer hiring people who they’re a first priority for, it’s integral for your research on the company and its projects to be very thorough. This will make you come across as an asset rather than a potential candidate.
Also, your work experiences will come in handy because they will elevate your value by showing that not only are you interested in pursuing data analysis in the future but you also enjoy it. This sort of consistency in a candidate works as a positive signal to the company. Thus, make sure you have a spreadsheet with data about the projects you’ve worked on. This leaves a great impression on the interviewer as you come across as an organised and methodical worker.
This is your window to prove that you can work well in a team. It is a quality truly valued by companies and it would be in your advantage to relate a situation where you participated maturely within a group, any leadership position you took or how you collectively as a group tackled a certain problem.
Make sure you’re not making yourself sound dominating towards the rest of the group. Instead, show how you’re a team player. You can also talk about how much fun you had in your experience, what you learnt from your fellow team members and how you grew from working with them. Finally, express your hope and excitement at the prospect of getting a similar opportunity in the future.
To tackle this sort of question, you must have a strong grip on your basic testing knowledge. It would help to know the various kinds of testing approaches available and how each approach differs from in the other and thus, makes one suitable over the other in different situations.
You must also be aware of the importance of each kind of testing methodology. Moreover, you should be able to pick the one you’re most comfortable using, as well as why you prefer it over the others. It would strengthen your case if you can provide relevant examples or work experience to prove your familiarity with the subject at hand.
Along with this, knowing about the domain and memorizing various data analysis terminologies along with their functions can come in very handy because there will definitely be a question testing your knowledge.
Generally, interviews end with the interviewer presenting a scenario which you will be asked to figure out. You need to understand that as long as your concepts of testing knowledge are clear, you’re in a relatively safe zone. The test here isn’t about your knowledge but about how fast you can think on your feet. So stay calm because if you panic, you’ll cause yourself more harm than good. Therefore, pause for a few minutes and take your time to think.
Don’t rush into it because the answer is never too simple. After you’ve formulated what you have to say, say it with confidence because your outward demeanor speaks volumes about your character especially in stressful situations.
Worse scenario: you’re completely stumped and have no idea. In such situations, it’s essential to remember to not give up without trying. Usually when they see you trying, they tend to help you reach the conclusion. So, don’t lose hope and keep pushing.
In the end, you need to remember to stride in with confidence, trust your instincts, get enough sleep before your interview and keep your CV handy.
These were my five most important interview questions that you can come across at your data analyst apprenticeship interview. Not only will they help you ace the interview with your knowledge about the subject matter but will allow the interviewers a glance into your personality.
For most interviewers, it is the character of an employee that holds most value. Hence, go through this article for when you prep for that interview- which shouldn’t scare you so much anymore. And let me know if these questions helped you in any way. If you liked this article then don’t forget to like, comment and share! Good Luck!
Every day people are faced with problems that need immediate resolution for operations to go on. Also, a lot of times people end up dealing with the matter lightly, only for the issue to resurface. However, to entirely solve a problem, its root cause must be established, and from then on the right steps can be taken to avoid the matter resurfacing.
Root cause analysis (RCA) is the process followed until the chief reason for a problem is determined and eventually solved, helping you to improve quality. Once the source is found and eliminated, you no longer have to worry about the problems you faced reemerging.
For example, you might own a laptop, and you are used to it working fine. All of a sudden, the machine may start responding slowly to commands. Upon rebooting it, the first few minutes it might seem to have regained its efficiency, but soon begins lagging again. At this point there might be several problems causing your laptop to malfunction;
At this moment, all the above are known as causal factors, since you are not yet sure where the exact problem lies.
RCA can be subdivided into several meticulous steps that lead one to find the exact underlying of the problem.
Step 1: Identify all the problem’s causal factors
The initial step in root cause analysis is determining all the issues that may have led to the change in performance. With the earlier mentioned laptop, the reason for the slump in performance might be an internal system problem, like a corrupt operating system.
Similarly, you might have accidentally knocked it and distorted the hard disk, causing it to malfunction. At this point, list all the possible factors that might cause the problem until you have exhausted all of them. The more causal factors you have, the more likely you are to get to the root cause.
According to Towards Data Science, it is never wise to assume that the problem might have only happened when you noticed it. Chances are the root cause may have happened days or even weeks before, and you need to trace the chain of events leading to the problem you are facing.
You now have a list of all the factors that could lead to your misfortune. Since you know that not all of them have the likelihood of causing the trouble you face, rank them in order from the one with the highest possibility to the one with the lowest. Good judgment is needed to narrow down the list efficiently.
With the example of the laptop, lagging can be caused by several factors. A virus in the system, or even an outdated driver software. A virus attacking the computer is a viable reason as viruses insert themselves in the middle of the operating system and start altering system files. You could rule out the possibility of a hardware component causing the issue since you could have already discovered it.
In this stage, you also need to troubleshoot your most potent causal factors until you find the one that solves the problem. For instance, you might try to update all the devices drivers. If the lagging persists, then you know your problem doesn’t lie in the drivers. You can also uninstall some of the programs you recently installed and see if the problem goes away or perseveres.
With your list of a possible factors, ranked from highest to lowest capabilities, the next step of action is determining the root cause. To help you do this, you need to determine what factors can lead to the causal factors. You might have accessed an insecure website while browsing, or you may have even installed a new program on your device before your lagging problem commenced.
You also need to determine other effects the problem might be causing besides just making your laptop lag. The diminished performance might mean you do not finish reports or assignments on time and eventually might land in trouble at school or work. Such additional problems are known as correlated results.
Also, the program you last installed might have caused the lagging because it was affected by a virus. The program, in this case, is called a contributing factor.
You can further break down the program problem into smaller bits to better investigate and understand the problem. Maybe it’s not compatible with your laptop. You might also have downloaded it from an untrusted site, and further installed it without scanning for viruses. Work backward, asking yourself a series of “Why” questions until you arrive at the root cause of the problem.
You have worked your way back on the possible causes of the matter and have concluded that your computer’s lagging is as a result of a virus in the system. This might be true because viruses have the tendency to hide and only affect some programs. An outdated antivirus program will be the root cause of the problem in this case. An up-to-date software can search deep in the system and remove already manifested harmful programs, let alone blocking them from entering the system.
Now that you have updated your antivirus program and the problem has been eradicated, it is up to you to ensure the problem does not surface again. You will only achieve that provided your virus definitions are always updated. If you are forgetful, you can set the program to give you reminders every once in a while.
Root Cause Analysis will always solve the problem from the root itself. In addition to that, it does so in a fast and cost-effective manner. Through this method, you can also find that you create solutions to problems that haven’t even manifested yet, as well as uncover other relationships between problems and their symptoms. Eventually, it also helps you to establish long-lasting solutions to any problem.
Do you know what software programmers dread the most? Testing.
Have you ever encountered a situation where the software you’re using - regardless of whether it’s on the computer, your smartphone or your tablet - didn’t quite give you the result it expected?
Sometimes it’s plain wrong, sometimes just bizarre and sometimes just in a state where stubbornly refuses to give you a response. We’d be surprised if you haven’t, as almost every software ever created has had bugs, errors and defects built into it. Not on purpose, but simply because of the monumental task it is to create 100% perfect quality software.
You could even go so far as to say that quality software isn’t that which is without bugs and errors, it’s that which has the least bugs and errors.
Technically speaking, software quality is the degree to which a software’s performance and features meets the expectations. In other words, is it doing what it’s supposed to do, and does it ever act funny?
In practice, it covers multiple elements, such as design and interface, reliability, reusability, consistency of output and of course, functionality. The better these qualities show themselves in the execution of the software’s operations, the better the software quality.
A software may pass off as satisfactory by providing the right results, regardless of the testing or development model, even if it lacks in the design and durability department. But if defects prevent correct computation, then the software is worth nothing at all. However pretty it might be, you wouldn’t use a calculator that calculated 1 + 1 to be 3, would you?
It then becomes necessary to take software through a stringent quality testing process to ensure that it’s doing it’s job. That’s what we’ll be taking you through today.
Good software is a lot of things. What it definitely isn’t is simply the correct execution of its tasks.
According to Virginia Tech, there are 6 qualities that are a sign of good software.
Specific testing methods can help a developer make sure that each of the requirements are met under various circumstances of use. It has to also be capable of being easily maintained (“maintainability”). What if your client requires a moderate change to the program? An amateur software developer would rewrite the whole program; a good one would have accounted for such a possibility and allowed for modular changes that enable new requirements to fit in snugly with the old program.
“Reliability” and “Reusability” come next. No software is technically 100% reliable, but the aim for a high degree of reliability should always be present. If, under regular operating circumstances, a software fails, and fails often, it is said to be unreliable. In some cases, such as in air traffic control, a minor drop in reliability can have severe consequences. It work hand in hand with correctness and maintainability. Reusability is self-explanatory: can your software be used again, for some other purpose? Has it been designed in such a way that some of its functions may be transmitted to other programs with common requirements, thereby saving you time?
“Portability” is another feature that simply measures how well your software can be used on a wide variety of systems. There are a large variety of computer systems which clients often deal with and you’ll want to be certain that it can run on as many of them as possible. “Efficiency” measures how optimized your program is, in terms of computer resource. Efficient software uses as little as possible, giving your client a better experience overall.
Believe or not, money is one of the biggest consequences of poor software. The enormous time spent in debugging poorly written code results in hundreds of billions of dollars of lost revenue, as discovered by Cambridge University.
Lost time is another result. Clients are stubborn about their requirements, and when you deliver code that is imperfect or downright wrong, they expect it to be corrected - as they should. You’ll only end up wasting more time correcting something that could have been written properly the first time around.
There are far darker consequences as well, depending on the purpose of the software. Stock market crashes and airline delays have been known to have been affected by software bugs. Thousands of people can be stranded halfway across the world, many companies and vested stakeholders lose enormous sums of money because of overlooked errors in the original program. Heaven forbid there being errors in a hospital’s software program.
Broadly speaking, there are three different kinds of faults with software: errors, defects called bugs or faults and failure, according to SoftwareTestingBooks. The first is when the programmer makes a mistake that results in incorrect output. The second when there is some internal mismatch or conflict in a component or series of components of the software that prevents the function from being carried out. The last is when the program simply does not provide the correct result.
It is the defects that are hardest to deal with as they require a close examination of the code.
Test. Test. Test.
And there all kinds of tests. They can be divided into two categories, let’s call them strategic and tactical. Tests that are strategic are automated, manual, exploratory tests, while the tactics used to perform the tests are unit, integration and functional, according to Atlassian.
You can check individual components of the software with unit tests, a subsystem of the program with integration tests and the whole end-to-end process of use with functional tests. These let you narrow down the problem areas.
Computers can be programmed to check the repetitive aspects of the software for correctness, while manual tests are used to check aspects of the software output that usually involve the customer experience. Exploratory testing is like field testing: you get a group of people who broadly represent your software target audience, and give them guidelines to check if it’s working. Essentially, you’re testing the software as if it’s “out there”, though with some supervision, according to Atlassian.
Watch the open lecture on software testing by Professor James Bach (video below). It’s a fantastically entertaining and informative watch that takes you through the whole of software testing.
Software is a quite complex endeavour, though also extremely interesting. At any rate, it is vital if you want to deliver good software and develop a good reputation. You can’t skimp on it!
Software testing is one of the vital phases of software development since some mistakes might be too costly. Projects developing totally new software are commonly challenged with doubts concerning software requirements as well as realization tools.
As a professional software developer, you spend most of your time working with clients that have very limited knowledge about programming, and most of the time, they cannot fully explain what they actually want you to develop.
This little misunderstanding can cause big troubles. In such cases, it is of utmost importance to constantly communicate and gather information from the customer.
If that happens to you, we recommend you to apply the iterative and incremental software development approach (IID) as it allows swift response to alterations, unlike historical methodologies, such as the waterfall model.
Therefore, I decided to provide you with some valuable information about the Iterative-Incremental Development model throughout this article.
Defining Interactive-Incremental Development According to Mockus and Herbsleb (2011) Iterative-Incremental Development is one of the methods of Agile software development, extreme programming and rational integrated procedure.
Iterative-incremental model is an approach of software development, which is formed around a steady enhancement in component additions along with a cyclic releases and pattern upgrading.
It starts with planning and carried out through iterative progression cycles that consist of constant customer response and the incremental computation of extra features, finished with the utilization of completed software before moving onto the next cycle (Larman, 2003).
In short, Incremental is a process of adding new components in small pieces whereas the iterative is a process of acting upon the project repetitively, for example, adding new components in cyclic way.
You first have to identify the software requirements, analyze them, and based on your analysis, you design the software and start coding to develop the designed model. Once you are finished, you conduct with the customer, gather feedback and move onto the next software product increment phase or cycle, where you repeat the steps you took at first cycle, but this time you take those steps based on the freshly gathered feedback and information.
The cycle continuous until the end product is perfectly delivered (Larman, 2003).
The perfect examples of iterative-incremental software development approach can be:
The Pros and Cons of Applying Iterative-Incremental Development Let’s be real. There is no perfect approach to software development and as all the other application development models, the iterative-incremental software development model also has its pros and cons.
Let’s take a look at the advantages that IID offers:
Even though the advantages sound good, a professional programmer should be aware of the following disadvantages of IID:
The Iterative-Incremental Approach is a great software development method, however, a good programmer should know when to actually apply this approach in practice.
If you are completely new to this approach, here are the suggested occasions when you can actually apply this method in your project:
Thus, the product can only be perfectly delivered until going on different cycles of development. Throughout this article, we tried to characterize one of the popular software development methods that widely used in practice nowadays.
Moreover, we decided to include this video tutorial that can help you learn more about Iterative-Incremental Software Development Method:
In this video, the author explains IID approach cycles in great detail.
a constant communication is a fundamental necessity for successful realization of Iterative-Incremental Development method. Particularly uncertainties in the form of shifting requirements may require more communication between the software engineer and client for better understanding and problem solving (Larman, 2003).
Within indecisive working conditions, short iteration phases are required to disclose issues as early as possible. If the iteration cycle is longer, the importance of the communication can be vital for integration part. Without a proper communication and understanding between the parties, it is impossible to successfully implement IID.
What is web testing? This is the practice of looking thoroughly over a web application for errors before it is made public for use. The main reason is to find defects that can negatively impact the website in future. This process can also be used as a platform for finding areas to improve to produce better results from the application.
Generally, there are many ways to perform web testing. Testing ensures that the scope, security, and functionality of the web are correctly working. The following are the basic tests performed for a website before it is launched: functionality testing, usability testing, interface testing, compatibility testing, performance testing and finally security testing.
Let’s have a look at each of them:
Software engineers call it “functional testing” also known as “functionality testing”. Basically ensuring all components work right.
This testing involves verifying that the web application works according to its documentation and specifications. This is generally ensuring that the forms work properly, links among homepages, connection with the database, and the user interface etc. works well according to its intended purpose.
These tests are documented in the test scripts, which test the functionality and specs. This test includes activities such as identifying the expected web functions, data sets, e.g. a drop down list of pre-defined values, data input and the output.
This is one of the most often asked questions in software testing classes and testing-related google searches as newcomers in the testing business are surrounded by confusion regarding the terminology.
Testing is a crucial part of any software development project as it ensures the project has no serious flaws or bugs that will later take a lot of resources and time to fix. But before any testing begins there are two documents that need to be drafted and approved: the test strategy and the test plan.
To be able to understand the difference between them one must first know what these documents mean and what they are useful for.
This is a document developed by the Test Manager and is a high-level document. It defines the approach the team will have in achieving the testing objectives. It derives from the Business Requirements document and it sets the standards for the testing processes and activities. As appose to an actual testing model, such as The Waterfall, this is the high level strategy.
The Test strategy includes the following:
Scope and objectives–the test strategy defines the business objectives and the test scope;
Business issues – the budget of the project, the amount of time allocated for testing, the resources needed and other parameters such as these are defined and set before the testing begins.
Testing approach–the document establishes what type of testing will be carried out (performance, functional, stress, load) and if the testing will be done automatically or only manually.
Test deliverables – will list the documents needed from the testing team and also the method they’ll use for testing record keeping.
Defect tracking approach–the test strategy defines the tools the team will use to keep track of the defects and the data flow between the testing and the development teams.
Training –this is especially important if new tools are introduced in the project. The test strategy also defines the type of training that’s needed and the person or entity in charge of delivering them.
Other relevant information – testing measurements and metrics, change and configuration management, risk management, automation information, if it’s being used.
In smaller projects, the test strategy is just a section of the test plan as it’s not practical to separate the two. According to differencebetween, in large companies with many projects, there is usually one test strategy and a lot of test plans, typically one plan for every major component.
According to getzephyr.com, The test plan focuses on describing what, how and when to test. The document is necessary as the test strategy only covers a whole range of modules and it covers general principles on how to approach the testing process. The test plan, on the other hand, focuses more on the specifics, the details of who and how is responsible for testing.
The test plan has the following components:
Test plan ID–it’s a unique code that it’s assigned to every plan.
Test environment – defines the environment that’s needed in order to carry out the testing. It’s the setup of both hardware and software that’s required by the test teams in order to execute test cases. It allows the team to carry out the tests by being configured with the necessary hardware, software and network.
Features to be tested or not – this section defines in details the software features that will be tested as well as the ones that will not be tested for any reason. They might not be available in that version of the software, for example.
Types of testing - the testing plan defines and describes in details the testing method used for every feature (stress, performance, usability, acceptance, integration, system etc).
Entry/ Exit criteria – basically specify when the testing has to start and when to stop.
Other relevant information such as status, testing tasks, pass or fail criteria, schedule, responsibilities, test items and a brief introduction.
The test plan is very specific as it tells the team or even the team members what to test and when as well as criteria used for testing.
A single development project can have multiple Test Plans and a waterfall project can have a test plan for every type of testing, as it is in an Agile project, for example, according to Focus Professional Services.
When we put together the characteristics of the test strategy and the test plan, we observe some crucial differences.
1. The Test Plan is formulated from SRS (Software Requirement Specification) and it describes the scope of testing as well as the activities performed, in detail. The test strategy describes the way testing is carried out, according to Art of Testing.
2. The test plan is very detailed and specific when the test strategy talks about the general approach to testing.
3. The test plan is subject to change while the test strategy remains untouched.
4. The test plan is always a standalone document, the test strategy can be, in smaller projects, included in the test plan.
5. While the test strategy is set at the organization level, the test plan is defined only at the project level.
6. The test strategy outlines the necessary resources to complete the testing while the test plan assigns the testing tasks to specific roles.
7. The testing strategy talks about the company vision and the expected results, the testing plan explains what needs to be done in order to achieve those results.
And the differences continue. The development of the testing plan, as well as the testing strategy, is viewed by many people as the most important part of testing and it really pays to have a very good plan that specifies clearly what steps are needed to ensure an error-free product.
Both these documents, however, are just pieces of paper unless they are checked regularly against the reality of the testing process and if the test plan is not updated to the current testing needs.
So, what is the difference between a test case and a test script? If this is something you've been asking yourself lately then you happen to be in just the right place. We'll first start by explaining what a Test Case is.
A test case is basically the specification of execution orders, inputs, expected results and testing procedures that define a series of single tests to be done with the main goal of achieving certain software testing objectives. These testing objectives could include compliance verification of specific requirements or exercising particular program paths.
Test cases rely on methodical testing procedures rather than the haphazard way of doing things. The desired coverage for software testing can be produced by building a series of test cases using this technique.
Test cases that have been formally defined give those same tests the ability to run repeatedly against the software's successive version. What this does is it allows for consistent as well as effective regression testing.
In order for an application's requirements to be fully tested, each requirement will require you to run a minimum of two test cases each. A negative test as well as a positive test.
Expected outputs and known inputs are the characteristics of a formal test case. Test cases based on normally accepted program operations are informally written test cases.
Now for the Test Script description. This is basically a script module consisting of system instructions for testing purposes. The fact that you need to write actual coding language to produce this tool is why people in the IT realm gave this procedure the term "test script".
The development of test scripts can be done in very many ways. A clear example is, when working with programming codebase that's object oriented, developers and programmers can access testing objects using several different strategies.
In other cases, developers and programmers, once again, can take huge advantage of APIs or Application Programming Interfaces for the creation of high quality test scripts, which will in turn lead to development projects with high functionality levels.
In general, test scripts are basically mediums that give IT professionals the ability to determine predetermined input results and test case isolations. This is comprehensive testing's strategy for the elimination of glitches and bugs as well as the promotion of better software service and product functionality. Test harnesses are the test script repositories and the text execution engines.
Any functionality that allows for testing is what a Test Scenario basically is. Most IT professionals also commonly refer to this as Test Condition or Test Possibility as well. In this approach, you as a software tester, will need to figure out real world scenarios by using the end user's point of view, as well as using the cases of the application that is currently being tested.
Two words make up Test Scenario. These are Test and Scenario. Here, "Test" represents verification or validation while "Scenario" is meant to represent the user journey's verification process.
Normally you'll find that large amounts of possible paths as well as large amounts of data combinations in the software will usually restrict you from using exhaustive testing, however, Scenario Testing ensures that the application's end to end functionality that is currently being tested is working as it should and it also makes sure that the business flows involved are also working as expected.
As Scenarios are just basically the User Journeys, in this approach the software tester, when checking the applications performance, just has to walk in the end user's shoes.
The Test Scenario's preparation stage is most often times the most vital part of the whole process. You as the software tester using this approach will need to get help or consult the business user, client, developer or business analyst. After the determination of these test scenarios is when you can begin to write test cases for each scenario.
The high level concepts of what need to be tested are what make up Test Scenarios.
If you're an IT professional in this day and age, then you might want to consider fully understanding the fundamentals of Test Plan. It has the ability of making some of your work so much easier as well as way more effective.
Always try to make the test plan as concise as possible if you want the plan to be as effective as possible and avoid superfluousness and redundancy, and with that you'll be good to go. Hopefully, you now know a lot more about Test Plan.
Regression testing is defined as the process of testing a changed software to ensure that the older established features still work as they should. It is a crucial step in software development as it eliminates many of the risks associated with software updates.
Although some organizations verify critical functionality only once and they presume it will continue to work fine unless it’s been purposely modified, the practice has shown that even routine changes in code can have unthought-of side effects that break previously established functionality.
It is essential as it provides the only reliable tool that verifies that the code changes don’t break the existing functionality of an application and it has a huge impact on release delays, budget overruns and the possibility of bugged errored software being released.
Regression testing determines when code alterations cause previously working functionality to fail, giving you the opportunity to identify errors in real time.
For a software that was previously working flawlessly, this can change if the updates included incorrect or incomplete changes. This occurs extremely often in the software industry. Generally, one of six attempts to correct a defect is faulty and generates additional errors.
This high rate of the defects has several reasons. First, it’s the tendency developers have to fix the symptoms instead of the root cause. Other factors can be the lack of experience of the developers or poor system documentation, often seen in the agile methodology, as appose to the waterfall model.
These techniques exist to focus our testing on the aspects that could have been affected by the code changes instead of covering all possible aspects that could go wrong.
Full testing (Retest All) aims to cover as many issues as possible and it’s basically running all tests after every change to the code is made. It’s the complete technique and sometimes the only option when you can’t predict which part of the software was affected by the update.
Regression test selection aims only at the modules that were more likely to be affected by the changes. As it is not complete, I can let errors slip through so it’s extremely important to receive a very high ROI.
Test Case Prioritization is approached in two different ways: general prioritization when cases are chosen based on their importance and version-specific prioritization when cases are chosen based on their importance for that specific version.
Hybrid combines any or all of the above techniques for various releases.
When you create your regression testing plan and you’re opting for one technique or the other, there are a few things you should keep in mind:
1. Use automation – nothing can make your process more efficient than automation. Repeated testing under the same conditions and with the same variables will not discover any new defects. Also, repeated tasks will make your testers lose concentration and they might miss some of the defects.
The biggest advantage of automated regression testing is that you can add extra test cases to the regression pack without increasing the testing time too much. And more, the automated test can be run during the night or at the same time with the manual tests.
2. Update your regression pack regularly – It is always a good idea to keep your regression pack up to date. As your project increases, some of the newest functionality won’t have enough test coverage while some other tests might not be necessary anymore.
3. Use an element 'id’ to locate items on screen. Original automation tests recorded actions they later replayed. They could simulate the clicking on a certain pixel’s location. However, if that button was moved, the clicking will take place in the wrong location. Calling it by name instead of location allow the test to continue no matter where the button was moved.
4. Analyze every defect that escaped the previous testing - this will allow you to figure out what went wrong and to include tests that can possibly cover that path and detect that particular type of defect.
5. Focus on busy paths – they should include the basic functionality of your software as well as the most used features. This implies you know your users and those features they rely on the most. Your regression pack should focus on the core functionality of your application.
6. Identify those areas that have shown the most failures and include in your regression pack more tests that focus on those areas.
7. Don’t forget to include tests that cover non-functional attributes such as performance, usability, security.
The latter are simple substitutes to Enterprise IDEs but they offer advanced functionality, like DOM comparison, collaboration functionality, etc.
When developers change or update their applications, the smallest modification can have unforeseen ramifications. Regression testing is the only way to ensure the modification hasn’t broken existing functionality. By re-running testing scenarios that were designed when original problems were fixed you can make sure your update didn’t cause previously solved bugs to re-appear.
Regression testing needs to be seen as a piece of a testing methodology that’s cost-effective but still complete and that incorporates enough variety, like for example frontend UI automated tests combined with targeted unit testing using risk prioritization. This will prevent any aspect of your application from being unchecked.
Software development companies with effective regression packs improve their performance of their developers significantly thus leading to a successful project.
The discovery of errors on time can save a lot of time wasted on chasing errors further in the development cycle. It also allows the team to update the code when necessary without being afraid it will compromise previously established functionality.
The Waterfall model, also known as linear sequential design, is a software development model. Just like the name suggests, the development flows only in one direction, which is downwards.
According to Oxagile, this sequential development ends up releasing a new software product. The key to this Waterfall Model’s framework is that it proceeds with each requirement step by step and never goes backwards..
The linear sequential design follows a program full of activities that need to be accomplished correctly before moving on to the next one.
This won’t allow you to leave any open stages because you won’t be able to proceed to the next task. All of the phases are planned and designed beforehand.
I highly recommend you to watch this YouTube video, that goes through the basics of this development model. This will help you understand all the aspects explained in the article. It’s named “What is Waterfall Methodology?” and it is created by Project Management Software – Easy Projects.
If you are still trying to understand how this software development model works, it is essential for you to get acquainted with all the steps that you will be required to pass before reaching the final result.
The most important thing you should keep in mind while going though this software development model is to have a clear vision of the project and to understand properly what you are aiming for.
The Waterfall Model is very useful and easy to follow, only if the idea and its stages are perfectly identified. According to a Tech Republic article, the following are the phases to a successful development.
One of the first steps is brainstorming and defining a concept. Investigate the target briefly to get an idea of their needs and find out the perfect product.
Once you resolve all of those questions, you need to do an exhaustive research of the clients and customers that you will be directing to. Define your target and investigate what they need and where they are from.
Once you have your customer’s area controlled, it is time to start designing. You will need to plan a strategy that solves each of the problems that are presented. Apart from that, you will need to program other aspects like the language.
The next step is to start constructing it. Once all the ideas are clear, you will be able to start with the next step, which is implementing the solutions to every stated problem and constructing the final product.
Once the construction part of the development is done, you should start testing it. Verify that it accomplishes all the requirements you named before. Also, check out if they are totally error-free.
There are three different types of testing that are usually put into practice. The first one is called unit testing of code modules, which makes sure that all the coding is properly set up.
Then you should proceed with the system testing and finally, the acceptance testing.
The next step is deployment. When you check and verify that everything is working properly, you will be able to install the final product. The last step is the maintenance of the software result you just created.
The Waterfall Model is well known for its multiple advantages when it comes to creating and developing a new software product from scratch.
In agreement with an article of Tech Target, the first thing to note is how organized the process is. This means that every step or activity has a deadline that needs to be respected and followed strictly.
Every task has a starting and ending point that needs to be accomplished in a limited time.
Dividing the development of the software in other departments makes it easier to manage and control. The rigid model usually turns into a successful final project.
Another advantage to keep in mind is that usually this model requires a lot of beforehand strategic thinking and planning. This is why so many problems are found in the early stages and can be avoided.
The model is also popular for its simplicity. As mentioned before, the planning is so well organized that everyone is able to understand the process. Moreover, the tasks never overlap each other, so there are no confusions.
All of the processes are completed one at a time, that is why the model is strict to follow but the durability of the activities is much shorter and effective than if you use any other development model.
After going through all of the advantages that this software development model has, it is fair to display some of the disadvantages.
One of the aspects that most people tend to dislike according to Armarjeet Chavan is the fact that once you complete one task, you are not able to step back and modify it.
Sometimes, there is a possibility that you might be able to change something but it will surely end up being extremely expensive and will add extra cost to your project.
That is why the Waterfall Model is only supposed to be used when the idea of the product is very clear and all of the requirements are understood beforehand.
However, it is true that due to its fast development, it makes it a little bit difficult and complicated to revise all the work, as well as to verify if it is going on the right path.
Another disadvantage is the difficulty to solve all the problems even before starting with the process. You may estimate the basic things that will get on your way but maybe not each and every one of them.
For example, you could have designed something that later turns out to cost a lot more money or it is just too difficult to produce. This is why some people state that this development model is unrealistic.
Finally, this model should only be used in short and simple projects because if you try to apply this to a complex development, the risk of needing to change any requirement is higher.
And as suggested above, this will only result in extra expenses or even a failure of the project.
Hello and welcome to part three of the ISTQB Foundation answer to questions. In case this is the first time that you’ve checked out one of these please feel free to go back and look at part one and part two.
If you would like to download the entire list of answers to questions on PDF or in PDF format, then click here.
I’m gonna be focusing in on three questions taken from sample paper number two. This is freely available for download at the main website TalentedTester.com. And the questions that we’re gonna be focusing in on this week is going to be questions 2, 7, and 15.
The first question is, “Why is a test strategy important?” Is it:
Image by: Flavio~
So have a think about those potential answers and then I’m going to highlight the correct one. The correct answer is B, and it is software defects can cause a number of critical problems including death, injury, financial loss of time, and poor customer experience, meaning it is important to have a test strategy. Bear in mind that you will have a lot of similar structured questions in the actual exam, multiple choice to try and catch you off guard, so it’s a case of just understanding the criteria and obviously having a good understanding of why it is correct.
Notice I said, “Not included.” This is another thing that can catch people off guard is when they use stuff like, “Not.” So it’s the complete opposite, and you may quickly scan through the question and the paper, and then just overlook that you’re actually looking at what is not included. So let’s have a quick look at these:
a) Reporting on defects.
b) Triage the defects with the development team.
c) Changing the status of the defects.
d) White box testing.
Image by: marcdalio
So have a look at these four answers. Think of, logically, which would be the correct one, make a selection, and, in just a few seconds, I’ll reveal the correct answer for your knowledge.
The correct answer is D, white box testing is not included in defect management. Remember the question is, “What’s not included?” So this is obviously the one that we need to isolate.
a) Project managers.
b) System testers.
d) Business analysts.
Have a think about these four potential answers. Think logically which will be the correct one, and then I’m going to reveal the answer shortly.
The correct answer is C, programmers. Which person typically uses static analysis tools? And for this the answer is programmers. So hopefully you’ve got this question correct. And hopefully all of the other three questions have made since. If not, you can add them to your list of questions and answers that can help you prepare for the exam and your study.
If you want a free exam question example paper or even download the exact PDF, which supports … includes the questions that have been covered today and a lot more or even additional mock papers, then click here. Thank you and hope to see you on the website.