Category Archives: Software Testing

Virtual testing – next software development step

The conversation on virtualisation to date has centred on infrastructure – servers, desktops, networks. That conversation is now heading into the application layer, and specifically – application testing, a critical part of any software development project.

Back in the development dark ages (about 15 years ago), thought leaders in the field realised the waterfall approach to software development was not necessarily the best, or most efficient. Waterfall development happened sequentially – requirement, specification, design, code, test. This meant that any major flaws in the project’s specification, design or code were only discovered at the end of the project – often way too late to be remedied or mitigated.

The waterfall approach consequently gave way to agile development methodologies, whereby software is developed in small chunks, says IndigoCube MD Ziaan Hattingh. The ‘specify, design, code’ sequence is repeated multiple times over the course of a project, and developers test early, and often.

Or so best practice dictates. “Then,” says Hattingh, “something else happened that made it difficult to test early – the move to as a service computing. Today, developers are building systems of systems, and these systems consume services from other service providers and pull it all together into one offering. This is difficult to test because, for example, if you’re developing a payment system that links to SWIFT, or Mastercard, you need access to that service to test the system.”

These systems of systems are so complex to test, Hattingh notes, that people tend to leave it until last. “This means they often find big, dangerous flaws only at the end of the development project, when they are very expensive to fix.”

Until virtualisation technology took that one necessary step forward and made virtual testing possible, that is. Says Hattingh: “A virtual testing environment enables you to create virtual services – so you can develop your software, then plug it into virtual services (like a mock Mastercard system) to test as you go. This virtual system responds appropriately so that you can test the solution often and early and fix problems as you go.”

While virtual systems are not real, they are realistic. And they offer another big benefit – cost-savings.

“Creating a test environment is expensive,” Hattingh comments. “You need a laboratory environment, software licences for test software, hardware and so on. And if you are developing multiple features or services, you need multiple test environments for each function. Virtual testing environments are substantially more cost-effective and allow you to do performance testing early on. Your networks, servers, databases, database types all affect performance and come together to provide your performance profile. This is also usually left until last, because that is when all these elements are finally brought together,” Hattingh comments.

“Now you can test your software’s performance early, as software functions become ready so that when you get to the end, performance, functionality, integration, all have been tested,” he says. “You will probably still do final testing on the full environment, but you won’t be in for any big, costly surprises.”

Source: http://www.itweb.co.za/index.php?option=com_content&view=article&id=63720:Virtual-testing-next-software-development-step&catid=279

Did you like this? Share it:

Wie Sie die Vorteile der exploratory Tests erhöhen

Wenn die Software zur Entwicklung der neuen und besseren Tests getestet wird, nannt man diese durchgeführten Tests die exploratory Tests. Es ist ein interaktiver Test-Prozess, wo der Tester  durch Erforschung testet. Danach folgen einige Tipps, um die Vorteile der exploratory Tests erhöhen.

+ Informieren sie sich gut. Die exploratory Tests werden meistens von professionalen Angestellten durchgeführt. Ein gut qualifizierter exploratory Tester ist in der Lage, Fehler nur durch das Lauf der Software zu finden und die kreative Testfälle zu schreiben, um die Qualtität der Bugs zu verbessern.

+ Strategie. Weil die Ausgabe vom Budge in der Vorarbeit immer niedriger ist, ist es wichtig, die qualifizierten und am besten geeigneten exploratory Tester anzustellen. Solche Angestellen müssen auch viele berufliche Erfahrungen haben.

+ Die vergangenen Daten über das Produkt zu nutzen. Es wäre sehr hilfreich, wenn Sie Informationen über das Produkt auf den vergangenen Versionen sammeln.

+ Das Testsergebnis zu erstellen. Stellen Sie sicher, dass das Testsergebnis überprüfbar und vertretbarf ür die Zertifizierung sind, weil die exploratory Tester erforderlich sind, zu erklären und zu veranschaulichen. All dies führt dazu, dass die Produkte nach den Aufforderungen der Kunden entwickelt werden.

