admin | Testing Brain

Software Exploratory Testing ( ET ) Tutorial

What is Exploratory Testing

This testing is similar to the ad-hoc testing and is done in order to learn/explore the application. It si shortly known as ET.

Exploratory software testing is a powerful and fun approach to testing. View the pdf tutorials about Exploratory Testing. In some situations, it can be orders of magnitude more productive than scripted testing. At least unconsciously, testers perform exploratory testing at one time or another. Yet it doesn’t get much respect in our field. It can be considered as “Scientific Thinking” at real time.

Exploratory testing is the act of exploring, making discoveries about the software, whether it works or not, the type of job it does and what it doesn’t do. The tester keeps making a new decision based on what are discovered during the course of the test. This is normally thought of as a black box testing technique.

What is exploratory testing?

Exploratory testing was first defined in 1984 by Cem Kaner, as “a style of software testing that emphasizes the personal freedom and responsibility of the individual tester to continually optimize the quality of his/her work by treating test-related learning, test design, test execution, and test result interpretation as mutually supportive activities that run in parallel throughout the project.”

Advantages of exploratory testing

Exploratory testing comes with some advantages which are highlighted below.

Testers can guide their future testing by making use of deductive reasoning derived from previous results. It is not mandatory that a current series of scripted tests must be completed before advancing to explore a rich environment that is more targeted. When intelligently used, this can help to speed up the process of detecting more bugs.
Another advantage is that it requires less preparation, it is easy to discover important bugs, and the approach has the tendency to be more intellectually stimulating than scripted tests execution at the time of execution.
One other advantage is that most bugs are detected by exploratory testing after the initial testing has been done. It simply helps to detect bugs that escaped being seen during the initial testing.
Exploratory testing is useful in that, when a bug is discovered, it can be used to explore the size, variations, and scope of the bug in order to supply adequate feedback to the developers.
Exploratory testing is useful in dynamic product environment when the product is at its early stage of development, undergoing changes, or the product is unstable. This is particularly made possible because exploratory testing approach needs less documentation or no documentation at all before testing activities are commenced.
It provides simultaneous learning. While automated tests assist in executing checks/tests swiftly, humans are able to learn from the tests conducted and come up with different test scenarios.

Disadvantages of Exploratory Testing

Exploratory testing is not without one or two disadvantages. Here are a few of the disadvantages to take note of.

It is impossible to review in advance tests invented and performed on the fly, and it is also hard to give an idea about the exact tests that have been run.
When revisited, freestyle exploratory test ideas are not likely to be performed in exactly the same way, making it a disadvantage if it is important that the specific details of the earlier tests are to be repeated.

Conclusion

The importance of exploratory testing cannot be overemphasized. Exploratory testing requires testers with an analytical mindset, who are able to know what to test for and how to analyze the results, even though the tests are carried out by automated software.

PDF Tutorials

Pages: 123

Ad Hoc Tetsing in Software Development

What is Ad Hoc Testing

This type of testing is done without any formal Test Plan or Test Case creation. Ad-hoc testing helps in deciding the scope and duration of the various other testing and it also helps testers in learning the application prior starting with any other testing. It is the least formal method of testing. View pdf tutorials about Ad-hoc testing after reading all these details.

One of the best uses of ad hoc testing is for discovery. Reading the requirements or specifications (if they exist) rarely gives you a good sense of how a program actually behaves. Even the user documentation may not capture the “look and feel” of a program. Ad hoc testing can find holes in your test strategy, and can expose relationships between subsystems that would otherwise not be apparent. In this way, it serves as a tool for checking the completeness of your testing. Missing cases can be found and added to your testing arsenal. Finding new tests in this way can also be a sign that you should perform root cause analysis.

Ask yourself or your test team, “What other tests of this class should we be running?” Defects found while doing ad hoc testing are often examples of entire classes of forgotten test cases. Another use for ad hoc testing is to determine the priorities for your other testing activities. In our example program, Panorama may allow the user to sort photographs that are being displayed. If ad hoc testing shows this to work well, the formal testing of this feature might be deferred until the problematic areas are completed. On the other hand, if ad hoc testing of this sorting photograph feature uncovers problems, then the formal testing might receive a higher priority.

