Google Test is a unit testing library for the C++ programming language, based on the xUnit architecture. The library is released under the BSD 3-clause license.
It can be compiled for a variety of POSIX and Windows platforms, allowing unit-testing of 'C' sources as well as C++ with minimal source modification. The tests themselves could be run one at a time, or even be called to run all at once. This makes the debugging process very specific and caters to the need of many programmers and coders alike.

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.

Robot Framework project is hosted on GitHub where you can find further documentation, source code, and issue tracker. Downloads are hosted at PyPI. The framework has a rich ecosystem around it consisting of various generic test libraries and tools that are developed as separate projects.

Capybara is a library written in the Ruby programming language which makes it easy to simulate how a user interacts with an application. Capybara can talk with many different drivers which execute tests through the same clean and simple interface. You can seamlessly choose between Selenium, Webkit or pure Ruby drivers. Tackle the asynchronous web with Capybara's powerful synchronization features.
Capybara automatically waits for your content to appear on the page, you never have to issue any manual sleeps.

Selenium is an umbrella project encapsulating a variety of tools and libraries enabling web browser automation. Selenium specifically provides infrastructure for the W3C WebDriver specification -- a platform and language-neutral coding interface compatible with all major web browsers.
The project is made possible by volunteer contributors who've generously donated thousands of hours in code development and upkeep.

A collection of source from different Google projects that may be of use to developers working other Mac projects. Also, includes the Google Developer Spotlight Importers. To browse the Google Toolbox for Mac source code, visit the Source tab. Library changes are documented in the release notes. If you find a problem/bug or want a new feature to be included in the Google Toolbox for Mac, please join the discussion group or submit an issue. Google Toolbox for Mac follows the Google Objective-C Style Guide.

Android's ever-expanding ecosystem of devices creates a unique challenge to testing applications. Spoon aims to simplify this task by distributing instrumentation test execution and displaying the results in a meaningful way. Instead of attempting to be a new form of testing, Spoon makes existing instrumentation tests more useful. Using the application APK and instrumentation APK, Spoon runs the tests on multiple devices simultaneously. Once all tests have completed, a static HTML summary is generated with detailed information about each device and test. Spoon will run on all targets which are visible to adb devices.

Firing Range is a test bed for web application security scanners, providing synthetic, wide coverage for an array of vulnerabilities. Firing Range was developed by Google in the hopes of building a test ground for automated scanners. Firing Range doesn't focus on creating realistic-looking testbeds for human testers. Instead, the tool uses automation to exhaustively enumerate the contexts and the attack vectors that an application might exhibit. It is built entirely on Google technologies like Chrome and Google Cloud Platform, with support for the latest HTML5 features, a low false positive rate, and ease of use in mind.

A simple unit testing framework for C based on the xUnit style. Ideal for Test Driven Development (TDD). Designed to be portable. Those who are new to TDD / Unit Testing, can jump straight to Getting Started. Seatest requires to explicitly register all the tests and fixtures as the framework needs to be easily used in embedded environments / compilers / IDEs. The current prime target being PICs and the MPLAB IDE. Supports embedded development using a dual compiler approach. All the test fixtures and tests are created through the structure of the code itself.

A Ruby gem for writing powerful tests in Rails apps with very little code. Shoulda-matchers provides Test::Unit- and RSpec-compatible one-liners that test common Rails functionality. These tests would otherwise be much longer, more complex, and error-prone.If you're not testing a Rails project or don't want to use the matchers, you can use shoulda-context independently to write tests

The key to optimize work is to automate as much as possible.
Whether you are developing software, setting up infrastructure or even testing, if there is a chance to do it just take it.

Most of the times the boring and frequent tasks can be automated.
There are a lot of different tools and technologies that can help you with that,
but sometimes starting is simply an hassle by itself and one might end up giving up and doing it "manually".

This is where Athena jumps in. The idea is quite simple, we minimize the start process by:

Karma is a test runner for JavaScript that runs on Node.js. It is very well suited to testingAngularJS or any other JavaScript projects. Using Karma to run tests using one of many popular JavaScript testing suites (Jasmine, Mocha, QUnit, etc.) and have those tests executed not only in the browsers of your choice, but also on the platform of your choice (desktop, phone, tablet.) Karma is highly configurable, integrates with popular continuous integration packages (Jenkins, Travis, and Semaphore) and has excellent plugin support.

Taurus is an open source test automation tool that extends and abstracts JMeter, and helps to overcome these challenges. Taurus provides a simple way to create, run and analyze performance tests, which is basically an abstraction layer over JMeter (or Grinder or Gatling or Selenium). Taurus is an acronym that stands for Test Automation Running Smoothly, which reflects its baseline mission - making the process of test configuration and execution as simple as possible.