Drittanbieter für das Software-Test entstanden seit langer Zeit in China und leisteten großen Beitrag zur Software-Entwicklung in China. Sie können sich auf diese chinesischen Tester von diesen Software-Test-Unternehmen verlassen. Sie sind erfahren und können Ihren Erwartungen erfüllen. Auch sind explorative Tester in China sehr gewidmet. Sie kennen die Bedeutung der Kommunikation. Deshalb können Sie sicherstellen, dass jeder Ihrer Meinungen ernst betrachtet wird.

Unitesting als ein Test Outsourcing-Anbieter in China bietet Ihnen eine breite Palette für Software testing-Services. Unser Ziel ist, die Erfreudlichkeit und Zufriedenheit der Kunden zu gewinnen.

Did you like this? Share it:

Is it time to revamp your software testing strategies?

Under the cloud of sequestration, IT contractors face the challenge of delivering large, highly complex software systems for the government and its agencies with increasingly limited resources. We are expected to maintain the same high standards while budgets tighten. The mission-critical nature of government software systems—including those for the Department of Defense—leaves no room for error.

To keep up with the demands inherent in building systems of this size and complexity, we must find ways to streamline processes. One area ripe for re-evaluation is software testing, which now consumes more than 50 percent of the resources—in both cost and time—of most development schedules.

The traditional testing of complex systems is labor intensive, time consuming and limited. Project teams must test thoroughly to ensure software quality. Engineers who are needed to focus on design and development are preoccupied with repetitive test tasks and analysis.

Increasing the size of test teams to match the rate at which software applications are growing is cost prohibitive. Maintaining current test team size and continuing the same processes will erode the amount of testing actually conducted, decreasing overall test coverage and compromising quality.

New technologies in the form of automated software testing (AST) are available and must be embraced. AST is a technology that dramatically accelerates test execution and reporting time while expanding test coverage and test complexity. Recent advances in AST enable the automation of a very high percentage of the testing that needs to be conducted.

Imagine trying to be competitive in today’s marketplace if you were writing all of your software in assembly code, defining every command and compiling it yourself, while other firms were developing their software in an integrated development environment using software design tools and programming in JAVA. Using modern tools, today’s software engineers are able to focus on what the software is supposed to do, and are, by and large, abstracted from the details of software commands.

Testing manually today is like writing software at the assembly code level. Test engineers need to define and execute every step and command. It is a tedious process. A well thought out AST solution provides an alternative, allowing test engineers the opportunity to focus on designing tests and evaluating the results.

The strategic use of AST offers the following advantages:

+ Improved software quality: Repeatable, consistent and thorough automated tests support the delivery of high quality software.

+ Improved documentation: Automated tests readily produce documented, objective, quality evidence, including requirements traceability and comprehensive pass/fail results.

+ Reduced testing time and manpower: Automated tests run significantly faster than manual tests, are less labor-intensive, and provide the capability to verify thousands to millions of test permutations in minutes to hours.

+ Cost savings: AST can markedly reduce the costs involved in producing first-rate software. Savings result from not only reduced test time and manpower but also from lower lifecycle costs as a result of improved software quality and documentation.

Given the significant time and effort required to conduct software testing today, organizations that effectively utilize AST will increase their competiveness in the marketplace. In my experience, firms that implement a well-defined automated software testing strategy can increase their testing productivity by an average of 75 percent.

As the ever-increasing size and complexity of software systems drive the time and cost of testing, we need to think outside the box. It is time to incorporate AST and embrace this empowering technology.

Source: http://washingtontechnology.com/Articles/2013/05/09/Insights-Gauf-software-testing.aspx?Page=1

Did you like this? Share it:

How to Change Software Testing for New Cloud Configurations