PDF Tutorials

Pages: 1234

Software Load Testing Tutorial, Importance

What is Load Testing

The application is tested against heavy loads or inputs such as testing of web sites in order to find out at what point the web-site/application fails or at what point its performance degrades. Load testing operates at a predefined load level, usually the highest load that the system can accept while still functioning properly. View the Load testing tutorials in pdf

Note that load testing does not aim to break the system by overwhelming it, but instead tries to keep the system constantly humming like a well-oiled machine.In the context of load testing, extreme importance should be given of having large data sets available for testing. Bugs simply do not surface unless you deal with very large entities such thousands of users in repositories such as LDAP/NIS/Active Directory; thousands of mail server mailboxes, multi-gigabyte tables in databases, deep file/directory hierarchies on file systems, etc. Testers obviously need automated tools to generate these large data sets, but fortunately any good scripting language worth its salt will do the job.

PDF Tutorials

Pages: 1234

Software Stress Testing Guide

What is Stress Testing

The application is tested against heavy load such as complex numerical values, large number of inputs, large number of queries etc. which checks for the stress/load the applications can withstand. Stress testing deals with the quality of the application in the environment. Read the stress testing tutorials in pdf with examples after this basic introduction.

The idea is to create an environment more demanding of the application than the application would experience under normal work loads. This is the hardest and most complex category of testing to accomplish and it requires a joint effort from all teams. A test environment is established with many testing stations. At each station, a script is exercising the system. These scripts are usually based on the regression suite. More and more stations are added, all simultaneous hammering on the system, until the system breaks. The system is repaired and the stress test is repeated until a level of stress is reached that is higher than expected to be present at a customer site.

Race conditions and memory leaks are often found under stress testing. A race condition is a conflict between at least two tests. Each test works correctly when done in isolation. When the two tests are run in parallel, one or both of the tests fail. This is usually due to an incorrectly managed lock. A memory leak happens when a test leaves allocated memory behind and does not correctly return the memory to the memory allocation scheme. The test seems to run correctly, but after being exercised several times, available memory is reduced until the system fails.

PDF Reference tutorials with example

Stress-Testing General Purpose Digital Library Software

Pages: 12

Software Functional Testing Guides

What is Functional Testing

In this type of testing, the software is tested for the functional requirements. The tests are written in order to check if the application behaves as expected. Although functional testing is often done toward the end of the development cycle, it can—and should, —be started much earlier. Refer the Pdf tutorials about Functional testing also after reading this introduction. Individual components and processes can be tested early on, even before it’s possible to do functional testing on the entire system.

Functional testing covers how well the system executes the functions it is supposed to execute, including user commands, data manipulation, searches and business processes, user screens, and integrations. Functional testing covers the obvious surface type of functions, as well as the back-end operations (such as security and how upgrades affect the system).

PDF Tutorials

Automating Functional Tests Using Selenium – pdf guide

Pages: 12

Black Box Testing tutorial

What is Black Box Testing | Advantages | Disadvantages | Black box testing techniques

What is Black Box Testing

Black Box Testing is testing without knowledge of the internal workings of the item being tested. For example, when black box testing is applied to software engineering, the tester would only know the “legal” inputs and what the expected outputs should be, but not how the program actually arrives at those outputs.

It is because of this that black box testing can be considered testing with respect to the specifications, no other knowledge of the program is necessary. For this reason, the tester and the programmer can be independent of one another, avoiding programmer bias toward his own work. For this testing, test groups are often used, “Test groups are sometimes called professional idiots…people who are good at designing incorrect data.” 1 Also, do to the nature of black box testing, the test planning can begin as soon as the specifications are written. The opposite of this would be glass box testing, where test data are derived from direct examination of the code to be tested. For glass box testing, the test cases cannot be determined until the code has actually been written. Both of these testing techniques have advantages and disadvantages, but when combined, they help to ensure thorough testing of the product.
Synonyms for black-box include: behavioral, functional, opaque-box, and closed-box.

