cucumber-js-documentation

Feature: a feature
  Scenario: a failing scenario
    When I divide 10 by 0
    Then the result is 9

Feature: a feature
  Scenario: a failing scenario
    When I divide 10 by 0
    Then the result is 9

When I add 4 and 5
Then the result is 9

Feature: Asynchronous step definition body
  Scenario: Waiting for an asynchronous step to call back
    When an asynchronous step passes
    Then a step passes

Feature: some feature

Scenario: I've declared one step and it is passing
    Given This step is passing

var cucumberSteps = function() {
  this.Given(/^This step is passing$/, function(callback) { callback(); });
};
module.exports = cucumberSteps;

var hooks = function () {
  this.Before(function(scenario, callback) {
    scenario.attach(new Buffer([100, 97, 116, 97]), 'image/png');
    callback();
  });
};

module.exports = hooks;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "I've declared one step and it is passing",
        "id": "some-feature;i've-declared-one-step-and-it-is-passing",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "keyword": "Before ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {},
            "embeddings": [
              {
                "mime_type": "image/png",
                "data": "ZGF0YQ=="
              }
            ]
          },
          {
            "name": "This step is passing",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          }
        ]
      }
    ]
  }
]

Feature: some feature

Scenario: I've declared one step and it is passing
    Given This step is passing

var cucumberSteps = function() {
  this.Given(/^This step is passing$/, function(callback) { callback(); });
};
module.exports = cucumberSteps;

var hooks = function () {
  this.Before(function(scenario, callback) {
    var Stream = require('stream');
    var versionParts = /v(\d+)\.(\d+)\.(\d+)/.exec(process.version);
    var major = parseInt(versionParts[0], 10);
    var minor = parseInt(versionParts[1], 10);

    if (major > 0 || minor >= 10) {
      var stream = new Stream.Readable();
      stream._read = function() {};
      stream.push(new Buffer([100, 97, 116, 97]));
      stream.push(null);

      scenario.attach(stream, 'image/png', function(error) {
        callback(error);
      });
    }
    else {
      scenario.attach(new Buffer([100, 97, 116, 97]), 'image/png');
      callback();
    }
  });
};

module.exports = hooks;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "I've declared one step and it is passing",
        "id": "some-feature;i've-declared-one-step-and-it-is-passing",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "keyword": "Before ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {},
            "embeddings": [
              {
                "mime_type": "image/png",
                "data": "ZGF0YQ=="
              }
            ]
          },
          {
            "name": "This step is passing",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          }
        ]
      }
    ]
  }
]

Feature: some feature

Scenario: I've declared one step and it is passing
    Given This step is passing

var cucumberSteps = function() {
  this.Given(/^This step is passing$/, function(callback) { callback(); });
};
module.exports = cucumberSteps;

var hooks = function () {
  this.Around(function(scenario, runScenario) {
    scenario.attach("text");

    runScenario(function(scenario, callback) {
      callback();
    });
  });
};

module.exports = hooks;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "I've declared one step and it is passing",
        "id": "some-feature;i've-declared-one-step-and-it-is-passing",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "keyword": "Around ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {},
            "embeddings": [
              {
                "mime_type": "text/plain",
                "data": "dGV4dA=="
              }
            ]
          },
          {
            "name": "This step is passing",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          },
          {
            "keyword": "Around ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          }
        ]
      }
    ]
  }
]

Feature: some feature

Scenario: I've declared one step and it is passing
    Given This step is passing

var cucumberSteps = function() {
  this.Given(/^This step is passing$/, function(callback) { callback(); });
};
module.exports = cucumberSteps;

var hooks = function () {
  this.Around(function(scenario, runScenario) {
    runScenario(function(callback) {
      scenario.attach("text");
      callback();
    });
  });
};

module.exports = hooks;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "I've declared one step and it is passing",
        "id": "some-feature;i've-declared-one-step-and-it-is-passing",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "keyword": "Around ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          },
          {
            "name": "This step is passing",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          },
          {
            "keyword": "Around ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {},
            "embeddings": [
              {
                "mime_type": "text/plain",
                "data": "dGV4dA=="
              }
            ]
          }
        ]
      }
    ]
  }
]

Feature: some feature

Scenario: I've declared one step and it is passing
    Given This step is passing

var cucumberSteps = function() {
  this.Given(/^This step is passing$/, function(callback) { callback(); });
};
module.exports = cucumberSteps;

var hooks = function () {
  this.Before(function(scenario, callback) {
    scenario.attach("text");
    callback();
  });
};

module.exports = hooks;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "I've declared one step and it is passing",
        "id": "some-feature;i've-declared-one-step-and-it-is-passing",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "keyword": "Before ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {},
            "embeddings": [
              {
                "mime_type": "text/plain",
                "data": "dGV4dA=="
              }
            ]
          },
          {
            "name": "This step is passing",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          }
        ]
      }
    ]
  }
]

Feature: some feature

Scenario: I've declared one step and it is passing
    Given This step is passing

var cucumberSteps = function() {
  this.Given(/^This step is passing$/, function(callback) { callback(); });
};
module.exports = cucumberSteps;

var hooks = function () {
  this.After(function(scenario, callback) {
    scenario.attach("text");
    callback();
  });
};

module.exports = hooks;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "I've declared one step and it is passing",
        "id": "some-feature;i've-declared-one-step-and-it-is-passing",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "name": "This step is passing",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          },
          {
            "keyword": "After ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {},
            "embeddings": [
              {
                "mime_type": "text/plain",
                "data": "dGV4dA=="
              }
            ]
          }
        ]
      }
    ]
  }
]

Feature: some feature

Scenario: I've declared one step and it is passing
    Given This step is passing

var cucumberSteps = function() {
  this.Given(/^This step is passing$/, function(callback) {
    var world = this;
    world.scenario.attach("text");
    callback();
  });
};
module.exports = cucumberSteps;

var hooks = function () {
  this.Before(function(scenario, callback) {
    var world = this;
    world.scenario = scenario;
    callback();
  });
};

module.exports = hooks;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "I've declared one step and it is passing",
        "id": "some-feature;i've-declared-one-step-and-it-is-passing",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "keyword": "Before ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          },
          {
            "name": "This step is passing",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {},
            "embeddings": [
              {
                "mime_type": "text/plain",
                "data": "dGV4dA=="
              }
            ]
          }
        ]
      }
    ]
  }
]

Feature: testing scenarios
  Background:
    Given a background step

  Scenario:
    When a scenario step

Feature: testing scenarios
  Background:
    Given a background step

  Scenario:
    When a scenario step

  Scenario:
    When a second scenario step

Feature: some feature
  Scenario:
    When a step is passing

var cucumberSteps = function() {
  this.When(/^a step is passing$/, function(callback) { callback(); });
};
module.exports = cucumberSteps;