Development and operations (DevOps) tools such as Puppet and Chef automate changes to configurations in systems. Some teams use these tools, and other frameworks, to actually automate the creation of the entire production Web server environment—sometimes in public services such as Amazon Web Services, sometimes in a local environment.

The problem with automating the rollouts is that code has bugs. A configuration change meant for QA—say, to direct users to a test environment—could be propagated to production, leaving users logged into an environment that looks real but will never actually ship products. (Don’t laugh too hard: Last month this happened to one of my clients, a multibillion-dollar retail operation moving to customer self-service.)

The good news is that, as new risks emerge, so, too, are new techniques to manage those risks. Here are a few things to think about in any cloud transition.

Amazon’s Elastic Compute Cloud has occasional, unpredictable outages. Even without Amazon, if a company uses Chef or Puppet to automate system administration, those tools use code, and that code could have defects.

Here are a few possible problems with a cloud implementation:

+ A feature is created in production but disabled by a configuration flag. A programmer turns on the GUI, but the behavior remains "off."

+ A private cloud manager designed to roll out new servers over time has a defect in the "reaper" process that turns off old instances.

+ Mistakes in the merge process can put test configurations such as databases, server names and URLs into production.

+ API issues, especially a third-party API that changes after the code "passes" the test environment.

All these problems could appear first in production. In fact, they’re likely to first appear in production, with no visible signs in the test environment. A week of phone calls, interviews and a trip to San Diego to discuss this in person at the Software Test Professionals Conference have led me to conclude that there are no easy answers.

A traditional test approach won’t find these problems. Instead, the people I interviewed recommended two things: Either change the architecture to reduce risk or monitor, test and (quickly) fix issues in production.

Source: http://www.cio.com/article/732864/How_to_Change_Software_Testing_for_New_Cloud_Configurations

Did you like this? Share it:

Bugtracking Systeme

Für ein Software-Entwicklungsprojekt ist ein Bugtracking System erforderlich. Um den Bedarf zu decken steht eine Reihe von Bugtracking Tools zur Verfügung. Im folgenden werden drei Bugtracking-Systeme dargestellt, die sich an Ihren Geschmack und Anforderung anpassen.

Bugzilla. Bugzilla wurde von verschiedenen großen Opensource Projekten verwendet, um ihre Fehler zu verfolgen. Es ist stabil, aktiv gepflegt, weithin angepasst Fehlerdatenbank. Bugzilla ist in Perl geschrieben und arbeitet auf verschiedenen Datenbanken wie MySQL und Oracle.

Mantis. Mantis wird in PHP geschrieben und arbeiten an verschiedenen Datenbanken wie MySQL, MS SQL, PostgreSQL. Die Funktionen von Mantis liegen in Source Codeintegration, Zeiterfassung, Thema Beziehung Graph, anonymen Zugriff, benutzerdefinierte Felder und Workflow, usw..

Jira. Jira ist ein sehr mächtiges Werkzeug und kann als das defekte Tracking System sowie das Planungstool für Agile Projekte verwendet werden. Eines der interessantesten Charakter von Jira ist Configuring Dashboard. Sie können verschiedene Dashboards und auf jeder Dashboards über Jira berichten.

In China erregt das Testing immer mehr Aufmerksamkeit. Tester werden systematisch trainiert. Zahlreiche Institutionen werden in China eingerichtet, um die Tester, einschließlich Videospiel-Tester, zu trainieren. Damit kann ihr Kenntnis vertieft und verbessert werden. Darüber hinaus verfügen die Testing-Unternehmen hier in China über die fortschrittene automatisierte Prüftechnik.

UniTesting als ein weltweit führendes Testing-Unternehmen in China bietet verschiedene testing-Services an, wie zum Beispiel Videospieltesting, Mobile-Anwendungstesting und Testing für die Anwendungen im Gesundheitswesen sowie Web-Application. Unsere Mitglieder sind professionell und engagiert.

Did you like this? Share it:

What Is Software Testing