Advantages of Black Box Testing

more effective on larger units of code than glass box testing
tester needs no knowledge of implementation, including specific programming languages
tester and programmer are independent of each other
tests are done from a user’s point of view
will help to expose any ambiguities or inconsistencies in the specifications
test cases can be designed as soon as the specifications are complete

Disadvantages of Black Box Testing

only a small number of possible inputs can actually be tested, to test every possible input stream would take nearly forever
without clear and concise specifications, test cases are hard to design
there may be unnecessary repetition of test inputs if the tester is not informed of test cases the programmer has already tried
may leave many program paths untested
cannot be directed toward specific segments of code which may be very complex (and therefore more error prone)
most testing related research has been directed toward glass box testing

Testing Strategies/Techniques

black box testing should make use of randomly generated inputs (only a test range should be specified by the tester), to eliminate any guess work by the tester as to the methods of the function
data outside of the specified input range should be tested to check the robustness of the program
boundary cases should be tested (top and bottom of specified range) to make sure the highest and lowest allowable inputs produce proper output
the number zero should be tested when numerical data is to be input
stress testing should be performed (try to overload the program with inputs to see where it reaches its maximum capacity), especially with real time systems
crash testing should be performed to see what it takes to bring the system down
test monitoring tools should be used whenever possible to track which tests have already been performed and the outputs of these tests to avoid repetition and to aid in the software maintenance
other functional testing techniques include: transaction testing, syntax testing, domain testing, logic testing, and state testing.
finite state machine models can be used as a guide to design functional tests
According to Beizer 2 the following is a general order by which tests should be designed:
1. Clean tests against requirements.
2. Additional structural tests for branch coverage, as needed.
3. Additional tests for data-flow coverage as needed.
4. Domain tests not covered by the above.
5. Special techniques as appropriate–syntax, loop, state, etc.
6. Any dirty tests not covered by the above.

Levels Of Black Box Testing

Split a string and store into an array

This PHP script code is for split a string into the specified length and store it into an array. Here we are using a form to enter the string to split , length at which split process and the cut mode . In normal cut modes split wont happen in the middle of a single word , in strict mode split will happen strictly even in the middle of a single word.

<html>
<head>
</head>
<body>
<form name="split" action="" method="post">
Enter the string to Split
<input type="text" name="text1" /><br />
Enter the character length to split:<input type="text" name="len1" /><br />
Cut Mode;<select name="cut">
<option value=0 t>Normal Cut</option>
<option value=1>Strict Cut</option>
</select><br>
<input type="submit" value="split" name="btnsubmit" />

</form>
<?php
if(isset($_POST['btnsubmit']))
{
$text=$_POST['text1'];
$len1=$_POST['len1'];
$mode=$_POST['cut'];
//echo "Original String ".$text;
//$count= strlen($text);
$newtext = wordwrap($text, $len1, "<***>",$mode);
$result=explode('<***>', $newtext);
$count= count($result);
$i=0;
while ($i<$count)
{
echo "String ".$i." is : <b>".$result[$i]."</b><br>";
$i=$i+1;
}
}
?>
</body>
</html>

PHP wordwrap function

PHP wordwrap() function is used for wrapping a string to a given number of characters. It will cut the string at the specified length and insert the string or character we have entered at that position.

Its Syntax will be :
wordwrap ( string , length , break character , cut mode );

First parameter will be the string to be wrapped
Second parameter specifies at which length wrap should occur.
Third parameter specified the character or string to be inserted at the specified length.
Fourth parameter is optional. This cut mode parameter specified the mode of cutting. When we specify this parameter as TRUE , cutting will occur at the middle of words too , it will strictly cut at the specified length. By default its value will be false , and cutting wont happen in the middle of a word.

You will get more clear picture about this wordwrap function after seeing the following sample PHP programs and its output