.

1 scenario (1 passed)
1 step (1 passed)

Feature: some feature
  Scenario: first scenario
    When a step is passing

  Scenario: second scenario
    When a step does not exist

var cucumberSteps = function() {
  this.When(/^a step is passing$/, function(callback) { callback(); });
};
module.exports = cucumberSteps;

.

1 scenario (1 passed)
1 step (1 passed)

Feature: some feature
  Scenario:
    When a step is undefined

U

1 scenario (1 undefined)
1 step (1 undefined)

You can implement step definitions for undefined steps with these snippets:

this.When(/^a step is undefined$/, function (callback) {
  // Write code here that turns the phrase above into concrete actions
  callback.pending();
});

Feature: some feature
  Scenario:
    When a step is passing

var cucumberSteps = function() {
  this.When(/^a step is passing$/, function(callback) { callback(); });
};
module.exports = cucumberSteps;

.

1 scenario (1 passed)
1 step (1 passed)

Feature: some feature
  Scenario:
    When a step is passing

var cucumberSteps = function() {
  this.When(/^a step is passing$/, function(callback) { callback(); });
};
module.exports = cucumberSteps;

.

1 scenario (1 passed)
1 step (1 passed)

Feature: some feature
  Scenario:
    When a step is failing

var cucumberSteps = function() {
  this.When(/^a step is failing$/, function(callback) { callback("forced error"); });
};
module.exports = cucumberSteps;

F

(::) failed steps (::)

forced error

Failing scenarios:
<current-directory>/features/a.feature:2 # Scenario:

1 scenario (1 failed)
1 step (1 failed)

Feature: some feature
  Scenario:
    When a step is failing

var cucumberSteps = function() {
  this.When(/^a step is failing$/, function(callback) { callback("forced error"); });
};
module.exports = cucumberSteps;

F

(::) failed steps (::)

forced error

Failing scenarios:
<current-directory>/features/a.feature:2 # Scenario:

1 scenario (1 failed)
1 step (1 failed)

Feature: some feature
  Scenario:
    When a step is failing

var cucumberSteps = function() {
  this.When(/^a step is failing$/, function(callback) { callback("forced error"); });
};
module.exports = cucumberSteps;

var hooks = function() {
  this.registerHandler('AfterFeatures', function (event, callback) {
    callback();
  });
};
module.exports = hooks;

F

(::) failed steps (::)

forced error

Failing scenarios:
<current-directory>/features/a.feature:2 # Scenario:

1 scenario (1 failed)
1 step (1 failed)

Feature: Simple flat steps
  In order to execute features
  As cucumber
  I want to run features successfully

  Scenario: Simple flat step
    Given a step passes
    When a step passes
    Then a step passes

Feature: Given, When, Then, And and But step execution
  Scenario: All kinds of steps
    Given a "Given" step passes
    When a "When" step passes
    Then a "Then" step passes

  Scenario: All kinds of steps with And's and But's
    Given a "Given" step passes
    And a "Given" step passes
    But a "Given" step passes
    When a "When" step passes
    And a "When" step passes
    But a "When" step passes
    Then a "Then" step passes
    And a "Then" step passes
    But a "Then" step passes

Feature: Step definition body execution
  Scenario: Step definition body is executed once
    When I call a watched step
    Then the watched step should have been called 1 time

  Scenario: Step definition body is executed several times
    When I call a watched step
    And I call a watched step
    And I call a watched step
    Then the watched step should have been called 3 times

Feature: Steps receiving parameters
  Scenario: Single-parameter step
    When I call a step with "a parameter"
    Then the 1st received parameter should be "a parameter"

  Scenario: Three-parameter step
    When I call a step with "one", "two" and "three"
    Then the 1st received parameter should be "one"
    And the 2nd received parameter should be "two"
    And the 3rd received parameter should be "three"

Feature: Steps receiving a DocString parameter
  Scenario: One-liner DocString parameter
    When I call a step with the following text:
      """
      The cucumber (Cucumis sativus) is a widely cultivated plant in the gourd family Cucurbitaceae.
      """
    Then the 1st received parameter should be "The cucumber (Cucumis sativus) is a widely cultivated plant in the gourd family Cucurbitaceae."

  Scenario: Matching group and one-liner DocString
    When I call a step with "Cucumber" and the following text:
      """
      The cucumber (Cucumis sativus) is a widely cultivated plant in the gourd family Cucurbitaceae.
      """
    Then the 1st received parameter should be "Cucumber"
    And the 2nd received parameter should be "The cucumber (Cucumis sativus) is a widely cultivated plant in the gourd family Cucurbitaceae."

  Scenario: Matching group and multiline DocString
    When I call a step with "Cucumber" and the following text:
      """
      cu·cum·ber |ˈkyoōˌkəmbər|
      noun
        1. a long, green-skinned fruit with watery flesh, usually eaten raw in salads or pickled.
        2. the climbing plant of the gourd family that yields this fruit, native to the Chinese Himalayan region. It is widely cultivated but very rare in the wild. • Cucumis sativus, family Cucurbitaceae.
      """
    Then the 1st received parameter should be "Cucumber"
    And the 2nd received parameter should be:
      """
      cu·cum·ber |ˈkyoōˌkəmbər|
      noun
        1. a long, green-skinned fruit with watery flesh, usually eaten raw in salads or pickled.
        2. the climbing plant of the gourd family that yields this fruit, native to the Chinese Himalayan region. It is widely cultivated but very rare in the wild. • Cucumis sativus, family Cucurbitaceae.
      """

| Cucumber     | Cucumis sativus |
| Burr Gherkin | Cucumis anguria |

{ "Cucumber":"Cucumis sativus", "Burr Gherkin": "Cucumis anguria" }

Feature: some feature

Scenario: I've declared one step and it is passing
    Given This step is passing

var cucumberSteps = function() {
  this.Given(/^This step is passing$/, function(callback) { callback(); });
};
module.exports = cucumberSteps;

var hooks = function () {
  this.Before(function(callback) {
    callback();
  });

  this.After(function(callback) {
    callback();
  });

  this.Around(function(runScenario) {
    runScenario(function(callback) {
      callback();
    });
  });
};

module.exports = hooks;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "I've declared one step and it is passing",
        "id": "some-feature;i've-declared-one-step-and-it-is-passing",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "keyword": "Around ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          },
          {
            "keyword": "Before ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          },
          {
            "name": "This step is passing",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          },
          {
            "keyword": "After ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          },
          {
            "keyword": "Around ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          }
        ]
      }
    ]
  }
]

Feature: some feature

Scenario: I've declared one step and it is passing
    Given This step is passing