What is Software Testing? It is processes quantify the quality of software and maintain the quality throughout the life of software. Software Testing is a oriented to “Detection”. It’s examining system or an application under controlled condition. It’s intentionally making things go wrong when they should not and things happen when they should not.

Organizations vary considerably in how they assign responsibility for QA and testing.

Sometimes they’re the combine responsibility of one group or individual. Also common are project teams that include a mix of tester and developers who work closely together, with overall QA processes monitored by project managers. It will depend on what best fits an organizations size and business structure.

Software testing is a process to find out difference between Expected Results and Actual Results.

Expected Results: – We get Expected results from the requirement or it is what the customer needs as his requirement.

Actual Results: – when we execute software the behavior of the software or how it reacts or what it is giving you at the end of an operation is called as actually results.

What’s a Test Case?

A Test Case is documents that describe an input, action, or event and an expected response, to determine if a feature of an application is working correctly. A test case should contain particulars such as test case identifier, test case name, objective, test condition / setup, input data requirements, steps, and expected results.

Note that: – The process of developing test cases can help find problems in the requirements’ or design of an application, since it requires completely thinking through the operation of the application. For this reason, it useful to prepare test cases early in the development cycle if possible.

What should be done after a bug is found?

The bug needs to be communicated and assigned to developers that can fix it. After the problem is resolved, fixes should be retested, and determinations made regarding requirements for regression testing to check that fix didn’t create problem elsewhere. If a problem tracking system is in place, it should encapsulate these processes. A verity of commercial problem – tracking / management software tools are available (see the tools sections for web recourse with listing of such tools.) 

The following are items to consider in the tracking process.

1) Complete information such that developers can understand the bug, get an idea of its severity, and reproduce it if necessary.
2) Bug identifier
3) Current budge status
4) The application name or identifier and version
5) The function, module, feature, object, screen. Etc where the bug occurred.
6) Environment specifies , system , platform, relevant hardware specifies
7) Test case name/ number identifier
8) One line bug description
9) Full bug description
10) Description of steps needed to reproduce the bug if not covered by a test case or if the developers doesn’t have easy access to the test case
11) Name and / or description of file / data / message etc used in test
12) File experts / error message/ log file experts/screen shots/ test tools log that would be helpful in finding the causes of the problem
13) Severity estimate ( a5-level range such as 1 – 5 or critical – to – low is common)
14) Was the bug reproducible?
15) Tester name
16) Test date
17) Bug reporting date
18) Name of developer / group /organization the problem is assigned to
19) Description of problem cause
20) Description of fix
21) Code section / file / module / class method that was fixed
22) Date of fix
23) Application version that contains the fix
24) Tester responsible for retest
25) Reset date
26) Reset results
27) Regression testing requirement
28) Tester responsible for regression tests
29) Regression testing result

Reporting or tracking process show personal at various stages. For instance tester need to know when enable notification of appropriate personal at various stage.  For instance tester need to know when resetting is needed developers need to know when bug are found and how to get the need information and reporting / summary capabilities are needed for managers.

Defects:-

It is any variants between expected result and actually result it is a defects.

Or   Software is not fulfilling the expectation then it is a defects.

Defects are always visible on GUI (Graphical User Interface) to the tester.

Defect-Metrics-Analysis

Error:-

It is human mistake done in coding a simple silly mistake may cause a server defects. It is visible to developer only. Error results defects.

Failure :-

When the software as a whole do not fulfill customer requirement or customer unsatisfactory is called as failure. It is visible to client or end user. Defects lead to failure.

Clients:-

It clients is one who pays you for software development. He may also be the end user.

End User: – He is one who actually uses the software. He may also be a client.

Types of Defects:-

Wrong: – Software is doing what it is not supposed to do. It is not doing what it is supposed to do.

Both the points are specified in requirement.

Missing: – It is not specified to do but it should do accordingly.

Extra: – It is not specified in the requirement and also doesn’t require but doing so.

Source: http://www.technotrice.com/what-is-software-testing/

