Functional Testing Tools: Open Source or Commercial Acceptance and User Automated Software Testing


Open Source Functional Software Testing Tools


.NetSpec is a small test extension framework for the Visual Studio Testing Framework. Its main goals are: * Allow users to write tests in an RSpec like syntax more in terms with Behaviour Driven Developement (BDD) * Make tests easier to read * Integrate with TFS team build and Visual Studio test view

Abbot Java GUI Test Framework

Abbot helps you test your Java UI. It comprises Abbot, which lets you programmatically drive UI components, and Costello (built on Abbot) which allows you to easily launch, explore and control an application. The framework may be used with both scripts and compiled code.


Anteater is a testing framework designed around Ant, from the Apache Jakarta Project. It provides an easy way to write tests for checking the functionality of a Web application or of an XML Web service. The type of tests you can write using Anteater are: * Send a HTTP/HTTPS request to a Web server. When the response comes back, test that it meets certain criteria. You can check for HTTP headers and response codes, and validate the response body with regexp, XPath, Relax NG, or contentEquals tests, plus some binary formats. New tests can be easily added. * Listen for incoming HTTP requests at an given URL on the local machine. When a request comes on that URL, you can check its parameters and/or content, and send a response accordingly.


Apodora is an automated functional testing framework for web applications. It is used to create automated functional tests for web applications. Apodora Features: * Increased Test Coverage * Decreased Test Management * Robust Automation Object Repository * Automate Testing of Multiple Technologies * Enhanced Extensibility * Accessible Functionality * Advanced and Beginner Features * Based in IronPython

Approval Tests

Unit testing asserts can be difficult to use. Approval tests simplify this by taking a snapshot of the results, and confirming that they have not changed.


Arbiter is a requirements gathering and acceptance testing tool for project managers and web developers, to help ease client interaction. The project specification can be defined in word processor format as you would normally. By adding some special items, such as titled bulleted lists and highlighted text items, both a test suite and glossary can be written right into the spec. The Arbiter server will parse these documents and run the tests, reporting the results into the documents themselves. This allows the client to see project process. It also allows the developers, sitting next to the client, to add concrete executable examples of the use cases. This adds clarity and helps to settle disputes over required functionality. Using the glossary, developers can signal to the client that concepts are not well understood. Tests can be marked pending if a document contains unexplained glossary items.


Autonet is an GUI network test platform, internally it's based on CLI to communicate with devices. It can help you to arrange test cases, setup commands to devices ,run commands to check results and record test results.


AutoPy is a simple toolkit for automating and scripting repetitive tasks, especially those involving a GUI, with Python. It includes functions for controlling the mouse and keyboard, finding colors and bitmaps on-screen, as well as displaying cross-platform alerts.


Avignon is an acceptance test system that allows you to write executable tests in a language that you define. It uses XML to define the syntax of the language but, if you choose to extend the language, leaves the semantics of the tests up to you.


Barista makes developing UI test faster, easier and more predictable. Built on top of Espresso, it provides a simple an discoverable API, removing most of the boilerplate and verbosity of common Espresso tasks. You and your Android team will write tests with no effort.


Bddify is a simple to use and extend BDD framework for .Net developers


benerator is a framework for creating realistic and valid high-volume test data, used for testing (unit/integration/load) and showcase setup. Metadata constraints are imported from systems and/or configuration files. Data can be imported from and exported to files and systems, anonymized or generated from scratch. Domain packages provide reusable generators for creating domain-specific data as names and addresses internationalizable in language and region. It is strongly customizable with plugins and configuration options. benerator is released under a dual license - GPL and commercial. For quick details check the FAQ.


Browsershots makes screenshots of your web design in different browsers. It is a free open-source online service created by Johann C. Rocholl. When you submit your web address, it will be added to the job queue. A number of distributed computers will open your website in their browser. Then they will make screenshots and upload them to the central server here.

Canoo WebTest

Canoo WebTest is a free open source tool for automated testing of 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 aims at being API compatible with Watir.


Concordion is mainly aimed at the development team that consists of analysts/clients and developers working together in an agile fashion. The analysts/clients work together with the developer to write the specifications in HTML. The developers then write their fixtures in a .NET language and Concordion runs the two together producing red/green results like a unit test.