var cucumberSteps = function() {
  this.Given(/^This step is passing$/, function(callback) { callback(); });
};
module.exports = cucumberSteps;

var hooks = function () {
  this.Around(function(runScenario) {
    runScenario('Fail', function(callback) { callback(); });
  });
};

module.exports = hooks;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "I've declared one step and it is passing",
        "id": "some-feature;i've-declared-one-step-and-it-is-passing",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "keyword": "Around ",
            "hidden": true,
            "result": {
              "error_message": "<error-message>",
              "duration": "<duration>",
              "status": "failed"
            },
            "match": {}
          },
          {
            "name": "This step is passing",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "status": "skipped"
            },
            "match": {}
          },
          {
            "keyword": "Around ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          }
        ]
      }
    ]
  }
]

Feature: some feature

Scenario: I've declared one step and it is passing
    Given This step is passing

var cucumberSteps = function() {
  this.Given(/^This step is passing$/, function(callback) { callback(); });
};
module.exports = cucumberSteps;

var hooks = function () {
  this.Around(function(runScenario) {
    runScenario.fail();
  });
};

module.exports = hooks;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "I've declared one step and it is passing",
        "id": "some-feature;i've-declared-one-step-and-it-is-passing",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "keyword": "Around ",
            "hidden": true,
            "result": {
              "error_message": "<error-message>",
              "duration": "<duration>",
              "status": "failed"
            },
            "match": {}
          },
          {
            "name": "This step is passing",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "status": "skipped"
            },
            "match": {}
          },
          {
            "keyword": "Around ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          }
        ]
      }
    ]
  }
]

Feature: some feature

Scenario: I've declared one step and it is passing
    Given This step is passing

var cucumberSteps = function() {
  this.Given(/^This step is passing$/, function(callback) { callback(); });
};
module.exports = cucumberSteps;

var hooks = function () {
  this.Around(function(runScenario) {
    // no-op

    runScenario(function(callback) {
      callback('Fail');
    });
  });
};

module.exports = hooks;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "I've declared one step and it is passing",
        "id": "some-feature;i've-declared-one-step-and-it-is-passing",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "keyword": "Around ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          },
          {
            "name": "This step is passing",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          },
          {
            "keyword": "Around ",
            "hidden": true,
            "result": {
              "error_message": "<error-message>",
              "duration": "<duration>",
              "status": "failed"
            },
            "match": {}
          }
        ]
      }
    ]
  }
]

Feature: some feature

Scenario: I've declared one step and it is passing
    Given This step is passing

var cucumberSteps = function() {
  this.Given(/^This step is passing$/, function(callback) { callback(); });
};
module.exports = cucumberSteps;

var hooks = function () {
  this.Around(function(runScenario) {
    // no-op

    runScenario(function(callback) {
      callback.fail();
    });
  });
};

module.exports = hooks;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "I've declared one step and it is passing",
        "id": "some-feature;i've-declared-one-step-and-it-is-passing",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "keyword": "Around ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          },
          {
            "name": "This step is passing",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          },
          {
            "keyword": "Around ",
            "hidden": true,
            "result": {
              "error_message": "<error-message>",
              "duration": "<duration>",
              "status": "failed"
            },
            "match": {}
          }
        ]
      }
    ]
  }
]

Feature: some feature

Scenario: I've declared one step and it is passing
    Given This step is passing

var cucumberSteps = function() {
  this.Given(/^This step is passing$/, function(callback) { callback(); });
};
module.exports = cucumberSteps;

var hooks = function () {
  this.Before(function(callback) {
    callback('Fail');
  });
};

module.exports = hooks;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "I've declared one step and it is passing",
        "id": "some-feature;i've-declared-one-step-and-it-is-passing",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "keyword": "Before ",
            "hidden": true,
            "result": {
              "error_message": "<error-message>",
              "duration": "<duration>",
              "status": "failed"
            },
            "match": {}
          },
          {
            "name": "This step is passing",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "status": "skipped"
            },
            "match": {}
          }
        ]
      }
    ]
  }
]

Feature: some feature

Scenario: I've declared one step and it is passing
    Given This step is passing

var cucumberSteps = function() {
  this.Given(/^This step is passing$/, function(callback) { callback(); });
};
module.exports = cucumberSteps;

var hooks = function () {
  this.Before(function(callback) {
    callback.fail();
  });
};

module.exports = hooks;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "I've declared one step and it is passing",
        "id": "some-feature;i've-declared-one-step-and-it-is-passing",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "keyword": "Before ",
            "hidden": true,
            "result": {
              "error_message": "<error-message>",
              "duration": "<duration>",
              "status": "failed"
            },
            "match": {}
          },
          {
            "name": "This step is passing",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "status": "skipped"
            },
            "match": {}
          }
        ]
      }
    ]
  }
]

Feature: some feature

Scenario: I've declared one step and it is passing
    Given This step is passing

var cucumberSteps = function() {
  this.Given(/^This step is passing$/, function(callback) { callback(); });
};
module.exports = cucumberSteps;

var hooks = function () {
  this.After(function(callback) {
    callback('Fail');
  });
};

module.exports = hooks;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "I've declared one step and it is passing",
        "id": "some-feature;i've-declared-one-step-and-it-is-passing",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "name": "This step is passing",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          },
          {
            "keyword": "After ",
            "hidden": true,
            "result": {
              "error_message": "<error-message>",
              "duration": "<duration>",
              "status": "failed"
            },
            "match": {}
          }
        ]
      }
    ]
  }
]

Feature: some feature

Scenario: I've declared one step and it is passing
    Given This step is passing

var cucumberSteps = function() {
  this.Given(/^This step is passing$/, function(callback) { callback(); });
};
module.exports = cucumberSteps;

var hooks = function () {
  this.After(function(callback) {
    callback.fail();
  });
};

module.exports = hooks;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "I've declared one step and it is passing",
        "id": "some-feature;i've-declared-one-step-and-it-is-passing",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "name": "This step is passing",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          },
          {
            "keyword": "After ",
            "hidden": true,
            "result": {
              "error_message": "<error-message>",
              "duration": "<duration>",
              "status": "failed"
            },
            "match": {}
          }
        ]
      }
    ]
  }
]

Feature: some feature

Scenario: I've declared one step and it is passing
    Given This step is passing

var cucumberSteps = function() {
  this.Given(/^This step is passing$/, function(callback) { callback(); });
};
module.exports = cucumberSteps;

var hooks = function () {
  this.Around(function(scenario, runScenario) {
    runScenario("fail", function(callback) {
      callback();
    });
  });

  this.Around(function(scenario, runScenario) {
    runScenario(function(callback) {
      callback();
    });
  });

  this.Before(function(scenario, callback) {
    callback();
  });

  this.After(function(scenario, callback) {
    callback();
  });
};