Chakram is an API testing framework designed to perform end to end tests on JSON REST endpoints.

The library offers a BDD testing style and fully exploits javascript promises - the resulting tests are simple, clear and expressive. Chakram is built on node.js, mocha and chai.

This readme offers an introduction to the library. For more information, visit Chakram's documentation and tests which demonstrate all of Chakram's capabilities. In addition, example tests of publicly accessible APIs are available in the examples directory. If required, assistance can be found in the project's gitter chat room.

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 the 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 the page and getting their locations and dimensions.
Once it sees that something is wrong - Galen reports the error, makes a screenshot and highlights the misbehaving element on it.

Jasmine is a behavior-driven development framework for testing JavaScript code. It does not depend on any other JavaScript frameworks. It does not require a DOM. And it has a clean, obvious syntax so that you can easily write tests. It's heavily influenced by, and borrows the best parts of, ScrewUnit, JSSpec, JSpec, and of course RSpec. Jasmine has a rich set of matchers included. There is also the ability to write custom matchers for when a project's domain calls for specific assertions that are not included below.

Tsung is a distributed load testing tool and an open source tool written in Erlang. It is protocol-independent and can currently be used to stress Jabber/XMPP, HTTP, SOAP, LDAP and PostgreSQL servers (SSL is supported). It simulates complex user's behaviour using an XML description file, reports many measurements in real time (including response times, CPU and memory usage from servers, customized transactions, etc.). HTML reports (with graphics) can be generated during the load. For HTTP, it supports 1.0 and 1.1, has a proxy mode to record sessions, supports GET and POST methods, Cookies, and Basic WWW-authentication. It has already been used to simulate thousands of virtual users.

Appium is an open-source tool for automating native, mobile web, and hybrid applications on iOS and Android platforms. Native apps are those written using the iOS or Android SDKs. Mobile web apps are web apps accessed using a mobile browser. Hybrid apps have a wrapper around a "webview" -- a native control that enables interaction with web content. Projects like Phonegap, make it easy to build apps using web technologies that are then bundled into a native wrapper, creating a hybrid app.Appium is "cross-platform": it allows to write tests against multiple platforms (iOS, Android), using the same API. This enables code reuse between iOS and Android testsuites.

Karate enables you to script a sequence of calls to any kind of web-service and assert that the responses are as expected. It makes it really easy to build complex request payloads, traverse data within the responses, and chain data from responses into the next request. Karate's payload validation engine can perform a 'smart compare' of two JSON or XML documents without being affected by white-space or the order in which data-elements actually appear, and you can opt to ignore fields that you choose.

Since Karate is built on top of Cucumber-JVM, you can run tests and generate reports like any standard Java project. But instead of Java - you write tests in a language designed to make dealing with HTTP, JSON or XML - simple.

White is a framework for automating rich client applications based on Win32, WinForms, WPF, Silverlight and SWT (Java) platforms. It is .NET based and does not require the use of any proprietary scripting languages. Tests/automation programs using White can be written with whatever .NET language, IDE and tools you are already using. White provides a consistent object-oriented API, hiding the complexity of Microsoft's UIAutomation library (on which White is based) and windows messages.Only stable versions of White are released, so all releases are production-ready.

Protractor is an end-to-end test framework for AngularJS applications.
Protractor runs tests against your application running in a real browser, interacting with it as a user would. Protractor is built on top of WebDriverJS, which uses native events and browser-specific drivers to interact with your application as a user would.
Protractor is intended for end to end or integration testing. Big tests in which you have a running instance of your entire application should be run using Protractor.
Protractor is intended to run tests from a user's point of view - if your test could be written down as instructions for a human interacting with your application, it should be an end to end test written with Protractor.

ExtentReports is a reporting library for automation testing for .NET and Java. It creates detailed and beautiful HTML reports for modern browsers. ExtentReports shows test and step summary along with dashboards, system and environment details for quick analysis of your tests. It is very easily integrated with all test-frameworks (TestNG, JUnit, NUnit etc.) and provides better looking reports. Because Extent is created as a logging utility, it is also possible to use custom logs for each test, add snapshots & videos, assign categories and authors and filter using several parameters.

Test-driven database development. Write readable, easy-to-maintain unit and integration tests for your database code. DBFitis a part of FitNesse, itself an implementation of the FIT acceptance testing framework. DBFit is directly targeted at database testing. Tests are written as wiki tables with a query or procedure execute followed by a listing of the expected results. It can handle direct SQL, stored procedures, or, with a bit of simple customization, custom procedures.