CubicTest is a graphical Eclipse plug-in for writing Selenium and Watir tests. It makes web 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. CubicTest features an innovative test recorder and test runner based on Selenium RC which are fully integrated with the graphical test editor. Tests can also run standalone from Maven 2.


Cucumber is a tool that can execute plain-text documents as automated functional tests.


DejaGnu is a framework for testing other programs. Its purpose is to provide a single front end for all tests. Think of it as a custom library of Tcl procedures crafted to support writing a test harness. A test harness is the testing infrastructure that is created to support a specific program or tool. Each program can have multiple testsuites, all supported by a single test harness. DejaGnu is written in Expect, which in turn uses Tcl -- Tool command language.


dogtail is a GUI test tool and automation framework written in Python. It uses Accessibility (a11y) technologies to communicate with desktop applications. dogtail scripts are written in Python and executed like any other Python program.


Ebselen is a Mavenised Selenium Test Framework


Expect is a tool for automating interactive applications such as telnet, ftp, passwd, fsck, rlogin, tip, etc. Expect really makes this stuff trivial. Expect is also useful for testing these same applications. And by adding Tk, you can also wrap interactive applications in X11 GUIs.


FEST (Fixtures for Easy Software Testing) is an open source library licensed under Apache 2.0 that makes it easy to create and maintain robust functional GUI tests.


Flexmojos provides first-class support for Flex and AIR development within Apache Maven. It allows Maven to compile, optimize, and test Flex SWF, Flex SWC, Air SWF and Air SWC. The main goal is to provide full support to all mxmlc/compc options. Major features: * SWF, SWC, AIR and Flex versions; * AIR signing and .air file generation; * RSL and caching framework support; * Modules support; * full implementation of MXMLC and COMPC options; * Flex 3 and Flex 4 * use FLEX-OEM-COMPILER - faster, less memory usage, no need of references to local drive; * compatible with several unit testing frameworks: FlexUnit, FUnit, asUnit, AdvancedFlex, fluint and FlexUnit 4 * html-wrappers generation * code generation using GAS3


FlexMonkey is a testing framework for Flex apps that provides for the capture, replay and verification of Flex UI functionality. FlexMonkey can record and playback Flex UI interactions, and generates ActionScript-based testing scripts that can easily be included within a continuous integration process. It uses the Flex Automation API and was created by extending Adobe's sample automation adapter, AutoQuick.


Frankenstein is a Functional Testing tool for Swing applications. Frankenstein's focus is on readable, simple, fast functional tests that can be shared and run by everyone on a team. Apart from automating your functional tests, you could also use Frankenstein for recording bugs so that they may be easily reproduced later.


FuncUnit is a free, open source, web application testing tool. It is the first complete functional testing tool built for JavaScript developers by JavaScript developers.


FunFX is the only free alternative to achieve functional testing of Adobe Flex applications.


FunkLoad is an open source functional and load web tester, written in Python.

Given When Then

Simple, powerful acceptance testing for node.js. Construct acceptance tests with BDD semantics in straightforward, sentence-like statements. Execute your tests in the cloud using Selenium 2 on Sauce Labs.


IdMUnit is the leading xUnit automated testing framework for Identity Management that simplifies and accelerates the functional testing of the solution. Test cases are defined and implemented in spreadsheet format. This product plugs into Eclipse.


Lightweight, yet powerful web application test harness. Test scripts written in XML. No programming required and no changes required to your web application. Supports sessions/cookies, POST form data. Command line based for integration into other tools. Also useful for regression and smoke testing


ItsNat is an innovative open source (dual licensed, GNU Affero General Public License v3/commercial license for closed source projects) Java AJAX Component based Web Framework. It offers a natural approach to the modern web development. Why natural? ItsNat leverages the old tools to build the new AJAX based Web 2.0 applications: pure (X)HTML templates, pure W3C DOM... and pure Java!. ItsNat is server centric using a unique approach called TBITS, "The Browser Is The Server": ItsNat simulates a Universal W3C Java Browser at the server, with ItsNat the server mimics the behavior of a web browser, containing a W3C DOM Level 2 node tree and receiving W3C DOM Events.