Did you like this? Share it:

ALM software boosts testing and traceability for embedded product development

2

Testing and traceability play a vital role in embedded product development. Traceability rendered via Application Life-cycle Management (ALM) software enables the team to automatically generate test cases that link back to requirements, and report defects that link back to test cases. By knowing that defects are addressed and test cases run successfully, the team can have an immediate and accurate accounting of the state of product requirements.

Fifteen or 20 years ago, many embedded systems consisted of an 8-bit processor with a few KB of memory and perhaps a couple hundred lines of code. Today, the explosion of embedded systems in automobiles, ATMs, cell phones, and other devices has dramatically changed that dynamic. It’s not uncommon to see multiple 32- and 64-bit multicore[] processors on an Ethernet network, running multiple applications totaling hundreds of thousands of lines of code in these systems.

As these devices grow in complexity, it has become a significant burden for project teams to confirm that software requirements have been tested and tests can be traced back to requirements. In many cases, even with extensive testing, teams might not know whether they have successfully met all of the product requirements.

A high level of complexity and the need for greater system reliability also bring quality to the forefront. Older embedded systems were either simple enough or not important enough to spend time finding, tracking, and fixing software defects. Today, defects in embedded systems can be just as common and even more important than those in enterprise applications. And because of the greater complexity, it becomes more important to be able to trace defects back through test cases and to requirements so that teams have increased transparency into issues and the features they affect.

Today’s complex embedded systems can have hundreds or thousands of requirements, with as many or more test cases. Tracking and executing these test cases, and using that information to make sure requirements have been satisfied, becomes a real concern for teams that have to gain better control over their processes. To address this challenge, teams need an automated way to link artifacts so that data about one artifact becomes information for others. Application Life-cycle Management (ALM) software can help.

The value of traceability

Traceability is the practice of linking requirements to downstream artifacts like risk, test cases, defects, and even source code. Links enable two-way communication of change and progress between related artifacts.

For example, once a product has requirements, those validating it need to write test cases that ensure the product under development is meeting the design requirements. If test cases fail, the resulting defects are recorded in an issue tracking system.

Traceability enables product teams and stakeholders to understand and derive valuable information from the relationship between product development artifacts. By looking at defects, it is possible to determine which requirements haven’t yet been satisfied. Teams can use this information as an important guide to determine whether a product is ready to ship, and also to triage defects to satisfy the most important requirements first.

But effective traceability can do a whole lot more for a project. If safety risks are identified as a part the product, these can be linked to nonfunctional requirements that can then be traced to downstream artifacts. Source code can be traced to defects and back to requirements, closing the loop between design, development, and testing. In the same vein, when defect fixes are checked back in to source control, and tests run to confirm the fixes, the team and other product stakeholders know very clearly that the corresponding requirements have been satisfied.

Traceability also provides essential project information that often can’t be obtained in any other way. It provides testers with an easily understandable and reportable measure of product quality. By knowing which requirements remain unsatisfied, and whether they have issues logged against them, testers can estimate the time remaining to product completion. Last, traceability enables teams to better understand the work remaining, and in which functional areas of the product that work remains.

Managing requirements, test cases, and defects using Microsoft Word or Excel is challenging enough. But tracing requirements through test cases to defects and back to requirements is impossible without a real tracking system.

Building traceability into an embedded project

How does a product team go about building traceability? It starts with requirements. Once functional requirements are defined, risk analysis and mitigation begins, and testers generate test cases that will enable them to determine if the product under development meets those requirements.

As testers run test cases, the cases that pass indicate that the related requirements have been satisfied. If test cases fail, testers record defects that are associated with those test cases and, by linkage, to the requirement under test. The defects are associated with the related test cases and test runs, providing a link back to the testing stage.