module.exports = hooks;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "I've declared one step and it is passing",
        "id": "some-feature;i've-declared-one-step-and-it-is-passing",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "keyword": "Around ",
            "hidden": true,
            "result": {
              "error_message": "<error-message>",
              "duration": "<duration>",
              "status": "failed"
            },
            "match": {}
          },
          {
            "keyword": "Around ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          },
          {
            "keyword": "Before ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          },
          {
            "name": "This step is passing",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "status": "skipped"
            },
            "match": {}
          },
          {
            "keyword": "After ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          },
          {
            "keyword": "Around ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          },
          {
            "keyword": "Around ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          }
        ]
      }
    ]
  }
]

Feature: some feature

Scenario: I've declared one step and it is passing
    Given This step is passing

var cucumberSteps = function() {
  this.Given(/^This step is passing$/, function(callback) { callback(); });
};
module.exports = cucumberSteps;

var WorldConstructor = function WorldConstructor(callback) {
  var world = {
    isWorld: function() { return true; }
  };

  callback(world); // tell Cucumber we're finished and to use our world object instead of 'this'
};

module.exports.World = WorldConstructor;

var hooks = function () {
  this.World = require("../support/world.js").World;

  this.Before(function(callback) {
    var world = this;

    if (!world.isWorld())
      callback("Expected this to be world");
    else
      callback();
  });

  this.After(function(callback) {
    var world = this;

    if (!world.isWorld())
      callback("Expected this to be world");
    else
      callback();
  });

  this.Around(function(runScenario) {
    var world = this;
    var error;

    if (!world.isWorld())
      error = "Expected this to be world";
    else
      error = null;

    runScenario(error, function(callback) {
      var world = this;
      var error;

      if (!world.isWorld())
        error = "Expected this to be world";
      else
        error = null;

      callback(error);
    });
  });
};

module.exports = hooks;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "I've declared one step and it is passing",
        "id": "some-feature;i've-declared-one-step-and-it-is-passing",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "keyword": "Around ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          },
          {
            "keyword": "Before ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          },
          {
            "name": "This step is passing",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          },
          {
            "keyword": "After ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          },
          {
            "keyword": "Around ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          }
        ]
      }
    ]
  }
]

Feature: some feature

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature"
  }
]

Feature: some feature

Scenario: I havn't done anything yet

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "I havn't done anything yet",
        "id": "some-feature;i-havn't-done-anything-yet",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario"
      }
    ]
  }
]

Feature: some feature

Scenario: I've declared one step but not yet defined it
    Given I have not defined this step

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri":"<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "I've declared one step but not yet defined it",
        "id": "some-feature;i've-declared-one-step-but-not-yet-defined-it",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "name":"I have not defined this step",
            "line":4,
            "keyword":"Given ",
            "result":
            {
              "status":"undefined"
            },
            "match": {}
          }
        ]
      }
    ]
  }
]

Feature: some feature

Scenario: One pending step and two following steps which will be skipped
    Given This step is undefined
    Then this step should be skipped

var cucumberSteps = function() {
  this.Then(/^this step should be skipped$/, function(callback) { callback(); });
};
module.exports = cucumberSteps;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "One pending step and two following steps which will be skipped",
        "id": "some-feature;one-pending-step-and-two-following-steps-which-will-be-skipped",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "name": "This step is undefined",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "status": "undefined"
            },
            "match": {
            }
          },
          {
            "name": "this step should be skipped",
            "line": 5,
            "keyword": "Then ",
            "result": {
              "status": "skipped"
            },
            "match": {
            }
          }
        ]
      }
    ]
  }
]

Feature: some feature

Scenario: I've declared one step which is pending
    Given This step is pending

var cucumberSteps = function() {
  this.Given(/^This step is pending$/, function(callback) { callback.pending(); });
};
module.exports = cucumberSteps;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri":"<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "I've declared one step which is pending",
        "id": "some-feature;i've-declared-one-step-which-is-pending",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "name": "This step is pending",
            "line": 4,
            "keyword": "Given ",
            "result": { "status": "pending" },
            "match": {
            }
          }
        ]
      }
    ]
  }
]

Feature: some feature

Scenario: I've declared one step but it is failing
    Given This step is failing

var cucumberSteps = function() {
  this.Given(/^This step is failing$/, function(callback) { callback.fail(); });
};
module.exports = cucumberSteps;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri":"<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "I've declared one step but it is failing",
        "id": "some-feature;i've-declared-one-step-but-it-is-failing",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "name": "This step is failing",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "error_message": "<error-message>",
              "duration": "<duration>",
              "status": "failed"
            },
            "match": {
            }
          }
        ]
      }
    ]
  }
]

Feature: some feature

Scenario: I've declared one step which passes
    Given This step is passing

var cucumberSteps = function() {
  this.Given(/^This step is passing$/, function(callback) { callback(); });
};
module.exports = cucumberSteps;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri":"<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "I've declared one step which passes",
        "id": "some-feature;i've-declared-one-step-which-passes",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "name": "This step is passing",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {
            }
          }
        ]
      }
    ]
  }
]

Feature: some feature

Scenario: I've declared one step which is passing, one pending and one failing.
    Given This step is passing
    And This step is pending
    And This step fails but will be skipped

var cucumberSteps = function() {
  this.Given(/^This step is passing$/, function(callback) { callback(); });
  this.Given(/^This step is pending$/, function(callback) { callback.pending(); });
  this.Given(/^This step fails but will be skipped$/, function(callback) { callback.fail(); });
};
module.exports = cucumberSteps;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "I've declared one step which is passing, one pending and one failing.",
        "id": "some-feature;i've-declared-one-step-which-is-passing,-one-pending-and-one-failing.",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "name": "This step is passing",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          },
          {
            "name": "This step is pending",
            "line": 5,
            "keyword": "And ",
            "result": {
              "status": "pending"
            },
            "match": {}
          },
          {
            "name": "This step fails but will be skipped",
            "line": 6,
            "keyword": "And ",
            "result": {
              "status": "skipped"
            },
            "match": {}
          }
        ]
      }
    ]
  }
]

Feature: some feature

Scenario: I've declared one step which is passing, one pending and one failing.
    Given This step is pending
    And This step is passing but will be skipped
    And This step fails but will be skipped

var cucumberSteps = function() {
  this.Given(/^This step is pending$/, function(callback) { callback.pending(); });
  this.Given(/^This step is passing but will be skipped$/, function(callback) { callback(); });
  this.Given(/^This step fails but will be skipped$/, function(callback) { callback.fail(); });
};
module.exports = cucumberSteps;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "I've declared one step which is passing, one pending and one failing.",
        "id": "some-feature;i've-declared-one-step-which-is-passing,-one-pending-and-one-failing.",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "name": "This step is pending",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "status": "pending"
            },
            "match": {
            }
          },
          {
            "name": "This step is passing but will be skipped",
            "line": 5,
            "keyword": "And ",
            "result": {
              "status": "skipped"
            },
            "match": {
            }
          },
          {
            "name": "This step fails but will be skipped",
            "line": 6,
            "keyword": "And ",
            "result": {
              "status": "skipped"
            },
            "match": {
            }
          }
        ]
      }
    ]
  }
]