iValidator is a framework for XML-based test automation of complex test scenarios. iValidator is completely written in Java. The framework is available under an open source licence. iValidator is designed to run integration tests with large test scenarios for J2EE based applications. iValidator is equally suitable for black box and white box tests. Especially server applications can be tested at any desired level of complexity. Although applicable iValidator is not designed for unit and gui tests.


Jacareto is a capture & replay tool for programs written in Java. You can capture actions on applications and replay them later on (like macros). Jacareto can be used for many purposes: * GUI tests * Creation of animated demonstrations * Creation of macros * Qualitative and quantitative analyses of user behavior There are two front ends included in Jacareto: * CleverPHL is a GUI front end for Jacareto * Picorder is a command line front end for Jacareto


Jacobie is a Java API for use with Internet Explorer. Based on the JACOB project (JAva to COm Bridge) and the IE COM Object, it directly controls IE from java. This API can be used as a true end-user web browser test with IE and not a Http-Based test such as HttpUnit.


Jameleon is an automated testing framework that can be easily used by technical and non-technical users alike. One of the main concepts behind Jameleon is to create a group of keywords or tags that represent different screens of an application. All of the logic required to automate each particular screen can be defined in Java and mapped to these keywords. The keywords can then be organized with different data sets to form test scripts without requiring an in-depth knowledge of how the application works. The test scripts are then used to automate testing and to generate manual test case documentation.


JBehave is a java-based framework designed to encourage collaboration between Developers, QAs, BAs, business and other team members through automated scenarios. Behaviour-driven development (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.


Jemmy is a Java UI testing library. Tests are java programs. Jemmy represents the most natural way to test Java UI - perform the testing right from the Java code. Jemmy is a Java library which provides clear and straightforward API to access Java UI. Tests are then just java programs, which use the API. Having the tests in Java allows to use all the flexibility of high level language to capture test logic and also do any other operations needed to be done from test. Jemmy itself provides all the API necessary to write tests in terms of Java UI components (Swing and AWT). All the Java UI components are covered to the extent it makes sense for UI testing.


Jetif is a regression test framework in pure Java. It provides a simple and flexible architecture for Java unit testing and functional testing, and used for testing in both individual and enterprise software development. It's easy to use, but powerful, and with some important features for enterprise software testing. This project was inspired by JUnit, JTestCase and TestNG. There are several ideas come from JUnit, for example the assertion mechanism and TestListener concept, so it's easy to move to Jetif from JUnit.


JFunc is an extension to the JUnit testing framework to make it easier for use with functional tests. Functional testing (also called integration testing) significantly differs from unit testing in a number of respects. Part of this project is dedicated towards putting together code to address these differences; the other part of this project is putting together methodologies for functional testing. The current features that JFunc has to offer are the following: * Multiple failures * Easing the pains of Manual Suite Construction * Concise, typesafe, suite construction using proxies * Use one test object for a series of tests, rather than the one test instance per test * Test methods can accept arguments * Enhanced Test Runner * Verbose assertions * Pass arguments to tests on the CLI


Welcome to Jiffie, a Java/JNI library which allows Microsoft Internet Explorer to be controlled from Java. The primary purpose of this library is to allow automated regression testing of web applications using a framework like JUnit. Jiffie is designed to be simple to use and easy to extend. It is not designed to be a complete implementation of all of the COM interfaces made available by Internet Explorer. Jiffie is a tool used internally at Tapster Rock, and its development so far has been driven by our requirements. If you need it to do more, feel free to suggest enhancements, or better still, contribute some code!


Jitr is a JUnit Integration Test Runner. It allows your web application integration tests to easily run against a lightweight web container in the same JVM as your tests.


JSystem is an open source framework for writing and running automated system testing projects. The JSystem framework is comprised of the following components: 1. Services Java API - exposes JSystem services 2. JSystem Drivers- Java modules used to interfaces with devices and applications in the system under test. 3. JRunner - GUI application interface used for creating and running tests scenarios. 4. JSystem Agent - Execution engine used to run scenarios on a distributed setup. 5. JSystem Eclipse plug-in - accelerates the development environment setup and enforces JSystem conventions.


JWebUnit is a Java framework that facilitates creation of acceptance tests for web applications. It evolved from a project where we were using JUnit to create acceptance tests. Also, we can have different testing engines. Currently, only HtmlUnit plugin is ready. As the tests were being written, they were continuously refactored to remove duplication and other bad smells in the test code. JWebUnit is the result of these refactorings. JWebUnit provides a high-level API for navigating a web application combined with a set of assertions to verify the application's correctness. This includes navigation via links, form entry and submission, validation of table contents, and other typical business web application features. This code try to stay independent of the libraries behind the scenes. The simple navigation methods and ready-to-use assertions allow for more rapid test creation than using only JUnit and HtmlUnit. And if you want to switch from HtmlUnit to the other soon available plugins, no need to rewrite your tests.


Latka is a functional (end-to-end) testing tool. It is implemented in Java, and uses an XML syntax to define a series of HTTP (or HTTPS) requests and a set of validations used to verify that the request was processed correctly.

Linux Desktop Testing Project

GNU/Linux Desktop Testing Project (GNU/LDTP) is aimed at producing high quality test automation framework and cutting-edge tools that can be used to test GNU/Linux Desktop and improve it. It uses the Accessibility libraries to poke through the application's user interface. The framework also has tools to record test-cases based on user-selection on the application. GNU/LDTP core framework uses Appmap and the recorded test-cases to test an application and gives the status of each test-case as output. As of now, GNU/LDTP can test any GNOME application which are accessibility enabled, Mozilla,, any Java application (should have a UI based on swing) and KDE 4.0 applications based on QT 4.0 (based on the press releases by KDE).


MActor is an extensible integration test tool. It can facilitate tests of any XML-based integration. Adapters for TIBCO Rendezvous, HTTP, SOAP, file system and IBM MQSeries are currently included. Tests are specified in XML using the Test Specification Language, and input data to the tests are specified in HTML (in a similar manner as utilized in the FitNesse testing Framework). Messages that are published from the tests are typically constructed based on template messages where the values of some elements/attributes are replaces using XPath, but a number of other approaches are possible


MaxQ is a web functional testing tool MaxQ records you using a web site. It turns the links you click on and any other input into a Python script that you can play back at any time. You might use it to: * Check that your web site still works (regression test). * Check that your web site is producing valid HTML (using JTidy). * Automatically extract information from, or take some action on, someones else's web site.


Molybdenum is a test tool for web applications. It simulates user interactions in the browser and comes as a Firefox Extension.


Develop test-first style or just test against regressions: MozUnit provides framework, test runner, source browser, and API hooks for personalized reports. MozUnit is part of MozLab, a suite of tools and libraries for developers of AJAX and Mozilla applications, packaged as a Firefox extension.

NTAF (NHN Test Automation Framework)

NTAF (NHN Test Automation Framework) is a framework for end-to-end testing and acceptance test-driven development (ATDD).


P.A.M.I.E. - stands for Python Automated Module For I.E. Pamie's main use is for testing web sites by which you automate the Internet Explorer client using the Pamie scripting language. PAMIE is not a record playback engine! Pamie allows you to automate I.E. by manipulating I.E.'s Document Object Model via COM. This Free tool is for use by Quality Assurance Engineers and Developers.


PyConcordion is a Python port of Concordion. That is : * Write your specification in HTML with Concordion instrumentation * Write your fixture in Python just like you would write a fixture in Java * Run your tests either individually or with the folder runner * Look at the Concordion report


Pywinauto is a python package that allows you to automate the Windows GUI. Very easy to get started, and quite powerful.


This tool was developed specifically for testing products running across a wide variety of hardware and software platforms. Since it is completely written in Java, any machine capable of supporting a Java Virtual Machine (JVM) can be used. The QAT tool can be divided into two main sections, the Agent, responsible for actually running each test or group of tests, and the Harness, which is responsible for test selection, management, result and agent co-ordination. All that is required to run a test on a given machine, is an Agent running in a compatible JVM.


QMTest is a cost-effective general purpose testing solution that can be used to implement a robust, easy-to-use testing process. QMTest runs on Windows and on most UNIX-like operating systems including GNU/Linux. QMTest's extensible architecture allows it to handle a wide range of application domains: everything from compilers to graphical user interfaces to web-based applications. QMTest can easily compare test results to known-good baselines, making analyzing test results far simpler. And, because QMTest runs on virtually all operating systems, you can use it with your entire product line.

Robot Framework

Robot Framework is a Python-based keyword-driven test automation framework for acceptance level testing and acceptance test-driven development (ATDD). It has an easy-to-use tabular syntax for creating test cases and its testing capabilities can be extended by test libraries implemented either with Python or Java. Users can also create new keywords from existing ones using the same simple syntax that is used for creating test cases.

Sahi - Web Automation and Test Tool

Sahi is an automation and testing tool for web applications, with the facility to record and playback scripts. Developed in java and javascript, this tool uses simple javascript to execute events on the browser. Features include: * in-browser controls * intelligent recorder * text based scripts * ant support for playback of suites of tests * multi threaded playback * HTTP and HTTPS support * AJAX support Sahi runs as a proxy server and the browser needs to use the sahi server as its proxy. Sahi then injects javascript so that it can access elements in the webpage. This makes the tool independent of the website/ web application.


Selenium is a test tool for web applications. The tests are written as HTML tables and can be run directly in most modern web browsers. Selenium can be deployed on Windows, Linux, and Macintosh.


soapUI is a free and open source desktop application for inspecting, invoking, developing, simulating/mocking and functional, load and compliance testing of web services over HTTP.

Software Testing Automation Framework

The Software Testing Automation Framework (STAF) is an open source, multi-platform, multi-language framework designed around the idea of reusable components, called services (such as process invocation, resource management, logging, and monitoring).


Solex is a free open source Web application testing tool built as a plug-in for the Eclipse IDE. It provides functions to record a client session, adjust it according to various parameters and replay it later typically in order to ensure non regression of the application's behaviour


Spectacular is an Acceptance Test Driven Development (ATDD) / Behavior Driven Development (BDD) tool that aggregates several different types of testing frameworks into 1, and it also introduces the idea of Executable Use Cases.


Spinach is a high-level BDD framework that leverages the expressive Gherkin language (used by Cucumber) to help you define executable specifications of your application or library's acceptance criteria.


Sprajax is an open source black box security scanner used to assess the security of AJAX-enabled applications. By detecting the specific AJAX frameworks in use, Sprajax is able to better formulate test requests and identify potential vulnerabilities.


Snowday is a formatter for RSpec


SystiN stands for System Testing in .Net. This is a port of the popular Systir program. Systin will allow for an abstraction of Test Case specification and Test Case automation execution.


Systir stands for System Testing In Ruby. This doesn't mean "system testing of Ruby code"; rather, it means we used Ruby to create a tool for helping you automate your system tests. In short, Systir allows you to write system-level tests in a "domain language"; that is, a custom language that pertains to your target software functionality and its own particular constructs.


tclwebtest is a tool to write automated tests for web applications. It provides a simple API for issuing http requests, dealing with the result and assume specific response values, while taking care of the details such as redirects and cookies. It has some basic html parsing functionality, to provide access to elements of the result html page that are needed for testing (mainly links and forms).

Tellurium Automated Testing Framework

The Tellurium Automated Testing Framework (Tellurium), formally known as the Abstract Object based Selenium Test framework (AOST), is a test framework built on top of the Selenium test framework and it abstracts UI components to Java objects and does object to locator mapping (OLM) automatically at run time so that you can define UI objects simply by their attributes and write your selenium tests just like writing Java tests.


TestNG is a testing framework inspired from JUnit and NUnit but introducing some new functionalities that make it more powerful and easier to use, such as: * JDK 5 Annotations (JDK 1.4 is also supported with JavaDoc annotations). * Flexible test configuration. * Support for data-driven testing (with @DataProvider). * Support for parameters. * Allows distribution of tests on slave machines. * Powerful execution model (no more TestSuite). * Supported by a variety of tools and plug-ins (Eclipse, IDEA, Maven, etc...). * Embeds BeanShell for further flexibility. * Default JDK functions for runtime and logging (no dependencies). * Dependent methods for application server testing. TestNG is designed to cover all categories of tests: unit, functional, end-to-end, integration, etc...


TestPlan is an automated testing tool for testing interactive web systems. It offers these features: * Testing web pages via a Firefox or Internet Explorer, or a display-less backend * Reporting for status feedback on an entire test suite * Metrics for page responses and availability * Email and FTP for full web application testing * Unified syntax for Email, Text, HTML, CSV, and XML data * Advanced tracing for locating overnight errors * High-level specialized testing language suitable for non-developers * JavaScript and dynamic page testing


As the name suggests, TextTest works via comparing plain text logged by programs with a previous 'gold standard' version of that text. This is in contrast to most acceptance testing frameworks on offer today, which generally use some form of hand-written 'assertions' by the test writer that call into an application API.


Thucydides is an open source library that lets you use WebDriver/Selenium 2 to write better acceptance tests.


Trinidad is an in-process test runner for FitNesse tests. Here's what you can do with it: * run fitnesse fit and slim tests without starting the server as part of your build * run fitnesse tests from JUnit within your IDE * debug and troubleshoot fitnesse fixtures in-process as if you were working with unit tests * easily include fitnesse acceptance tests into your build (through JUnit) * easily run tests in transactions and roll back after each test (with Spring) * execute fitnesse tests from maven


UISpec is a Behavior Driven Development framework for the iPhone that provides a full automated testing solution that drives the actual iPhone UI. It is modeled after the very popular RSpec for Ruby. To make finding specific views in the iPhone UI easy, UISpec includes a very powerful view traversal DSL called UIQuery. Not only can you easily traverse the view heirarchy, you can also interact with the views you find.


UISpec4J is an Open Source functional and/or unit testing library for Swing-based Java applications, built on top of the JUnit test harness. If you are writing a Swing application, you will appreciate UISpec4J above all for its simplicity: UISpec4J's APIs are designed to hide as much as possible the complexity of Swing, resulting in easy to write and easy to read test scripts. This is especially true when comparing UISpec4J tests with those produced using Swing or low-level, event-based testing libraries.


Watij (pronounced wattage) stands for Web Application Testing in Java. Watij is a pure Java API created to allow for the automation of web applications. Based on the simplicity of Watir and enhanced by the power of Java, Watij automates functional testing of web applications through a real browser. Currently Watij supports automating Internet Explorer on Windows only. Future plans are in place to support others like Mozilla


Inspired by Watir development of WatiN started to make a similar kind of Web Application Testing possible for the .Net languages. Since then WatiN has grown into an easy to use, feature rich and stable framework. WatiN is developed in C# and aims to bring you an easy way to automate tests with Internet Explorer. WatiN Feature List: * Automates all major HTML elements * Find elements by multiple attributes * Supports AJAX website testing * Supports frames (cross domain) and iframes * Supports popup dialogs like alert, confirm, login etc.. * Supports HTML dialogs (modal and modeless) * A basic (extensible) logging mechanism * Works with Internet Explorer 6 and Internet Explorer 7


Watir (Web Application Testing in Ruby) is a functional testing tool for web applications. It supports tests executed at the web browser layer by driving a web browser and interacting with objects on a web page. It uses the Ruby scripting language.


WebInject is a free tool for automated testing of web applications and web services. It can be used to test individual system components that have HTTP interfaces (JSP, ASP, CGI, PHP, Servlets, HTML Forms, XML/SOAP Web Services, etc), and can be used as a test harness to create a suite of [HTTP level] automated functional, acceptance, and regression tests. A test harness, also referred to as a test driver or a test framework, allows you to run many test cases and collect/report your results. WebInject offers real-time results display and may also be used for monitoring system response times. WebInject can be used as a complete test framework that is controlled by the WebInject User Interface (GUI). Optionally, it can be used as a standalone test runner (text/console application) which can be integrated and called from other test frameworks or applications.


WET is a opensource web automation testing tool which uses Watir as the library to drive web pages. You dont have to download / install Watir separately or know anything about Watir. Watir is the library that WET uses and it is automatically installed for you. WET drives an IE Browser directly and so the automated testing done using WET is equivalent to how a user would drive the web pages. Using WET, you can perform all the operations required for testing web applications - like automatically clicking a link, entering text in a textfield, clicking a button etc. WET allows you to perform various checks as a part of the testing process by using Checkpoints

Windmill Testing Framework

Windmill is a web testing framework intended for complete automation of user interface testing, with strong test debugging capabilities. The first goal of Windmill is to make test writing easier, portable and sustainable. Test writing and debugging is an interactive process and requires an architecture that allows for large amounts of flexibility and back-and-forth communication.