Ideally, this linking is done automatically. While it is possible to manually create and maintain links between project artifacts, the work involved is detailed and constant. Whenever a requirement or test case changes, links have to be manually reestablished. The effort needed to manually create and maintain links between requirements, test cases, and defects is excessive, especially if those links have to be examined and updated almost daily.

In most projects, testers execute test cases multiple times, in different test runs. Tests are rerun when an initial run fails, and the fix needs to be verified. Tests are also run additional times for regression purposes, as the embedded software product scope grows to meet more requirements.

Tests may also be performed manually, or in an automated fashion using a testing harness. In practice, most teams do some of both. Manual testing is typically done the first time, and recorded using an automated tool. Subsequent tests are often run automatically, unless the functionality changes significantly. Test results provide the basis for traceability information, through either defects or successful test results. Both can trace back to requirements and other artifacts.

With automated testing and traceability, testing teams have the opportunity to perform at a high level, accomplishing testing within the product schedule and providing valuable information on quality and requirements fulfillment to product stakeholders. This makes testing more relevant to all stakeholders, especially in the latter stages of product development.

Ideally, this starts with requirements, but must also incorporate test management, defect tracking, and source code management. For products with safety implications, it should also incorporate risk management and mitigation. ALM software, such as TestTrack from Seapine Software, offers the ability to create, manage, and link artifacts from the beginning through the end of a design and development project. Figure 1 illustrates how a traceability matrix can help teams easily determine how defects or requirement changes can affect other parts of a project.

Traceability and safety-critical projects

Traceability has traditionally been used for large development projects with hundreds of engineers and testers, and thousands of requirements. This has been primarily the realm of commercial and military aviation and space systems, where the need for information to combat complexity overcame the cost of that information. These systems can take years to develop and bring to market, making the information gained through traceability especially valuable as team members leave and new ones arrive.

But with automation, such as that provided by ALM software, the cost and effort of traceability can be driven down to the point where it makes sense for smaller projects, and with shorter schedules. Automatic traceability between requirements and downstream artifacts, and back upstream from defects to requirements, makes identifying and communicating development hurdles and issues faster and more transparent.

Projects, such as smartphones, automotive systems, and smart industrial control equipment, benefit from better traceability. As more testing teams incorporate automated ALM methods to collect and disseminate traceability information, product quality will continue to improve, even as systems become more complex.

Source: http://embedded-computing.com/articles/application-testing-traceability-embedded-product-development/

Did you like this? Share it:

Don’t Mistake Test Management for Quality

Focus on Software Quality

Test Management systems manage and measure some of the testing activities performed on a project. Completing your testing activities tells me nothing about the overall “Quality” of the product. By definition, it is an incomplete part of the picture.

By putting your faith in Test Management plans or systems you are effectively saying “I don’t know how to measure what you want (i.e. Quality), so I will measure what I can do (i.e. Test).”

Does this mean it’s pointless to track the testing you’ve done? NO! I am not saying that. If you do something that you believe contributes to the value of the project, then please track what you are doing so that others can see what you have done. Preferably, make your progress visible in some way.

What we need to focus on is what the customer needs. Ask yourself: What problem are they trying to solve? What are we trying to deliver that is of value to them? …

So, if you somehow create a super Test Management Plan or system that tracks all of these activities for a given project, then would you have a Quality product? That would be really cool, by the way, but no, not necessarily. And don’t fool yourself into thinking that it will.

Basically, don’t get so bogged down in test management (the process) that you overlook actual quality. Checking boxes on your testing to-do list isn’t the same thing as working to make sure software is actually of high quality – bug free (at least mostly), efficient, effective and achieving its goal.

People seem to periodically remember that quality is the desired result of quality assurance. Between remembering, though, they get bogged down in once good practices and processes. Waterfall development made sense at one point in time – when the SDLC ran on a much more drawn out time frame. But then Waterfall Development became inefficient and too process laden. The answer was Agile development, which allowed teams to move faster and be more flexible. Agile largely did away with the clunkiness of test management and streamlined the process – tying testing more closely to the desired end product and the process of getting there.

