- http://blogs.msdn.com/b/jw_on_tech/ - James Whittaker
- http://www.developsense.com/ - Michael Bolton
- http://context-driven-testing.com/ Cem Kaner, James Bach, Brian Marick, Bret Pettichord, et al
- - IEEE 829-2008, also known as the 829 Standard for Software and System Test Documentation
- BS 7925-2 - Standard for Software Component Testing
- Being an Agile Tester - You're going to need a bigger hat rack
- What makes a good test engineer?
- Seven Kinds Of Testers - JMB
- Why you're NOT a Software Testing Expert, probably
- PDF: How to Break Software - James Whittaker
- PDF: What Is Software Testing? And Why Is It So Hard? - James Whittaker
- Testing References
- Google Testing Blog
- Association for Software Testing - an international non-profit professional association with members in over 50 countries. AST is dedicated and strives to build a testing community that views the role of testing as skilled, relevant, and essential to the production of faster, better, and less expensive software products. We value a scientific approach to developing and evaluating techniques, processes, and tools. We believe that a self-aware, self-critical attitude is essential to understanding and assessing the impact of new ideas on the practice of testing.
- https://en.wikipedia.org/wiki/Test_strategy - an outline that describes the testing approach of the software development cycle. It is created to inform project managers, testers, and developers about some key issues of the testing process. This includes the testing objective, methods of testing new functions, total time and resources required for the project, and the testing environment.
Test strategies describe how the product risks of the stakeholders are mitigated at the test-level, which types of test are to be performed, and which entry and exit criteria apply. They are created based on development design documents. System design documents are primarily used and occasionally, conceptual design documents may be referred to. Design documents describe the functionality of the software to be enabled in the upcoming release. For every stage of development design, a corresponding test strategy should be created to test the new feature sets.
- https://en.wikipedia.org/wiki/Test_plan - a document detailing a systematic approach to testing a system such as a machine or software. The plan typically contains a detailed understanding of the eventual workflow.
- https://en.wikipedia.org/wiki/Test_design - the act of creating and writing test suites for testing a software.
- https://en.wikipedia.org/wiki/Test_suite - less commonly known as a validation suite, is a collection of test cases that are intended to be used to test a software program to show that it has some specified set of behaviours. A test suite often contains detailed instructions or goals for each collection of test cases and information on the system configuration to be used during testing. A group of test cases may also contain prerequisite states or steps, and descriptions of the following tests.
- https://en.wikipedia.org/wiki/Test_case - a set of conditions or variables under which a tester will determine whether an application, software system or one of its features is working as it was originally established for it to do. The mechanism for determining whether a software program or system has passed or failed such a test is known as a test oracle. In some settings, an oracle could be a requirement or use case, while in others it could be a heuristic. It may take many test cases to determine that a software program or system is considered sufficiently scrutinized to be released. Test cases are often referred to as test scripts, particularly when written - when they are usually collected into test suites.
- https://en.wikipedia.org/wiki/Test_automation - the use of special software (separate from the software being tested) to control the execution of tests and the comparison of actual outcomes with predicted outcomes. Test automation can automate some repetitive but necessary tasks in a formalized testing process already in place, or add additional testing that would be difficult to perform manually.
- https://en.wikipedia.org/wiki/Test_harness - or automated test framework is a collection of software and test data configured to test a program unit by running it under varying conditions and monitoring its behavior and outputs. It has two main parts: the test execution engine and the test script repository. Test harnesses allow for the automation of tests. They can call functions with supplied parameters and print out and compare the results to the desired value. The test harness is a hook to the developed code, which can be tested using an automation framework.
- https://en.wikipedia.org/wiki/White-box_testing - a method of testing software that tests internal structures or workings of an application, as opposed to its functionality
- https://en.wikipedia.org/wiki/Static_testing - a form of software testing where the software isn't actually used. checks mainly for the sanity of the code, algorithm, or document. It is primarily checking of the code and/or manually reviewing the code or document to find errors. This type of testing can be used by the developer who wrote the code, in isolation. Code reviews, inspections and Software walkthroughs are also used.
- https://en.wikipedia.org/wiki/Black-box_testing - examines the functionality of an application (e.g. what the software does) without peering into its internal structures or workings. This method of test can be applied to virtually every level of software testing: unit, integration, system and acceptance. It typically comprises most if not all higher level testing, but can also dominate unit testing as well.
- https://en.wikipedia.org/wiki/Dynamic_testing - dynamic analysis refers to the examination of the physical response from the system to variables that are not constant and change with time. In dynamic testing the software must actually be compiled and run. It involves working with the software, giving input values and checking if the output is as expected by executing specific test cases which can be done manually or with the use of an automated process. This is in contrast to static testing. Unit tests, integration tests, system tests and acceptance tests utilize dynamic testing.
- https://en.wikipedia.org/wiki/Integration_testing - the phase in software testing in which individual software modules are combined and tested as a group. It occurs after unit testing and before validation testing.
- https://en.wikipedia.org/wiki/Fuzz_testing - involves providing invalid, unexpected, or random data to the inputs of a computer program. The program is then monitored for exceptions such as crashes, or failing built-in code assertions or for finding potential memory leaks. Fuzzing is commonly used to test for security problems in software or computer systems. It is a form of random testing which has been used for testing hardware or software.
- american fuzzy lop - a security-oriented fuzzer that employs a novel type of compile-time instrumentation and genetic algorithms to automatically discover clean, interesting test cases that trigger new internal states in the targeted binary. This substantially improves the functional coverage for the fuzzed code. The compact synthesized corpora produced by the tool are also useful for seeding other, more labor- or resource-intensive testing regimes down the road.
- zzuf - a transparent application input fuzzer. Its purpose is to find bugs in applications by corrupting their user-contributed data (which more than often comes from untrusted sources on the Internet). It works by intercepting file and network operations and changing random bits in the program’s input. zzuf’s behaviour is deterministic, making it easier to reproduce bugs.
- http://techblog.netflix.com/2016/10/netflix-chaos-monkey-upgraded.html 
- http://www.principlesofchaos.org 
- https://en.wikipedia.org/wiki/Exploratory_testing - an approach to software testing that is concisely described as simultaneous learning, test design and test execution. Cem Kaner, who coined the term in 1983, now defines exploratory testing 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."
While the software is being tested, the tester learns things that together with experience and creativity generates new good tests to run. Exploratory testing is often thought of as a black box testing technique. Instead, those who have studied it consider it a test approach that can be applied to any test technique, at any stage in the development process. The key is not the test technique nor the item being tested or reviewed; the key is the cognitive engagement of the tester, and the tester's responsibility for managing his or her time.
- https://en.wikipedia.org/wiki/Session-based_testing - a software test method that aims to combine accountability and exploratory testing to provide rapid defect discovery, creative on-the-fly test design, management control and metrics reporting. The method can also be used in conjunction with scenario testing. Session-based testing was developed in 2000 by Jonathan and James Bach. Session-based testing can be used to introduce measurement and control to an immature test process and can form a foundation for significant improvements in productivity and error detection. Session-based testing can offer benefits when formal requirements are not present, incomplete, or changing rapidly.
- https://en.wikipedia.org/wiki/Error_guessing - a test method in which test cases used to find bugs in programs are established based on experience in prior testing. The scope of test cases usually rely on the software tester involved, who uses past experience and intuition to determine what situations commonly cause software failure, or may cause errors to appear.
- https://en.wikipedia.org/wiki/Scenario_testing - a software testing activity that uses scenarios: hypothetical stories to help the tester work through a complex problem or test system. The ideal scenario test is a credible, complex, compelling or motivating story the outcome of which is easy to evaluate. These tests are usually different from test cases in that test cases are single steps whereas scenarios cover a number of steps. Kaner coined the phrase scenario test by October 2003. He commented that one of the most difficult aspects of testing was maintaining step-by-step test cases along with their expected results. His paper attempted to find a way to reduce the re-work of complicated written tests and incorporate the ease of use cases.
- https://en.wikipedia.org/wiki/Functional_testing - a quality assurance (QA) process and a type of black box testing that bases its test cases on the specifications of the software component under test. Functions are tested by feeding them input and examining the output, and internal program structure is rarely considered (not like in white-box testing). Functional testing differs from system testing in that functional testing "verifies a program by checking it against ... design document(s) or specification(s)", while system testing "validate[s] a program by checking it against the published user or system requirements"
- https://en.wikipedia.org/wiki/Non-functional_testing - testing of a software application for its non-functional requirements. The names of many non-functional tests are often used interchangeably because of the overlap in scope between various non-functional requirements. For example, software performance is a broad term that includes many specific requirements like reliability and scalability.
- https://en.wikipedia.org/wiki/Software_performance_testing - testing performed to determine how a system performs in terms of responsiveness and stability under a particular workload. It can also serve to investigate, measure, validate or verify other quality attributes of the system, such as scalability, reliability and resource usage. Performance testing is a subset of performance engineering, an emerging computer science practice which strives to build performance into the implementation, design and architecture of a system.
- https://salsa.debian.org/reproducible-builds/disorderfs - an overlay FUSE filesystem that introduces non-determinisminto filesystem metadata. For example, it can randomize the orderin which directory entries are read. This is useful for detectingnon-determinism in the build process.
- https://en.wikipedia.org/wiki/Unit_testing - testing method by which individual units of source code, sets of one or more computer program modules together with associated control data, usage procedures, and operating procedures are tested to determine if they are fit for use. Intuitively, one can view a unit as the smallest testable part of an application. In procedural programming, a unit could be an entire module, but it is more commonly an individual function or procedure. In object-oriented programming, a unit is often an entire interface, such as a class, but could be an individual method. Unit tests are short code fragments created by programmers or occasionally by white box testers during the development process. Ideally, each test case is independent from the others. Substitutes such as method stubs, mock objects, fakes, and test harnesses can be used to assist testing a module in isolation. Unit tests are typically written and run by software developers to ensure that code meets its design and behaves as intended.
- A Set of Unit Testing Rules by Michael Feathers. Difference between unit and integration tests.
- Rice Consulting Services - Software Testing Training
- Software Testing Tutorial 1: Why Testing is Important?
- Open Lecture by James Bach on Software Testing
- James Bach on testing in an agile software development team.
- Agile Software Testing with James Bach
- James Bach speaking on "Switching to the Context Driven School of Testing"
- How to Think about Efficiency in Software Testing - James Bach
- GTAC 2010: Turning Quality on its Head - James Whittaker
- http://www.allreadable.com/4fea1y1q - transcription
- http://blog.utest.com/2010/12/21/more-bang-for-your-testing-buck-follow-up-qa-with-james-whittaker/ - follow-up on different talk, not too long after though
- YouTube: GTAC 2011: Opening Keynote Address - Test is Dead - Alberto Savoia
- YouTube: GTAC 2011: Keynote - How Hackers See Bugs
- Agile Testing Challenges Webinar - 2010, business language heavy
- Agile Testing in the Real World 121013
to check later;
- EuroSTAR Software Testing Conference - Europe’s #1 Event for Software Testers
- YouTube: EuroSTARConference
See also WebDev#Testing
- gcov - a test coverage program. Use it in concert with GCC to analyze your programs to help create more efficient, faster running code and to discover untested parts of your program. You can use gcov as a profiling tool to help discover where your optimization efforts will best affect your code. You can also use gcov along with the other profiling tool, gprof, to assess which parts of your code use the greatest amount of computing time.
- Gcovr - provides a utility for managing the use of the GNU gcov utility and generating summarized code coverage results. This command is inspired by the Python coverage.py package, which provides a similar utility for Python.
- https://en.wikipedia.org/wiki/xUnit - the collective name for several unit testing frameworks that derive their structure and functionality from Smalltalk's SUnit. SUnit, designed by Kent Beck in 1998, was written in a highly-structured object-oriented style, which lent easily to contemporary languages such as Java and C#. Following its introduction in Smalltalk the framework was ported to Java by Beck and Erich Gamma and gained wide popularity, eventually gaining ground in the majority of programming languages in current use.
- JUnit is a simple framework to write repeatable tests. It is an instance of the xUnit architecture for unit testing frameworks.
- TestDox creates simple documentation from the method names in JUnit test cases.
- FitNesse - The fully integrated standalone wiki and acceptance testing framework.
- Watir - pronounced water, is an open-source (BSD) family of Ruby libraries for automating web browsers. It allows you to write tests that are easy to read and maintain. It is simple and flexible. Watir drives browsers the same way people do. It clicks links, fills in forms, presses buttons. Watir also checks results, such as whether expected text appears on the page. Watir is a family of Ruby libraries but it supports your app no matter what technology it is developed in. Whilst Watir supports only Internet Explorer on Windows, Watir-WebDriver supports Chrome, Firefox, Internet Explorer, Opera and also running in headless mode (HTMLUnit). Like other programming languages, Ruby gives you the power to connect to databases, read data files and spreadsheets, export XML, and structure your code as reusable libraries.
- WatiN - Web Application Testing In .Net. Inspired by Watir development of WatiN started in December 2005 to make a similar kind of Web Application Testing possible for the .Net languages
- https://github.com/catchorg/Catch2 - A modern, C++-native, header-only, test framework for unit-tests, TDD and BDD - using C++11, C++14, C++17 and later (or C++03 on the Catch1.x branch)
- Selenium is a portable software testing framework for web applications. Selenium provides a record/playback tool for authoring tests without learning a test scripting language (Selenium IDE). It also provides a test domain-specific language (Selenese) to write tests in a number of popular programming languages, including C#, Java, Groovy, Perl, PHP, Python and Ruby. The tests can then be run against most modern web browsers.
- What's the correct pronunciation of "Selenium"? - with project history
- Automating Your Browser Based Testing Using WebDriver - Simon Stewart, Google Tech Talk, March 16, 2012
- Simon Stewart, Selenium State of the Union - SeleniumConf 2013
Selenium 1 (Remote Control)
- Bromine is an open source QA tool that uses selenium RC as its testing engine.
Selenium 2 (WebDriver)
- YouTube: GTAC 2013: WebDriver for Chrome
- YouTube: GTAC 2013: Web Performance Testing with WebDriver
- http://www.seleniumwebdriver.com/ The Online Community for Selenium 2.0 Webdriver and Selenium RC Users and Professionals
- Watir WebDriver - the most elegant way to use WebDriver with ruby.
- Selendroid is a test automation framework which drives off the UI of Android native and hybrid applications (apps) and the mobile web. Tests are written using the Selenium 2 client API - that's it!
- Simon Stewart, Google @iqnite: Building a Test Grid for the Cloud: Scalable Test Automation
- Francois Reynaud + Kevin Menard: Selenium 2 Grid - 2011
- https://github.com/groupon/Selenium-Grid-Extras - Simplify the managment of the Selenium Grid Nodes and stabilize said nodes by cleaning up the test environment after the build has been completed
- YouTube: Large scale selenium grid managment
- https://github.com/zalando/zalenium - a Selenium Grid extension to scale your local grid dynamically with docker containers. It uses docker-selenium to run your tests in Firefox and Chrome locally, if you need a different browser, your tests can get redirected to a cloud testing provider (Sauce Labs, BrowserStack, TestingBot). Zalenium also works out of the box in Kubernetes.
- Selendroid is a test automation framework which drives off the UI of Android native and hybrid applications (apps) and the mobile web. Tests are written using the Selenium 2 client API - that's it!
- ios-driver - Test any IOS native, hybrid, or mobile web application using Selenium / WebDriver.
- Appium is an open source test automation framework for use with native and hybrid mobile apps. It drives iOS and Android apps using the WebDriver JSON wire protocol.
- Galen is a test framework originally designed for testing layout of web applications but is also a great tool for functional testing. When it comes to testing a responsive layout it works in a following way: Open a page in browser, Resize it to specified size, Test the layout according to user-defined specs. It uses Selenium for interacting with elements on page and getting their locations and dimensions.
- Cucumber lets software development teams describe how software should behave in plain text. The text is written in a business-readable domain-specific language and serves as documentation, automated tests and development-aid - all rolled into one format. Cucumber works with Ruby, Java, .NET, Flex or web applications written in any language. Cucumber also supports more succinct tests in tables - similar to what FIT does. Dig around in the examples and documentation to learn more about Cucumber tables. Cucumber is the RSpec Story Runner done right.
- Concordion - an open source tool for writing automated acceptance tests in Java (and .NET, Python, Scala, and Ruby).
- Test Recorder - The purpose of the application is to generate code compatible with several applications, including WatiN (Web Application Testing In .NET), Celerity, and WatiR.
- Window Licker - A framework for the test-driven development of Java systems through the GUI.
- cyber-dojo is where software teams do deliberate practice. You write your code and tests inside a browser! A cyber-dojo session is great for learning about tdd, team dynamics, and software development in general.
- RSpec is testing tool for the Ruby programming language. Born under the banner of Behaviour-Driven Development, it is designed to make Test-Driven Development a productive and enjoyable experience
- HtmlUnit is a "GUI-Less browser for Java programs". It models HTML documents and provides an API that allows you to invoke pages, fill out forms, click links, etc... just like you do in your "normal" browser. HtmlUnit is not a generic unit testing framework. It is specifically a way to simulate a browser for testing purposes and is intended to be used within another testing framework such as JUnit or TestNG.
- JWebUnit is a Java-based testing framework for web applications. It wraps existing testing frameworks such as HtmlUnit and Selenium with a unified, simple testing interface to allow you to quickly test the correctness of your web applications.
- Webrat lets you quickly write expressive and robust acceptance tests for a Ruby web application.
- Windmill is a web testing tool designed to let you painlessly automate and debug your web application.
Originating at the Open Source Applications Foundation Windmill was built to help QA keep up with the rapid release cycles of the Chandler Server Web UI (Cosmo) project.
- CubicTest is a graphical Eclipse plug-in for writing Selenium and Watir tests. It makes tests faster and easier to write, and provides abstractions to make tests more robust and reusable. CubicTest's test editor is centered around pages/states and transitions between these pages/states. The model is intuitive for both Ajax and traditional web applications and supports most user interaction types.
- Robot Framework is a generic test automation framework for acceptance testing and acceptance test-driven development (ATDD). It has easy-to-use tabular test data syntax and it utilizes the keyword-driven testing approach. Its testing capabilities can be extended by test libraries implemented either with Python or Java, and users can create new higher-level keywords from existing ones using the same syntax that is used for creating test cases.
- Tapster - Mobile Automation Robot
- TUT is a small and portable unit test framework for C++.
- UnitTest++ is a lightweight unit testing framework for C++.
- Bandit is a framework for C++11 that wants to make working with unit tests a pleasant experience.
- Snowhouse is a stand alone assertion framework for C++. It was originally developed as part of Igloo and has been extracted to be usable in other contexts.
- cute - C++ unit test executor
- Coded UI - Test Automation Using Visual Studio 2010 Coded UI
- Best Practices for Coded UI Tests
- https://github.com/google/googletest - Google's C++ test framework!