Feature: one passes one fails

Scenario: This one passes
  Given This step is passing
Scenario: This one fails
  Given This step is failing

var cucumberSteps = function() {
  this.Given(/^This step is passing$/, function(callback) { callback(); });
  this.Given(/^This step is failing$/, function(callback) { callback.fail(); });
};
module.exports = cucumberSteps;

[
  {
    "id": "one-passes-one-fails",
    "name": "one passes one fails",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "This one passes",
        "id": "one-passes-one-fails;this-one-passes",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "name": "This step is passing",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {
            }
          }
        ]
      },
      {
        "name": "This one fails",
        "id": "one-passes-one-fails;this-one-fails",
        "line": 5,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "name": "This step is failing",
            "line": 6,
            "keyword": "Given ",
            "result": {
              "error_message": "<error-message>",
              "duration": "<duration>",
              "status": "failed"
            },
            "match": {
            }
          }
        ]
      }
    ]
  }
]

Feature: feature a

Scenario: This is the first feature
    Given This step is passing

Feature: feature b

Scenario: This is the second feature
    Given This step is passing

Feature: feature c

Scenario: This is the third feature
    Given This step is passing

var cucumberSteps = function() {
  this.Given(/^This step is passing$/, function(callback) { callback(); });
};
module.exports = cucumberSteps;

[
  {
    "id": "feature-a",
    "name": "feature a",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "This is the first feature",
        "id": "feature-a;this-is-the-first-feature",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "name": "This step is passing",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {
            }
          }
        ]
      }
    ]
  },
  {
    "id": "feature-b",
    "name": "feature b",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/b.feature",
    "elements": [
      {
        "name": "This is the second feature",
        "id": "feature-b;this-is-the-second-feature",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "name": "This step is passing",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          }
        ]
      }
    ]
  },
  {
    "id": "feature-c",
    "name": "feature c",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/c.feature",
    "elements": [
      {
        "name": "This is the third feature",
        "id": "feature-c;this-is-the-third-feature",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "name": "This step is passing",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          }
        ]
      }
    ]
  }
]

Feature: feature a

Scenario: This is the feature a scenario one
    Given This step is passing

Scenario: This is the feature a scenario two
    Given This step is passing

Scenario: This is the feature a scenario three
    Given This step is passing

Feature: feature b

Scenario: This is the feature b scenario one
    Given This step is passing

Scenario: This is the feature b scenario two
    Given This step is passing

Scenario: This is the feature b scenario three
    Given This step is passing

Feature: feature c

Scenario: This is the feature c scenario one
    Given This step is passing

Scenario: This is the feature c scenario two
    Given This step is passing

Scenario: This is the feature c scenario three
    Given This step is passing

var cucumberSteps = function() {
  this.Given(/^This step is passing$/, function(callback) { callback(); });
};
module.exports = cucumberSteps;

[
  {
    "id": "feature-a",
    "name": "feature a",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "This is the feature a scenario one",
        "id": "feature-a;this-is-the-feature-a-scenario-one",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "name": "This step is passing",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {
            }
          }
        ]
      },
      {
        "name": "This is the feature a scenario two",
        "id": "feature-a;this-is-the-feature-a-scenario-two",
        "line": 6,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "name": "This step is passing",
            "line": 7,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          }
        ]
      },
      {
        "name": "This is the feature a scenario three",
        "id": "feature-a;this-is-the-feature-a-scenario-three",
        "line": 9,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "name": "This step is passing",
            "line": 10,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          }
        ]
      }
    ]
  },
  {
    "id": "feature-b",
    "name": "feature b",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/b.feature",
    "elements": [
      {
        "name": "This is the feature b scenario one",
        "id": "feature-b;this-is-the-feature-b-scenario-one",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "name": "This step is passing",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          }
        ]
      },
      {
        "name": "This is the feature b scenario two",
        "id": "feature-b;this-is-the-feature-b-scenario-two",
        "line": 6,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "name": "This step is passing",
            "line": 7,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          }
        ]
      },
      {
        "name": "This is the feature b scenario three",
        "id": "feature-b;this-is-the-feature-b-scenario-three",
        "line": 9,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "name": "This step is passing",
            "line": 10,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          }
        ]
      }
    ]
  },
  {
    "id": "feature-c",
    "name": "feature c",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/c.feature",
    "elements": [
      {
        "name": "This is the feature c scenario one",
        "id": "feature-c;this-is-the-feature-c-scenario-one",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "name": "This step is passing",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          }
        ]
      },
      {
        "name": "This is the feature c scenario two",
        "id": "feature-c;this-is-the-feature-c-scenario-two",
        "line": 6,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "name": "This step is passing",
            "line": 7,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          }
        ]
      },
      {
        "name": "This is the feature c scenario three",
        "id": "feature-c;this-is-the-feature-c-scenario-three",
        "line": 9,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "name": "This step is passing",
            "line": 10,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          }
        ]
      }
    ]
  }
]

Feature: some feature

Background:
  Given This applies to all scenarios

var cucumberSteps = function() {
  this.Given(/^This applies to all scenarios$/, function(callback) { callback(); });
};
module.exports = cucumberSteps;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "",
        "keyword": "Background",
        "description": "",
        "type": "background",
        "line": 3,
        "steps": [
          {
            "name": "This applies to all scenarios",
            "line": 4,
            "keyword": "Given "
          }
        ]
      }
    ]
  }
]

Feature: some feature

Background:
    Given This applies to all scenarios but fails

var cucumberSteps = function() {
  this.Given(/^This applies to all scenarios but fails$/, function(callback) { callback.fail(); });
};
module.exports = cucumberSteps;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "",
        "keyword": "Background",
        "description": "",
        "type": "background",
        "line": 3,
        "steps": [
          {
            "name": "This applies to all scenarios but fails",
            "line": 4,
            "keyword": "Given "
          }
        ]
      }
    ]
  }
]

Feature: some feature

Scenario: Scenario with DocString
  Given we have this DocString:
  """
  This is a DocString
  """

var cucumberSteps = function() {
  this.Given(/^we have this DocString:$/, function(string, callback) { callback(); });
};
module.exports = cucumberSteps;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "Scenario with DocString",
        "id": "some-feature;scenario-with-docstring",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "name": "we have this DocString:",
            "line": 4,
            "keyword": "Given ",
            "doc_string":
              {
                "value": "This is a DocString",
                "line": 5,
                "content_type": ""
              },
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          }
        ]
      }
    ]
  }
]