Now, each agile team is responsible for its own quality, the tester advocates quality and encourages activities that build quality in such as accurate acceptance criteria, unit testing, automated acceptance testing, story testing and exploratory testing. These activities aren’t managed in a test management tool, but against each user story in a lightweight story management tool (such as Trello or Mingle). The tester is responsible for managing his/her own testing. …

Step by Step test cases (such as those in Quality Center) are no longer needed as each user story has acceptance criteria, and each team writes automated acceptance tests written for functionality they develop which acts as both automated regression tests and living documentation.

But even Agile is beginning to present problems. Teams are getting too caught up in the concept that Agile Development doesn’t have long meetings, demanding master plans or much (if any) documentation. By holding onto these concepts so strongly, teams are forgetting the rationale behind the methodology – it’s supposed to be about make better software faster. Do short meetings, loose planning and no documentation automatically result in better quality? No. A dedication to understanding what users want and a commitment to quality assurance (not just testing) is the path to good quality software. Paul echoes this sentiment in a call to testers:

Testers: if you want to do a great job, focus on the testing activities that explore the systems from the perspectives of the people who matter. Never hide or bury your work (i.e. in documents, spreadsheets, test management systems, etc.). Make it visible – use dashboards, mind maps or other visual mediums because they assist with team collaboration and understanding. Keep detailed records archived somewhere if you need them, but don’t worry about “managing” to those fiddly bits as an indicator of “quality” – because they’re not.

No matter what development methodology you use, part of working toward a quality product is taking testing out of its isolated box. Addressing testing as an independent entity or leaving it until the last minute means you have very few options other than a checklist or traditional test management practices and constraints. Instead, work testing in throughout the planning, development and deployment processes.

Source: http://blog.utest.com/dont-mistake-test-management-for-quality/2013/04/

Did you like this? Share it:

Die Auslagerung der Software-Testing-Services nach China

Traditionell ist das Software-Test eine eigene Funktion oder ein Teil der von Softwareherstellern durchgeführten Gesmtaufgaben. Jedoch ist die Rolle der Tests immer wichtiger geworden, während IT immer wichtiger für Geschäftsentwicklung ist. Auf den ersten Blick ist Outsourcing beliebt, weil es das Problem bei den begrenzten Testressourcen und bei dem Mangel an qualifizierten Softwaretester beherrscht.

Software-Prüfung ist wichtig, aber es ist absolut keine Haupttätigkeit von den meisten anderen Anbietern, die sie benötigen. In diesem Fall kann die Auslagerung von Software-Tests dem Unternehmen helfen, sich auf sein Kerngeschäft zu konzentrieren. Inzwischen kann die Qualität der getesteten Produkte auch sicher sein. Das ist unbedingt eine Zeit und Geld sparende Wahl.

Als einer der beliebtesten Outsourcing-Standorte besitzen die Testing-Hersteller in China solche Fähigkeiten und Erfahrungen, mit denen diese Unternehmen im globalen Geschäft auffällig sind. Chinesische Softwaretester sind geschickt in Aufgabenerfüllung und können immer die Erwartungen der Kunden realisieren. Daher ist das Outsourcing von Software-testing-Services nach China praktisch kosteneffektiv. Mit der Entscheidung für Softwaretest-Outsourcing nach China sinken sich die Kosten für die Durchführung der testen Tätigkeiten stark. Darüber hinaus müssen sich die Kunden um die Einstellung und Ausbildung der Tester nicht kümmern. Deshalb können Sie sich auf das Kerngeschäft konzentrieren. Auf diese Weise verfacht das Outsourcing der Software-Testing-Services nach China Ihre Effizienz.

UniTesting ist eine professionelle und unabhängige Software-Testing-Anbieter und bietet vielfältige Software-QA-Testing-Services in China an, einschließlich Funktionstests, Leistungstests, Sicherheitstests, etc.. Lassen Sie die Software-Testing-Arbeit einfach nach UniTesting auslagern, weil unsere Firma Sie nie Mals enttäuscht.