Tarantula is modern tool for managing software testing in agile software projects. It's free, licensed as open source software under GNU GPLv3.

Tarantula is modern tool for managing software testing in agile software projects. it is free. it aims to be the best open source test management tool, especially in Agile Testing, Testing management, Reporting and Usability.

Its Dashboard offers quick status view to your report. It is based on Test Object, meaning that you can select particular “release/version” to be viewed. There are various metrics displayed, e.g. how testing is progressing, failed cases, testing and requirement coverage etc.

EclEmma is a free Java code coverage tool for Eclipse, available under the Eclipse Public License.
It brings code coverage analysis directly into the Eclipse workbench:
Fast develop/test cycle: Launches from within the workbench like JUnit test runs can directly be analyzed for code coverage.
Rich coverage analysis: Coverage results are immediately summarized and highlight;ed in the Java source code editors.
Non-invasive: EclEmma does not require modifying your projects or performing any other setup. Since version 2.0 EclEmma is based on the JaCoCo code coverage library. The Eclipse integration has its focus on supporting the individual developer in an highly interactive way.

XMLUnit is an open source project licensed under the BSD license. It provides a small library of interrelated classes that simplify each of the different ways to test XML pieces that have been outlined in the previous section. Special APIs are provided to simplify writing unit tests with J/NUnit, but the library itself is fully usable without any testing framework at all. There is a Java and a .NET version of XMLUnit. XMLUnit’s APIs will accept “pieces of XML” as input using several different forms. In most cases they can be provided as InputStreams, Readers, Strings, InputSources or readily parsed DOM Document instances. XMLUnit also provides a Transform class that can be used to apply an XSLT transformation to an existing input.

Imprimatur is a tool for performing automated functional testing on web applications. The tests are described in a simple test script. Along with the standard HTTP methods, Imprimatur handles authentication, file uploads and HTTPS. The responses are validated using regular expressions.

Robolectric is designed to allow you to test Android applications on the JVM based on the JUnit 4 framework. Robolectric is a framework that allows you to write unit tests and run them on a desktop JVM while still using Android API. Robolectric mocks part of the Android framework contained in the android.jar file. Robolectric provides also implementations for the methods while the standard Android unit testing support throws exceptions for all Android methods.

This enables you to run your Android tests in your continuous integration environment without any additional setup.Robolectric supports resource handling, e.g., inflation of views. You can also use the findViewById() to search in a view.

RedGlass works alongside Selenium to observe browser events, and provides an interactive log which illustrates changes to the DOM during an automation session. It can be used as a diagnostic tool for writing tests which involve complex browser events and interactions. RedGlass loads a javascript application into your browser session which listens for the event types. When one of those events is fired, the event data is posted to a local server which temporarily persists the data in memory. The data is then served through a Web Socket initiated by the client UI. Since there is no persistent data store, the event data is lost as soon as it is removed from memory (page refresh, server restart, etc).

MiniTest, as the name suggests, is a small and fast unit testing framework. Shipped with Ruby 1.9, MiniTest supports a complete suite of testing capabilities such as TDD, BDD, mocking, and benchmarking. Since ruby 1.9 the ruby standard library has included a testing framework called MiniTest, it is a modern and lightweight replacement for ruby 1.8's Test::Unit framework. MiniTest provides:

RSpec is a Behaviour-Driven Development tool for Ruby programmers. BDD is an approach
to software development that combines Test-Driven Development, Domain Driven Design,
and Acceptance Test-Driven Planning. RSpec helps you do the TDD part of that equation,
focusing on the documentation and design aspects of TDD. RSpec is composed of multiple libraries, which are designed to work together, or can be used independently with other testing tools like Cucumber or Minitest.

AutoHotkey (AHK) is a free, open-source macro-creation and automation software for Windows that allows users to automate repetitive tasks. It is driven by a scripting language that was initially aimed at providing keyboard shortcuts, otherwise known as hotkeys, that over time evolved into a full-fledged scripting language. And if you're really interested, here's a great video about it

RCUNIT is a small framework for testing C programs and a black box testing tool. It uses non-local jumps to emulate exceptions and handles program terminating signals (e.g. SIGILL) during test runs. RCUNIT allows creation of test fixtures, either per test or per test group. RCUNIT also provides a runtime memory leak check facility and an extensible exception handling mechanism. Requiring only an ANSI compliant C compiler, it is a highly portable unit testing tool.

TestCafe is a pure node.js end-to-end solution for testing web apps. It takes care of all the stages: starting browsers, running tests, gathering test results and generating reports. TestCafe doesn’t need browser plugins - it works in all popular modern browsers out-of-the-box.