Feature: some feature

Background: Background with DocString
  Given we have this DocString:
  """
  This is a DocString
  """

var cucumberSteps = function() {
  this.Given(/^we have this DocString:$/, function(string, callback) { callback(); });
};
module.exports = cucumberSteps;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "Background with DocString",
        "keyword": "Background",
        "description": "",
        "type": "background",
        "line": 3,
        "steps": [
          {
            "name": "we have this DocString:",
            "line": 4,
            "keyword": "Given ",
            "doc_string": {
              "value": "This is a DocString",
              "line": 5,
              "content_type": ""
            }
          }
        ]
      }
    ]
  }
]

@alpha @beta @gamma
Feature: some feature

Scenario: This scenario has no tags
    Given This step is passing

var cucumberSteps = function() {
  this.Given(/^This step is passing$/, function(callback) { callback(); });
};
module.exports = cucumberSteps;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 2,
    "keyword": "Feature",
    "tags": [
      {
        "name": "@alpha",
        "line": 1
      },
      {
        "name": "@beta",
        "line": 1
      },
      {
        "name": "@gamma",
        "line": 1
      }
    ],
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "This scenario has no tags",
        "id": "some-feature;this-scenario-has-no-tags",
        "line": 4,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "name": "This step is passing",
            "line": 5,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          }
        ]
      }
    ]
  }
]

Feature: some feature

@one @two @three
Scenario: This scenario has tags
    Given This step is passing

var cucumberSteps = function() {
  this.Given(/^This step is passing$/, function(callback) { callback(); });
};
module.exports = cucumberSteps;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "This scenario has tags",
        "id": "some-feature;this-scenario-has-tags",
        "line": 4,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "tags": [
          {
            "name": "@one",
            "line": 3
          },
          {
            "name": "@two",
            "line": 3
          },
          {
            "name": "@three",
            "line": 3
          }
        ],
        "steps": [
          {
            "name": "This step is passing",
            "line": 5,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          }
        ]
      }
    ]
  }
]

Feature: some feature

Scenario: This scenario contains a step with a table
    Given This table:
    |col 1|col 2|col 3|
    |one  |two  |three|
    |1    |2    |3    |
    |!    |~    |@    |

var cucumberSteps = function() {
  this.Given(/^This table:$/, function(table, callback) { callback(); });
};
module.exports = cucumberSteps;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "This scenario contains a step with a table",
        "id": "some-feature;this-scenario-contains-a-step-with-a-table",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "name": "This table:",
            "line": 4,
            "keyword": "Given ",
            "rows": [
              { "cells": ["col 1", "col 2", "col 3" ] },
              { "cells": ["one", "two", "three"] },
              { "cells": ["1", "2", "3"] },
              { "cells": ["!", "~", "@"] }
            ],
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          }
        ]
      }
    ]
  }
]

Feature: some feature

Background:
  Given This table:
    |col 1|col 2|col 3|
    |one  |two  |three|
    |1    |2    |3    |
    |!    |~    |@    |

var cucumberSteps = function() {
  this.Given(/^This table:$/, function(table, callback) { callback(); });
};
module.exports = cucumberSteps;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "",
        "keyword": "Background",
        "description": "",
        "type": "background",
        "line": 3,
        "steps": [
          {
            "name": "This table:",
            "line": 4,
            "keyword": "Given ",
            "rows": [
              { "cells": ["col 1", "col 2", "col 3"] },
              { "cells": ["one", "two", "three"] },
              { "cells": ["1", "2", "3"] },
              { "cells": ["!", "~", "@"] }
            ]
          }
        ]
      }
    ]
  }
]

Feature: some feature

  Scenario Outline: I've declared one step which passes
    Given This <instance> step is passing

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature"
  }
]

Feature: some feature

  Scenario Outline: I've declared one step which passes
    Given This <instance> step is passing

  Examples:
    | instance |

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature"
  }
]

Feature: some feature

  Scenario Outline: I've declared one step which passes
    Given This <instance> step is passing

  Examples:
    | instance |
    | first    |
    | second   |

var cucumberSteps = function() {
  this.Given(/^This (first|second) step is passing$/, function(instance, callback) { callback(); });
};
module.exports = cucumberSteps;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "I've declared one step which passes",
        "id": "some-feature;i've-declared-one-step-which-passes",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "name": "This first step is passing",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          }
        ]
      },
      {
        "name": "I've declared one step which passes",
        "id": "some-feature;i've-declared-one-step-which-passes",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "name": "This second step is passing",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          }
        ]
      }
    ]
  }
]

Feature: some feature
  Background:
    Given This applies to all scenarios

  Scenario Outline: I've declared one step which passes
    Given This <instance> step is passing

  Examples:
    | instance |
    | first    |

var cucumberSteps = function() {
  this.Given(/^This applies to all scenarios$/, function(callback) { callback(); });
  this.Given(/^This (first|second) step is passing$/, function(instance, callback) { callback(); });
};
module.exports = cucumberSteps;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "",
        "keyword": "Background",
        "description": "",
        "type": "background",
        "line": 2,
        "steps": [
          {
            "name": "This applies to all scenarios",
            "line": 3,
            "keyword": "Given "
          }
        ]
      },
      {
        "name": "I've declared one step which passes",
        "id": "some-feature;i've-declared-one-step-which-passes",
        "line": 5,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "name": "This applies to all scenarios",
            "line": 3,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          },
          {
            "name": "This first step is passing",
            "line": 6,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          }
        ]
      }
    ]
  }
]

Feature: some feature

  Scenario Outline: I've declared one step which passes
    Given This <instance> step is passing

  Examples:
    | instance |
    | first    |

  Examples:
    | instance |
    | second   |

var cucumberSteps = function() {
  this.Given(/^This (first|second) step is passing$/, function(instance, callback) { callback(); });
};
module.exports = cucumberSteps;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "I've declared one step which passes",
        "id": "some-feature;i've-declared-one-step-which-passes",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "name": "This first step is passing",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          }
        ]
      },
      {
        "name": "I've declared one step which passes",
        "id": "some-feature;i've-declared-one-step-which-passes",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "name": "This second step is passing",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          }
        ]
      }
    ]
  }
]

Feature: some feature

  Scenario Outline: I've declared one step which passes
    Given This <instance> step is passing

  Examples:
    | instance |
    | first    |
    | second   |

var cucumberSteps = function() {
  this.Given(/^This (first|second) step is passing$/, function(instance, callback) { callback(); });
};
module.exports = cucumberSteps;

