Very concerned about the quality of the products. This explains the worldwide availability of software testers. By providing, these people ensure its quality.
Many testers will never forget about negative testing, although not all programmers are happy with this. Such control is needed to protect against hackers, bots, Dos/DDos attacks.
What is the calling of testers? They must find problems that are not visible to others. Don't procrastinate with negative testing or you're putting the system in danger.
Positive and negative testing
Let's start from the very beginning. There are 2 types of control when test cases are included in testing: positive and negative. The latter has the advantage.
positive testing is the process of checking for correct behavior according to specifications and documentation. Positive testing is performed to ensure that the system does exactly what is expected.
Negative Testing is the process of checking for incorrect behavior. Through such testing, we can learn that the system will cope with unforeseen situations.
positive-negative testing
To perform software testing, you need to have intuition or a hunting instinct. A tester is a versatile person who can perform both business analysis and testing.
Testers check whether the process is running correctly: whether there is compliance with technical requirements and test scenarios. Running positive and negative testing separately will take longer than doing them all at the same time. This is because there are two test iterations.
After all, the closer to hour X, the faster time passes and the sooner you need to complete tasks, fix defects, apply business requirements (which may vary), and get more done. Deadline is the hottest time!
Separating negative and positive testing is simply against the nature of the tester! Its task is to check the system for all possible actions of the end user.
Humans are basically illogical and can cause problems in software. Negative testing will help avoid problems.
We (it's not such a secret) are very worried about the quality of our products and are watching the collapse of the system with trepidation. This justifies the existence of testers in the world. It makes us feel like heroes: the great Tester came and saved his users from terrible critical bugs!
And our testers never forget about negative testing, although not all progers are happy about it. But such checks are not a whim of "evil testers", they are caused by the need to close vulnerabilities and protect yourself from hackers and bots, Dos / DDos attacks entering the system.
Of course, what is the calling of test specialists? Need to find problems. Problems that no one most often has time to think about, does not want to see them and deal with them. And if not only the correct operation of the system is checked, but also its abnormal behavior, then tension in the team is added.
You see, programmers write software aiming at the result, at the planned release, they fly on the wings of inspiration! And then comes the stage of verification and numerous corrections and edits of the "ideal" code. And that's it, hide in all directions, the system is being tested.
In order not to annoy anyone, some specialists may postpone negative testing until later or ignore it altogether (horror!) For the sake of reducing time and budget. Well, why check if the program does not even do what it should, right? Nope.
Positive and negative testing
But first things first. When testing software with test cases, there are two sets of checks: positive and negative. And the second is usually more than the first.
positive testing- this is a check of the system for compliance with its normal (regular, expected) behavior, according to the TOR and. That is, here we look at whether the software does what is expected of it, whether the implementation meets modern requirements, whether user interface guidelines are supported, etc.
BUT negative testing is testing the system for abnormal behavior. We look at whether the software is resistant to incorrect data entry, how exceptions are handled, what information is shown in error messages, whether it is possible to disrupt the operation of the product and / or affect the performance of the solution, and so on.
We have already said that some experts leave negative testing for later or forget about it altogether, which is almost the same thing. You know, what is postponed until later almost always remains unfulfilled.
Therefore, in our opinion,
Negative and positive testing generally do not need to be separated and spread over time.
Because can we tell that a system is working as it should if we test its response only to the right inputs?
positive-negative testing
When testing, oh, how important intuition, feel, hunting instincts are - call it what you want. And here sits such our engineer, checks the registration form, for example.
He checks everything according to the technical specifications and test scenarios, looks at how the data is processed, which the user must enter into the fields (not the fact that he will enter, by the way) and here it is - insight! It seems to him that if you enter some “% adynadyn />” into this login field, and not plain text, then something will definitely happen. Something dark and gloomy wrong.
So what? He must say to himself, “No. Now I have to do positive testing and nothing else. Here I have a negative one scheduled for next week, then the time will come for% adynadyn />. Probably"?
We consider this approach to negative testing to be ineffective, and here's why:
- If you conduct positive and negative testing separately, it will be longer. At least because it will be two iterations of testing.
- Testers and coders live with deadlines. And if time is strictly limited, then postponing negative testing for later increases the risk that it will be forgotten altogether. After all, the closer to the moment X, the faster time flies, the sooner you need to complete the tasks, fix the defects, apply the final business requirements (which may change) and finish a bunch of other things. Deadline - the time is hot!
- The separation of negative and positive testing, in our opinion, is simply contrary to the nature of the tester! After all, its main task is to check the system for all possible actions of the end user. And people are mostly illogical, and can do a variety of indecent things with software;)
We, as testers, are very worried if the system contains errors on checks from the negative category. And especially if the consequences of such errors are critical for the entire system. But we are not afraid to report them. Especially with such a trick up our sleeve - we have female testers in our team. And who can stubbornly defend the “ideality” of the code when they smash the project’s performance with gentle voices to smithereens? That's the same.
So what conclusions can we draw?
Do not forget about negative testing, combine it with positive, gather experienced specialists in a team and try to shift the task of reporting onto the shoulders of girls! Everything except the last one is 100% recommended, and your project manager will deal with it.
And, of course, be sure to check your product, don't think that programmers will immediately write clean and beautiful code - you still can't do without bugs! Not to mention numerous vulnerabilities, which is confirmed by personal and confidential data regularly leaking into the network.
Tests on pictures and drawings can tell about a person’s personality even what he himself does not know. An abstract drawing will tell you what your thinking is and what it says.
The test that we will offer you is based on the test of the Swiss psychologist Hermann Rorschach. It was based on 10 amorphous spots-blots, which were asked to examine the subjects. Variations of this visual test are widely known. And today, such tasks are used for a variety of purposes, from diagnosing depression to testing the power of imagination.
Our express test is based on one such abstract image. Everyone can see something of their own in it. Take a look at this abstraction and fix the association that it reminded you of. Do not look for any specific similarity, do not sit over the drawing for too long: the brighter and more clearly the association is formed, the more truthful the result will be.
The base picture of our test looks like this.
And now we will find out the results and check who is tuned to a positive and creative beginning, and who needs to get rid of negative energy.
Note: if the picture caused you difficulties, if you did not see anything, this confusion may indicate a situation of choice in which you are directly or indirectly placed at the moment. Discomfort and irritation when trying to put blots into something meaningful can also indicate pent-up negative emotions.
Flower. This association depends on the color spot. If you see it in warm pink or orange shades, your energy is even, and you don’t have to worry that negativity has crept into your consciousness. And if the contour of the flower is made up of bluish spots, their cold shade may indicate subconscious anxiety.
Violin. Or another musical instrument. This image indicates creativity, but at the same time it can be a symbol of anxiety. On the whole, despite the latter circumstance, this result speaks of the positive direction of your energy, since creativity is not alien to you and you took an orientation towards warm orange: it turned out to be the dominant in your visual perception.
Human's figure. More often female, view from the back, but other interpretations are possible. The figures of people in the drawings speak of openness to others. You do not seem like a closed person, even if you are an introvert. The obstacles of the past are not terrible for you, and the idea of \u200b\u200bthe beautiful is not alien to you either.
Crab. Crab, crayfish, or other arthropod (perhaps even a spider or octopus). This association is difficult to attribute to pleasant, but do not rush to draw conclusions. Listen to yourself. If a pinkish, crab-like spot makes you think of a crab somewhere on the azure coast, most likely you have a rich imagination, but this association does not mean anything alarming. But if the feelings that are caused in you by such a resemblance are negative (you are afraid of claws, you are uncomfortable with the mandibles that your imagination has already drawn for you) - it's time to think and tune in to a positive wave.
heads. Heads of wild animals, gargoyles, a bull's head are all rather menacing symbols. Masks fall into this category. Such a division into parts can be caused by internal discord.
Internal organs. If you see pelvic bones in color spots or the picture causes other unpleasant anatomical associations, this may indicate hidden sexual problems or individual fears. It is best to fight them face to face. Do not rush to be upset if you saw exactly this in our test from the picture. Positive attitudes can change consciousness for the better.
Of course, we are all different, and it is likely that you saw something of your own, special and unique in these abstractions. In this case, you are probably gifted with out-of-the-box thinking, and your creativity should be protected and developed, because there are situations in which you can not do without a creative approach.
We wish you good luck in knowing your personality and inner self. Look in and do not forget to press the buttons and
12.10.2016 03:32
Everyone knows that the events that happen to us are largely due to our thoughts. And even if...
· Smoke testing. At this stage, it is necessary to check whether the system works at all (does it work correctly, does it handle errors correctly, etc.). This is done in order to understand whether the application is suitable for further testing, or if it does not initially work correctly.
"Positive" testing. At this stage, you need to check the result of the application when it receives the "correct" input data.
"Negative" testing. This is the final stage of initial testing. It is necessary to look at how the application behaves, giving "incorrect" data to the input. If such a variant is described in the specification (and it should be described), then it is necessary to compare the expected result with the received one.
At the stage of studying the specification, it is determined when and how the application itself should work, when and how it should respond to errors, i.e. how the system or its modules should respond to incorrect data or incorrect user behavior
The documentation makes it possible to understand for yourself the main stages of checking an application: where and how the application should work correctly, how to work out error situations: issue error messages, write an error to the work log file, stop execution, etc.
1) check how the application works when it receives valid input;
2) if everything works correctly, as described in the specification, the next step is to check the boundary values (minimum and maximum values \u200b\u200bof correct data);
3) check the operation of the application when entering data that is not in the range of valid values (checking the processing of incorrect input values).
The first two paragraphs describe a process called "positive" testing.
« positive» testing- this is testing on data or scenarios that correspond to the normal (regular, expected) behavior of the system under test. The main purpose of "positive" testing is to check whether the system can do what it was created for.
« negative» testing- this is testing on data or scenarios that correspond to the abnormal behavior of the system under test, as well as the issuance of various error messages, exceptions, "beyond" states, etc.
The main goal of "negative" testing is to check the system's resistance to the effects of a "negative" kind: checking the wrong data set, checking the processing of exceptional situations (both in the implementation of the software algorithms themselves and in the logic of business rules), etc.
“Positive” and “negative” testing should be preceded by work on the implementation of “ flue» testing, during which fast, shallow testing of the most critical functionality is carried out on simple, i.e. typical, scenarios with a minimum of checks (“so that there is no smoke”). Can be performed on both "positive" and "negative" data
Define functional, load, stress and stability testing.
Functional testing is to test the system in order to verify the feasibility of functional requirements, i.e. the ability of the program in certain conditions to solve the tasks needed by users. Functional requirements define what the program does and what tasks it solves.
Stress Testing. In general, the expected use of the application is modeled by emulating the work of several users at the same time. Such testing is most suitable for multi-user systems, and especially those using a client-server architecture (for example, Web servers).
stress testing- a type of software testing that evaluates the reliability and stability of the system in conditions of exceeding the limits of normal operation. Stress testing is especially necessary for "critical" software. Stress testing is usually better at detecting qualities such as robustness, availability, and the ability to handle exceptions by a system under heavy load than what is considered a sign of correct behavior under normal conditions.
Stability testing. This type of testing consists in checking the performance of the program during long-term operation with the expected level of load. Before starting to check the operation of the system at maximum and critical loads, it is necessary to check its operation under the conditions that are laid down in the functional requirements, i.e. run the system in normal mode for a long time. The main task of this testing is to detect memory leaks, as well as to verify that the processing speed and response time of the application were the same at the beginning and end of the test.
Questions for topic 18
In my training courses for beginner testers, I invite them to write positive and negative tests for:
- The function of calculating the root in the calculator.
- Working with the basket (adding / deleting / editing) in the online store.
And here's what I noticed - everything is fine with positive testing, the guys come up with different types of tests (because the task is to name a few, and not list everything, everything, everything, therefore, even if I work in a team, I don’t have to repeat myself). But with the negative, many have problems, they ask for clarification, because "nothing other than entering characters into the numerical value of the number of goods in the basket and calculating the root of a negative number comes to mind."
So I decided to write an explanatory article.
positive testing
A tester is a person who provides the team with information about a product. So we decided to make the same online store, thought over the concept, wrote the code, and now the task of testing is to tell if everything works the way we need.
And of course, positive tests are of great importance. If a user visits our site and cannot put the goods in the cart, then he will not give a damn that when entering any special characters or sql injections, we write beautiful error messages.
Therefore, when we are given something to test, we can happily rush to break new molds, but need check the correct scripts first. First we satisfy loyal and competent users, and then we do the rest.
Thus, positive testing is aimed at making sure that the main functionality works. All scenarios for using our system are feasible and lead to the expected result, not errors.
Let's look at an example:
The main test case is to check that the root of the correct number is actually calculated.
It can be divided into the following equivalence classes:
- After calculating the root, an integer remains (root of 4 = 2)
- After calculating the root, a fractional number remains (the root of 3)
Hmm, what if we have a fractional number not only after root calculation, but also before ? Can we take the root of the number 2.2? Positive test? Positive!
You can also divide the numbers into small ones, up to 100, for example. Then take the interval from 100 to the size of int and the third one will be even larger, as much as our calculator fits into. 3 equivalence classes, we check one value from the interval.
Let's not forget about the boundary values, let's check 0. Positive test? But how! The root of 0 is 0, not an error!
From the main, perhaps, everything.
Oh, that's where the scope for imagination!
The user can execute so many different scenarios!! But first of all, let's take the main, the shortest. Because if they don’t work, then long chains (added - edited - deleted - added again - etc.) are definitely not worth checking. So:
Do you think it will work if it works separately? Nooo, guys, you are testers! Never take programs "at their word"! Did you come up with a script? Check it out!
Moreover, such a scenario may well fall, we have already removed this product from the basket, right? So the system may well prevent us from adding it again. Like "you already refused, ale, I remember everything!". Is this behavior correct? Not!
Is the scenario itself positive? Yes! Although already with notes of perversion, it must be admitted
Negative Testing
It must be remembered that negative testing is no less important than positive testing. Because our users are people, not robots. And people tend to make mistakes. And you should always remember about this human factor.
If I come to the site, place an order and everything is fine - I will come there again. But if I come, place an order and accidentally make a mistake somewhere, for example, I paste the message copied in ICQ instead of a number, then I want to see a tactful remark, and not a crash of the entire system.
In general, in our time, there is usually a large selection of sites to solve a user's problem (for example, you need to buy something). After looking at them and realizing that the functionality he needs is everywhere, the user will choose the most beautiful and convenient site.
But, no matter how convenient such a site is, if it is not able to work under the influence of the human factor, the user will leave sooner or later. "Step to the left, step to the right - execution", who will like it? I would like to be able to make mistakes and correct errors, and not get "hands" with terrible error messages on the whole screen.
That's why we do negative testing. What is negative testing? This is obviously incorrect data entry. We enter and see how the program behaves, whether it gives clear error messages ...
But how do you write such tests? Let's look at examples:
1. The function of calculating the root in the calculator.
The first thing that comes to mind is what happens if you calculate the root of a negative number?
But what else can you think of?
- The root of the void - remember about the boundary values, we cannot enter a string of negative length, but here is the boundary value (string of zero length) we can!
- The root of the characters - you need to check what the system will say if you enter or copy-paste something symbolic there. Moreover, we divide the characters into Russian, English and special characters!
- The root of the meaning is "four" - also symbols can be divided into abracadabra and "number type". By the way, if we talk about such "type numbers" ...
- Let's try to enter a string that represents a number. And take the root of it already.
See? In fact, there are not so few tests! Separately, I would like to express on the topic "enter a very large number, as large as possible." You can try, why not? But this will have a more negative effect on the squaring scenario than on the calculation of the root.
At the root, you can not enter the largest possible number, but enter such a number that the root of it (fractional value) turns out to be very long and does not fit on the screen, what will happen then, will it be cut off or broken?
2. Working with a shopping cart in an online store.
Here, again, you can find a number field and play with it, as we just did with the calculator. The field "quantity of goods" is very suitable here! But, on the other hand, is it boring, such different applications and the same tests?
Remember just 2 words - different tabs !
Do you feel? Let's explain. A negative test to remove an item from the cart is to try to remove an item that has already been removed. And here the options for how this can be done begin:
- Opened the shopping cart in 2 browser tabs. First they clicked "delete" in one, then in the second. That is, an attempt to delete what you yourself have already deleted from your own basket.
- Attempt to delete a product deleted by the admin. In 1 tab, under the admin, we delete the product in general, in principle, and in the other we try to remove it from the basket under the user.
And by the way, you can also try to add a product removed by the admin or edit its quantity. And the admin may not delete the product, but transfer it to another category. And here nothing should break! If, in case of deletion, we should see the correct error message, then in case of transfer, we simply continue to work.
And what will happen if the admin did not move the product in the store hierarchy (he moved it to another category, the product was initially placed incorrectly), but simply corrected, edited the description? Nothing should break either!
And even if we don’t have a store, but something else, always think about how you can try to apply the technique of different tabs.
For example, we can create a card - a person, a building, the same book, something else... Try to edit it in 2 windows. In one, change one field, save, and then change the other field in the second and also save. Or delete something, and add or change it in the second window.
Always try to play with such things, it often ends badly for the program. And even if the team decides not to fix such defects as not critical yet, it doesn’t matter. We care about them know ! Provide information, and then decide what to do with it...
I would like to give another example from real practice. Also a web-interface, where you can click "create" and add a new card. The user adds, and at it through time the form falls. Why?
They began to find out. And they understood. The user had to start a lot of cards at once (migration), so he clicked on "create" several times while holding Ctrl (open in a new tab). And then I went through the tabs and created.
Here it would seem, where is the negative testing? After all, the user does not make conflicting changes by changing the same card. No, he creates new ones, that is, he brings information into various cards. But here's how, the system considered the open "new card" window to be one thing, loudly indignant at the arrogant attempts of the user to shove one piece of information there, then another.
So guys, keep it up! Open different tabs and go ahead, look for information about how, well, how your program behaves with conflicting influences on it?
PS - this is an excerpt from my book for beginner testers, written to help students of my school for testers
Come join us for a bite! ツ