<?php
$text="This tutorial will show about wordwrap function";
echo wordwrap($text,5," * ")
?>

Its output will be :

This * tutorial * will * show * about * wordwrap * function

Here we can see that single words are not splitted , they remains the same.

Now look at the next program with CUT mode parameter as TRUE

<?php
$text="This tutorial will show about wordwrap function";
echo wordwrap($text,5," * ", TRUE)
?>
Its output will be :

This * tutor * ial * will * show * about * wordw * rap * funct * ion

Here we can see that function has splitted the string strictly at the specified length and single words also splitted .

A Prime Number list generation PHP script

A prime number is defined as a number which can be only divisible by 1 and that number itself. That number cannot be divisible by any other number. So if we try to divide that number by any other number between one and that number , we will get a remainder. According to the prime number definition number one ( 1 ) wont consider as a primer number. The smallest primer number is 2 .

See is a list of primer number below 50
2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47,

Here is a sample PHP script program to create a list of prime numbers
In this example we are going to print first 20 prime numbers.

<?php
$count = 0 ;
$number = 2 ;
while ($count < 20 )
{
$div_count=0;
for ( $i=1;$i<=$number;$i++)
{
if (($number%$i)==0)
{
$div_count++;
}
}
if ($div_count<3)
{
echo $number." , ";
$count=$count+1;
}
$number=$number+1;
}
?>

Its output will be :

2 , 3 , 5 , 7 , 11 , 13 , 17 , 19 , 23 , 29 , 31 , 37 , 41 , 43 , 47 , 53 , 59 , 61 , 67 , 71 ,

Logic of this program : We need first store the current number to a variable. And then we will find the remainder for each division of other numbers with the stored number using a loop. And we will increment a counter if remainder found zero. After all the division operations with other numbers we will check the total counter for the remainder. If its value greater than two means , that number can be divisible by some other number instead of 1 and that number itself.If its value less than three means , its a primer number.

Now look at another PHP script for generating a list of prime numbers below 100.

<?php
$number = 2 ;
while ($number < 100 )
{
$div_count=0;
for ( $i=1;$i<=$number;$i++)
{
if (($number%$i)==0)
{
$div_count++;
}
}
if ($div_count<3)
{
echo $number." , ";
}
$number=$number+1;
}
?>

Its output will be ;

2 , 3 , 5 , 7 , 11 , 13 , 17 , 19 , 23 , 29 , 31 , 37 , 41 , 43 , 47 , 53 , 59 , 61 , 67 , 71 , 73 , 79 , 83 , 89 , 97 ,

This not only the one method of logic to create Primer number series .. You can create the list other methods and loops in PHP.

PHP Fibonacci Series printing

A Fibonacci Series of numbers will look like
0 , 1 , 1 , 2 , 3 , 5 , 8 , 13 , 21 , 34 , 55

First two Fibonacci numbers are 0 and 1 . After that each number will be the sum of previous two numbers . Here we can see that third Fibonacci number is 1 ( sum of first two numbers 0 + 1 ) , and fourth Fibonacci number will be the sum of third and second number ( 1 + 1 = 2 ) , and fifth Fibonacci number will be the sum of fourth and third number ( 2 + 1 = 3 ). The series will go like that infinity .

Now we can learn how to make a Fibonacci series using PHP .
Here is the PHP script for printing first 20 Fibonacci numbers .

<?php
$count = 0 ;
$f1 = 0;
$f2 = 1;
echo $f1." , ";
echo $f2." , ";
while ($count < 20 )
{
$f3 = $f2 + $f1 ;
echo $f3." , ";
$f1 = $f2 ;
$f2 = $f3 ;
$count = $count + 1;
}
?>

Its output will be :

0 , 1 , 1 , 2 , 3 , 5 , 8 , 13 , 21 , 34 , 55 , 89 , 144 , 233 , 377 , 610 , 987 , 1597 , 2584 , 4181 , 6765 , 10946 ,

In this example I have created the series using a while loop .Like this we can make Fibonacci Series using for loops also in PHP .