var hooks = function () {
  this.Before(function(callback) {
    callback();
  });

  this.After(function(callback) {
    callback();
  });

  this.Around(function(runScenario) {
    runScenario(function(callback) {
      callback();
    });
  });
};

module.exports = hooks;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "I've declared one step which passes",
        "id": "some-feature;i've-declared-one-step-which-passes",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "keyword": "Around ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          },
          {
            "keyword": "Before ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          },
          {
            "name": "This first step is passing",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          },
          {
            "keyword": "After ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          },
          {
            "keyword": "Around ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          }
        ]
      },
      {
        "name": "I've declared one step which passes",
        "id": "some-feature;i've-declared-one-step-which-passes",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "keyword": "Around ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          },
          {
            "keyword": "Before ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          },
          {
            "name": "This second step is passing",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          },
          {
            "keyword": "After ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          },
          {
            "keyword": "Around ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          }
        ]
      }
    ]
  }
]

Feature: some feature

Feature: some feature



0 scenarios
0 steps

Feature: some feature

Scenario: I've declared one step which passes
    Given This step is passing

var cucumberSteps = function() {
  this.Given(/^This step is passing$/, function(callback) { callback(); });
};
module.exports = cucumberSteps;

var hooks = function () {
  this.Before(function(callback) {
    callback();
  });

  this.After(function(callback) {
    callback();
  });

  this.Around(function(runScenario) {
    runScenario(function(callback) {
      callback();
    });
  });
};

module.exports = hooks;

Feature: some feature



  Scenario: I've declared one step which passes   # features/a.feature:3
    Given This step is passing                    # features/a.feature:4


1 scenario (1 passed)
1 step (1 passed)

Feature: some feature

Scenario: I've declared one step and it is passing
    Given This step is passing

var cucumberSteps = function() {
  this.Given(/^This step is passing$/, function(callback) { callback(); });
};
module.exports = cucumberSteps;

var hooks = function () {
  this.Before(function(callback) {
    callback('Fail');
  });
};

module.exports = hooks;

Feature: some feature



  Scenario: I've declared one step and it is passing   # features/a.feature:3
    Before
      Fail
    Given This step is passing                         # features/a.feature:4


(::) failed steps (::)

Fail

Failing scenarios:
<current-directory>/features/a.feature:3 # Scenario: I've declared one step and it is passing

1 scenario (1 failed)
2 steps (1 failed, 1 skipped)

Feature: testing scenarios
  Background:
    Given a background step

  Scenario Outline: A <some> step is followed by <result> steps
    When a <some> step
    Then i get <result>
  Examples:
    | some    | result  |
    | passing | passed  |
    | failing | skipped |

Feature: testing scenarios
  Scenario Outline: outline with table
    When a table step:
      | first   | second   |
      | <first> | <second> |
  Examples:
    | first   | second  |
    | 1       | 2       |

[["first","second"],["1","2"]]

Feature: testing scenarios
  Scenario Outline: outline with doc string
    When a doc string step:
      """
      I am doc string in <example> example
      And there are <string> string
      """
  Examples:
    | example | string |
    | first   | some   |

I am doc string in first example
And there are some string

Feature: testing scenarios
  Scenario Outline: scenario outline 1
    When step <id>

  Examples:
    | id |
    | a  |
    | b  |

  Scenario Outline: scenario outline 2
    When step <id>

  Examples:
    | id |
    | c  |
    | d  |

Feature: some feature

Scenario: I've declared one step and it is passing
    Given This step is passing

var cucumberSteps = function() {
  this.Given(/^This step is passing$/, function(callback) { callback(); });
};
module.exports = cucumberSteps;

function checkScenarioStatuses(scenario) {
  var error;

  if (scenario.isSuccessful() !== true)
    error = "Expected isSuccessful to be true";
  else if (scenario.isFailed() !== false)
    error = "Expected isFailed to be false";
  else if (scenario.isPending() !== false)
    error = "Expected isPending to be false";
  else if (scenario.isUndefined() !== false)
    error = "Expected isUndefined to be false";
  else if (scenario.getException() !== null)
    error = "Expected exception to be null";
  else
    error = null;

  return error;
}

var hooks = function () {
  this.Around(function(scenario, runScenario) {
    var error = checkScenarioStatuses(scenario);

    runScenario(error, function(callback) {
      var error = checkScenarioStatuses(scenario);

      callback(error);
    });
  });

  this.Before(function(scenario, callback) {
    var error = checkScenarioStatuses(scenario);

    callback(error);
  });

  this.After(function(scenario, callback) {
    var error = checkScenarioStatuses(scenario);

    callback(error);
  });
};

module.exports = hooks;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "I've declared one step and it is passing",
        "id": "some-feature;i've-declared-one-step-and-it-is-passing",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "keyword": "Around ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          },
          {
            "keyword": "Before ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          },
          {
            "name": "This step is passing",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          },
          {
            "keyword": "After ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          },
          {
            "keyword": "Around ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          }
        ]
      }
    ]
  }
]

Feature: some feature

Scenario: I've declared one step and it is passing
    Given This step is passing

var cucumberSteps = function() {
  this.Given(/^This step is passing$/, function(callback) { callback(); });
};
module.exports = cucumberSteps;

var hooks = function () {
  this.After(function(scenario, callback) {
    if (scenario.isSuccessful() !== true)
      error = "Expected isSuccessful to be true";
    else if (scenario.isFailed() !== false)
      error = "Expected isFailed to be false";
    else if (scenario.isPending() !== false)
      error = "Expected isPending to be false";
    else if (scenario.isUndefined() !== false)
      error = "Expected isUndefined to be false";
    else if (scenario.getException() !== null)
      error = "Expected exception to be null";
    else
      error = null;

    callback(error);
  });
};

module.exports = hooks;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "I've declared one step and it is passing",
        "id": "some-feature;i've-declared-one-step-and-it-is-passing",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "name": "This step is passing",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          },
          {
            "keyword": "After ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          }
        ]
      }
    ]
  }
]

Feature: some feature

Scenario: I've declared one step and it is failing
    Given This step is failing

var cucumberSteps = function() {
  this.Given(/^This step is failing$/, function(callback) { callback("Fail"); });
};
module.exports = cucumberSteps;

var hooks = function () {
  this.After(function(scenario, callback) {
    if (scenario.isSuccessful() !== false)
      error = "Expected isSuccessful to be false";
    else if (scenario.isFailed() !== true)
      error = "Expected isFailed to be true";
    else if (scenario.isPending() !== false)
      error = "Expected isPending to be false";
    else if (scenario.isUndefined() !== false)
      error = "Expected isUndefined to be false";
    else if (scenario.getException() !== "Fail")
      error = "Expected exception to be 'Fail'";
    else
      error = null;

    callback(error);
  });
};

module.exports = hooks;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "I've declared one step and it is failing",
        "id": "some-feature;i've-declared-one-step-and-it-is-failing",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "name": "This step is failing",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "error_message": "<error_message>",
              "duration": "<duration>",
              "status": "failed"
            },
            "match": {}
          },
          {
            "keyword": "After ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          }
        ]
      }
    ]
  }
]

Feature: some feature

Scenario: I've declared one step and it is pending
    Given This step is pending

var cucumberSteps = function() {
  this.Given(/^This step is pending$/, function(callback) { callback.pending(); });
};
module.exports = cucumberSteps;

var hooks = function () {
  this.After(function(scenario, callback) {
    if (scenario.isSuccessful() !== false)
      error = "Expected isSuccessful to be false";
    else if (scenario.isFailed() !== false)
      error = "Expected isFailed to be false";
    else if (scenario.isPending() !== true)
      error = "Expected isPending to be true";
    else if (scenario.isUndefined() !== false)
      error = "Expected isUndefined to be false";
    else if (scenario.getException() !== null)
      error = "Expected exception to be null";
    else
      error = null;

    callback(error);
  });
};

module.exports = hooks;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "I've declared one step and it is pending",
        "id": "some-feature;i've-declared-one-step-and-it-is-pending",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "name": "This step is pending",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "status": "pending"
            },
            "match": {}
          },
          {
            "keyword": "After ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          }
        ]
      }
    ]
  }
]

Feature: some feature

Scenario: I've declared one step and it is undefined
    Given This step is undefined

var cucumberSteps = function() {
};
module.exports = cucumberSteps;

var hooks = function () {
  this.After(function(scenario, callback) {
    if (scenario.isSuccessful() !== false)
      error = "Expected isSuccessful to be false";
    else if (scenario.isFailed() !== false)
      error = "Expected isFailed to be false";
    else if (scenario.isPending() !== false)
      error = "Expected isPending to be false";
    else if (scenario.isUndefined() !== true)
      error = "Expected isUndefined to be true";
    else if (scenario.getException() !== null)
      error = "Expected exception to be null";
    else
      error = null;

    callback(error);
  });
};

module.exports = hooks;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "I've declared one step and it is undefined",
        "id": "some-feature;i've-declared-one-step-and-it-is-undefined",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "name": "This step is undefined",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "status": "undefined"
            },
            "match": {}
          },
          {
            "keyword": "After ",
            "hidden": true,
            "result": {
              "duration": "<duration>",
              "status": "passed"
            },
            "match": {}
          }
        ]
      }
    ]
  }
]

Feature: some feature

Scenario: I've declared one step and it is undefined
    Given This step is pending
    And This step is undefined

var cucumberSteps = function() {
  this.Given(/^This step is pending$/, function(callback) { callback.pending(); });
};
module.exports = cucumberSteps;

var hooks = function () {
  this.After(function(scenario, callback) {
    if (scenario.isSuccessful() !== false)
      error = "Expected isSuccessful to be false";
    else if (scenario.isFailed() !== true)
      error = "Expected isFailed to be true";
    else if (scenario.isPending() !== true)
      error = "Expected isPending to be true";
    else if (scenario.isUndefined() !== true)
      error = "Expected isUndefined to be true";
    else
      error = null;

    callback(error);
  });

  this.After(function(scenario, callback) {
    callback("fail");
  });
};

module.exports = hooks;

[
  {
    "id": "some-feature",
    "name": "some feature",
    "description": "",
    "line": 1,
    "keyword": "Feature",
    "uri": "<current-directory>/features/a.feature",
    "elements": [
      {
        "name": "I've declared one step and it is undefined",
        "id": "some-feature;i've-declared-one-step-and-it-is-undefined",
        "line": 3,
        "keyword": "Scenario",
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "name": "This step is pending",
            "line": 4,
            "keyword": "Given ",
            "result": {
              "status": "pending"
            },
            "match": {}
          },
          {
            "name": "This step is undefined",
            "line": 5,
            "keyword": "And ",
            "result": {
              "status": "undefined"
            },
            "match": {}
          },
          {
            "keyword": "After ",
            "hidden": true,
            "result": {
              "error_message": "fail",
              "duration": 351161,
              "status": "failed"
            },
            "match": {}
          },
          {
            "keyword": "After ",
            "hidden": true,
            "result": {
              "duration": 319244,
              "status": "passed"
            },
            "match": {}
          }
        ]
      }
    ]
  }
]

When I divide 10 by 0

Feature: Missing
  Scenario: Missing
    Given this step passes

Feature: Missing
  Scenario: Missing
    Given this step passes

var cucumberSteps = function() {
  this.When(/^this step passes$/, function(callback) { callback(); });
};
module.exports = cucumberSteps;

.

1 scenario (1 passed)
1 step (1 passed)

Feature: Missing
  Scenario: Missing
    Given this step passes

U

1 scenario (1 undefined)
1 step (1 undefined)

You can implement step definitions for undefined steps with these snippets:

this.Given(/^this step passes$/, function (callback) {
  // Write code here that turns the phrase above into concrete actions
  callback.pending();
});

Feature: Missing
  Scenario: Missing
    Given this step passes

var cucumberSteps = function() {
  this.Given(/^this step passes$/, function(callback) { callback.pending(); });
};
module.exports = cucumberSteps;

P

1 scenario (1 pending)
1 step (1 pending)

Feature: Missing
  Scenario: Missing
    Given this step passes

U

1 scenario (1 undefined)
1 step (1 undefined)

You can implement step definitions for undefined steps with these snippets:

this.Given(/^this step passes$/, function (callback) {
  // Write code here that turns the phrase above into concrete actions
  callback.pending();
});

Feature: Missing
  Scenario: Missing
    Given this step passes

var cucumberSteps = function() {
  this.Given(/^this step passes$/, function(callback) { callback.pending(); });
};
module.exports = cucumberSteps;

P

1 scenario (1 pending)
1 step (1 pending)

Feature: some feature

0 scenarios
0 steps

Feature: some feature

Scenario: I've declared one step which passes
    Given This step is passing

var cucumberSteps = function() {
  this.Given(/^This step is passing$/, function(callback) { callback(); });
};
module.exports = cucumberSteps;

var hooks = function () {
  this.Before(function(callback) {
    callback();
  });

  this.After(function(callback) {
    callback();
  });

  this.Around(function(runScenario) {
    runScenario(function(callback) {
      callback();
    });
  });
};

module.exports = hooks;

1 scenario (1 passed)
1 step (1 passed)

Given I am a happy veggie \o/
When I type -[]{}()*+?.\^$|#/

Given I have 5 "kekiri" cucumbers

Given I have some "hekiri", "wild" and "regular" cucumbers

Given I have <some> cucumbers