Did you like this? Share it:

Software testing techniques: Overcoming biases

How did I miss that bug?

No matter what software testing techniques we apply, we have all asked ourselves that question.

Here’s a surprising answer: As software testers, we miss bugs — even those that become glaringly obvious after the fact — because we are hampered by our own biases. Our biases affect what we look for; how we go about designing, setting up and executing tests and how we interpret test results.

These biases can result in poor test performance and incorrect data interpretation. What we measure and what decisions we base on the data are driven by our own understandings and misunderstandings of the project and the goals of testing.

In this this tip, I explore the concept of biases and offer some software testing techniques to help overcome our individual biases.

Princeton University psychologist Daniel Kahneman and the late Amos Tversky, a former Stanford University psychologist, developed the idea of cognitive bias as a pattern of deviation in judgment. Their research demonstrated people’s inability to think critically in complicated situations. To compensate, people tend to use heuristics, or rules of thumb, to make decisions when the subject matter is complicated or when time is limited. This is effective in some situations, but can lead to errors in others. Our biases also lead to preconceived notions about situations, things and people. Our preconceived notions as testers about the application under test, the requirements or the developers affect our testing. Let’s review some biases that especially impact testers.

The representative bias
The term ‘representative bias’ describes what happens when we judge the likelihood of an occurrence in a particular situation by how closely the situation resembles similar situations. Testers may be influenced by this bias when designing data matrices. As a result, they may not test data in all states or not test enough types of data. For example, if the code works for a new customer order as well as an order in process, why bother testing the code to make sure it works with a completed order?

The congruence bias
The congruence bias is at work when testers test only the "happy" path and miss the negative test cases. We fall prey to this bias when we underestimate the time needed for a test cycle. Often, when we test applications on which we are "experts," we are limited by the "curse of knowledge" bias and miss defects that we would have seen if we approached the application from the perspective of a new user.

But what is going on when we miss the obvious bugs, the ones that are literally staring us in the face? This, too, is attributable to a bias known as inattentional blindness. Christopher Chabris and Daniel Simons demonstrated this bias in their famous invisible gorilla test. Subjects were asked watch a video of a basketball game and count the number of passes between players. During the game, a gorilla walked across the basketball court. Over 50% of the subjects were so focused on counting the passes that they failed to see the gorilla. The same thing can happen to software testers: We become so focused on executing our test cases that we can fail to see the obvious bug.

So how do we use the concepts of bias and preconceived notions to become better software testers? Rather than allowing our biases to hamper our testing efforts, we should recognize upfront that we have these biases and preconceived notions and plan and execute software testing accordingly. For example, we can add additional time to our estimates and include negative test scenarios in our test planning. Even though we believe that that one developer’s code is always full of bugs and the other developer’s code never has bugs, we should execute just as many tests on the code we perceive as bug-free as we do on the buggy code. As testers, we can help each other prevent biased testing by peer reviewing test results — the same developers do code reviews — or running each other’s test cases.

Don’t miss the Invisible Gorilla
But how do we make sure we see the "Invisible Gorilla?" As testers, we need to approach our testing holistically; we need to focus our attention on determining if this is a quality product, as opposed to just tracing our test cases to requirements and executing all of our test cases.

In addition to executing test cases, we should do exploratory testing. Conducting exploratory testing prior to running test cases is useful because we have yet to make any assessments, and potentially developed biases, about the quality of the product. Lifeguards keep themselves alert and focused by switching stations during their shifts. Exploratory testing can be used in this way by working it in between our test runs.

Finally, we can use oracles, such as "What would someone who doesn’t know how this application works do?" And when we see something we don’t believe we are seeing, we should believe it and repeat it.

Source: http://searchsoftwarequality.techtarget.com/tip/Software-testing-techniques-Overcoming-biases

Did you like this? Share it: