| Developer(s) | ThoughtWorks |
|---|---|
| Stable release | |
| Repository | |
| Written in | Go |
| Operating system | Platform-independent |
| Type | Test automation tool |
| License | Apache License 2.0 |
| Website | gauge |
Gauge is a light weight cross-platform test automation tool. It uses markdown to author test cases and scenarios. Its modular architecture makes it flexible and scalable.
Gauge specifications [2] are written in the business language. For example,
Find movies playing near me=========================== The System Under Test in this example is a web application to find and book movie tickets Search for movies-----------------*Specify location as "Bangalore" *Search for movie "Star Wars" *Verify that "INOX" is playing "Star Wars" at "7:30 pm" Book movie ticket-----------------*Sign up with email address <user@example.com> *Complete the verification *Select location as "Bangalore", the movie "Star Wars" and "3" seats *Confirm and pay *Verify the "e-ticket" has been sent to the registered email. This Gauge specification describes a feature of the System Under Test. The scenarios [3] Search for movies and Book movie ticket represent a flow in this specification. Steps [4] are executable parts of a specification.
Specifications in Markdown abstracts code behind the steps.
For example, the step Specify location as "Bangalore" implementation in Java would look like
// This Method can be written in any java class as long as it is in classpath.publicclassStepImplementation{@Step("Specify location as <location>")publicvoidhelloWorld(Stringlocation){// Step implementation}}Gauge has Support for writing test code in:
The Community contributed language runners are:
Gauge tests can be executed from the command line [5] or the supported IDEs. [6]
The default command gauge specs run the tests sequentially.
The command gauge -p specs will execute the tests in Parallel.
Gauge gives comprehensive test reports [7] that provides the required details of a given run.
Gauge's IDE support [6] helps to write and maintain the test suite.
In engineering and its various subdisciplines, acceptance testing is a test conducted to determine if the requirements of a specification or contract are met. It may involve chemical tests, physical tests, or performance tests.
A Java virtual machine (JVM) is a virtual machine that enables a computer to run Java programs as well as programs written in other languages that are also compiled to Java bytecode. The JVM is detailed by a specification that formally describes what is required in a JVM implementation. Having a specification ensures interoperability of Java programs across different implementations so that program authors using the Java Development Kit (JDK) need not worry about idiosyncrasies of the underlying hardware platform.
Software testing is the act of checking whether software satisfies expectations.
Unit testing, a.k.a. component or module testing, is a form of software testing by which isolated source code is tested to validate expected behavior.
A JAR file is a package file format typically used to aggregate many Java class files and associated metadata and resources into one file for distribution.
The Data Distribution Service (DDS) for real-time systems is an Object Management Group (OMG) machine-to-machine standard that aims to enable dependable, high-performance, interoperable, real-time, scalable data exchanges using a publish–subscribe pattern.
Markdown is a lightweight markup language for creating formatted text using a plain-text editor. John Gruber created Markdown in 2004 as an easy to read markup language. Markdown is widely used for blogging and instant messaging, and also used elsewhere in online forums, collaborative software, documentation pages, and readme files.
BMS is a file format for rhythm games developed by Urao Yane in 1998. The format was originally developed for BM98, though the term BMS is now widely used to describe the Beatmania-esque music data system in general.
Behavior-driven development (BDD) involves naming software tests using domain language to describe the behavior of the code.
In computer programming, a programming language specification is a documentation artifact that defines a programming language so that users and implementors can agree on what programs in that language mean. Specifications are typically detailed and formal, and primarily used by implementors, with users referring to them in case of ambiguity; the C++ specification is frequently cited by users, for instance, due to the complexity. Related documentation includes a programming language reference, which is intended expressly for users, and a programming language rationale, which explains why the specification is written as it is; these are typically more informal than a specification.
Jakarta Persistence, also known as JPA is a Jakarta EE application programming interface specification that describes the management of relational data in enterprise Java applications.
A functional specification in systems engineering and software development is a document that specifies the functions that a system or component must perform.
A specification often refers to a set of documented requirements to be satisfied by a material, design, product, or service. A specification is often a type of technical standard.
XPath is an expression language designed to support the query or transformation of XML documents. It was defined by the World Wide Web Consortium (W3C) in 1999, and can be used to compute values from the content of an XML document. Support for XPath exists in applications that support XML, such as web browsers, and many programming languages.
The ANSI/ISO C Specification Language (ACSL) is a specification language for C programs, using Hoare style pre- and postconditions and invariants, that follows the design by contract paradigm. Specifications are written as C annotation comments to the C program, which hence can be compiled with any C compiler.
Concordion is a specification by example framework originally developed by David Peterson, and now maintained by a team of contributors, led by Nigel Charman.
Cucumber is a software tool that supports behavior-driven development (BDD). Central to the Cucumber BDD approach is its ordinary language parser called Gherkin. It allows expected software behaviors to be specified in a logical language that customers can understand. As such, Cucumber allows the execution of feature documentation written in business-facing text. It is often used for testing other software. It runs automated acceptance tests written in a behavior-driven development (BDD) style.
Specification by example (SBE) is a collaborative approach to defining requirements and business-oriented functional tests for software products based on capturing and illustrating requirements using realistic examples instead of abstract statements. It is applied in the context of agile software development methods, in particular behavior-driven development. This approach is particularly successful for managing requirements and functional tests on large-scale projects of significant domain and organisational complexity.
Web IDL is an interface description language (IDL) format for describing APIs that are intended to be implemented in web browsers. Its adoption was motivated by the desire to improve the interoperability of web programming interfaces by specifying how languages such as ECMAScript should bind these interfaces.
Acceptance test–driven development (ATDD) is a development methodology based on communication between the business customers, the developers, and the testers. ATDD encompasses many of the same practices as specification by example (SBE), behavior-driven development (BDD), example-driven development (EDD), and support-driven development also called story test–driven development (SDD). All these processes aid developers and testers in understanding the customer's needs prior to implementation and allow customers to be able to converse in their own domain language.