Behat is an open source Behavior Driven Development framework for PHP 5.3+. What’s behavior driven development, you ask? It’s a way to develop software through a constant communication with stakeholders in form of examples; examples of how this software should help them, and you, to achieve your goals.

Behat is considered an official Cucumber implementation in PHP and is part of one big family of BDD tools.

Freshen is an acceptance testing framework for Python . uses the (mostly) same syntax as Cucumber. Why copy Cucumber? - Because it works and lots of people use it. Why use Nose? - Because it works and lots of people use it and it already does many useful things. No need to spend time in re-implementing coverage, profiling, test discovery, and command like processing again. Freshen supports 30 languages, exactly the same as cucumber, since the "language" file was borrowed from the cucumber project. As long as your .feature files respect the syntax, the person in charge of writing the acceptance tests may write it down.

Unity is a unit test framework written entirely in the C language. It is lightweight and possesses special features for embedded systems. Unity has scaled well from small to large embedded projects but can be used for any C project. At only one source file and a couple of header files, it doesn’t get much smaller.

PhantomJS is a scripted, headless browser used for automating web page interaction.
PhantomJS provides a JavaScript API enabling automated navigation, screenshots, user behavior and assertions making it a common tool used to run browser-based unit tests in a headless system like a continuous integration environment.
PhantomJS is based on WebKit making it a similar browsing environment to Safari and Google Chrome(before Chrome's fork of WebKit evolved into Blink). It is open-source software released under the BSD License.

NBehave framework is based on the behavioral domain specific language (DSL) of Behavior Driven Design (BDD). The primary goal of NBehave is a framework for defining and executing application requirement goals. These characterizations are modeled after the Behavioral Driven Design (BDD) terms Story, Scenario, Given, When, Then. Relying on a syntax that is lightweight and targeted at product owners (a few "quotes" mostly), the code becomes an executable and self-describing requirements document. The definitions within the actual unit test of the application along with the nature of the architecture and the domain model makes these concepts a sound framework.

RedwoodHQ is a free Open Source test automation framework that allows multiple users to develop automation code, create readable action/keyword driven test cases and execute them all under a single Web interface.RedwoodHQ supports any Java/Groovy code or test tools like Selenium, Appium, etc., can be used for back-end as well as front-end automation.

JBehave is a framework for Behaviour-Driven Development (BDD). BDD is an evolution of test-driven development (TDD) and acceptance-test driven design, and is intended to make these practices more accessible and intuitive to newcomers and experts alike. It shifts the vocabulary from being test-based to behaviour-based, and positions itself as a design philosophy.

Robotium is a test framework created to make it easy to write powerful and robust automatic black-box test cases for Android applications. With the support of Robotium, test case developers can write function, system and acceptance test scenarios, spanning multiple Android activities.
Robotium has full support for Activities, Dialogs, Toasts, Menus and Context Menus.

FlexUnit is a unit testing framework for Flex and ActionScript 3.0 applications and libraries. It mimics the functionality of JUnit, a Java unit testing framework, and comes with a graphical test runner. FlexUnit 4 was created to modernize testing with ActionScript 3.0 and Flex, bringing parity with the tools and techniques available to the Java community. It provides full support for unit testing in the tradition of FlexUnit .9 , but goes further with rich asynchronous support, meta-data defined testing, support for integration-level testing and an extensibility layer for new types and methods of testing.

PHPUnit is a unit testing software framework for the programming language PHP. Created by Sebastian Bergmann, PHPUnit is one of the xUnit family of frameworks that originated with SUnit. It uses assertions to verify that behavior of the unit of code under test behaves as expected. PHPUnit is the de-facto standard for unit testing in PHP projects. It provides both a framework to write the tests as well as the functionality to run the tests and analyze their results. It supports the development of object-oriented PHP applications using the concepts and methods of Agile Programming, Extreme Programming, Test-Driven Development, and Design-by-Contract Development.

JUnit is a unit testing framework for the Java programming language. JUnit has been important in the development of test-driven development, and is one of a family of unit testing frameworks which is collectively known as xUnit that originated with SUnit. JUnit is linked as a JAR at compile-time; the framework resides under package junit.framework for JUnit 3.8 and earlier, and under packageorg.junit for JUnit 4 and later.

Celerity is a JRuby library for easy and fast functional test automation for web applications. Celerity is a JRuby wrapper around HtmlUnit – a headless Java browser with JavaScript support. It provides a simple API for programmatic navigation through web applications.Celerity provides a superset of Watir's API.