cucumber-documentation

After do |scenario|
  puts scenario.status.inspect
end

Feature:
  Scenario:
    Given this step passes

After do |scenario|
  puts scenario.status.inspect
end

Feature:
  Scenario:
    Given this step fails

After do |scenario|
  puts scenario.status.inspect
end

Feature:
  Scenario:
    Given this step is pending

After do |scenario|
  if scenario.failed?
    puts "eek"
  end
end

Feature:
  Scenario:
    Given this step fails

eek

After do
  fail 'yikes'
end

Feature:
  Scenario:
    Given this step passes

  Scenario:                # features/pass.feature:2
    Given this step passes # features/step_definitions/steps.rb:1
      yikes (RuntimeError)
      ./features/support/bad_hook.rb:2:in `After'

After do
  puts "First"
end

After do
  puts "Second"
end

Feature:
  Scenario:
    Given this step passes

Second

First

Then /^the hook is called$/ do
  expect($hook_called).to be true
end

Around do |scenario, block|
  $hook_called = true
  block.call
end

Feature: Around hooks
  Scenario: using hook
    Then the hook is called

Feature: Around hooks

  Scenario: using hook      # features/f.feature:2
    Then the hook is called # features/step_definitions/steps.rb:1

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

Then /^the hooks are called in the correct order$/ do
  expect($hooks_called).to eq ['A', 'B', 'C']
end

Around do |scenario, block|
  $hooks_called ||= []
  $hooks_called << 'A'
  block.call
end

Around do |scenario, block|
  $hooks_called ||= []
  $hooks_called << 'B'
  block.call
end

Around do |scenario, block|
  $hooks_called ||= []
  $hooks_called << 'C'
  block.call
end

Feature: Around hooks
  Scenario: using multiple hooks
    Then the hooks are called in the correct order

Feature: Around hooks

  Scenario: using multiple hooks                   # features/f.feature:2
    Then the hooks are called in the correct order # features/step_definitions/steps.rb:1

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

Then /^the Around hook is called around Before and After hooks$/ do
  expect($hooks_called).to eq ['Around', 'Before']
end

Around do |scenario, block|
  $hooks_called ||= []
  $hooks_called << 'Around'
  block.call
  $hooks_called << 'Around'
  $hooks_called.should == ['Around', 'Before', 'After', 'Around'] #TODO: Find out why this fails using the new rspec expect syntax.
end

Before do |scenario|
  $hooks_called ||= []
  $hooks_called << 'Before'
end

After do |scenario|
  $hooks_called ||= []
  $hooks_called << 'After'
  expect($hooks_called).to eq ['Around', 'Before', 'After']
end

Feature: Around hooks
  Scenario: Mixing Around, Before, and After hooks
    Then the Around hook is called around Before and After hooks

Feature: Around hooks

  Scenario: Mixing Around, Before, and After hooks               # features/f.feature:2
    Then the Around hook is called around Before and After hooks # features/step_definitions/steps.rb:1

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

Then /^the Around hooks with matching tags are called$/ do
  expect($hooks_called).to eq ['one', 'one or two']
end

Around('@one') do |scenario, block|
  $hooks_called ||= []
  $hooks_called << 'one'
  block.call
end

Around('@one,@two') do |scenario, block|
  $hooks_called ||= []
  $hooks_called << 'one or two'
  block.call
end

Around('@one', '@two') do |scenario, block|
  $hooks_called ||= []
  $hooks_called << 'one and two'
  block.call
end

Around('@two') do |scenario, block|
  $hooks_called ||= []
  $hooks_called << 'two'
  block.call
end

Feature: Around hooks
  @one
  Scenario: Around hooks with tags
    Then the Around hooks with matching tags are called

Feature: Around hooks

  @one
  Scenario: Around hooks with tags
    Then the Around hooks with matching tags are called

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

Then /^the hook is called$/ do
  expect($hook_called).to be true
end

Around do |scenario, block|
  $hook_called = true
  block.call
end

Feature: Around hooks with scenario outlines
  Scenario Outline: using hook
    Then the hook is called

    Examples:
      | Number |
      | one    |
      | two    |

Feature: Around hooks with scenario outlines

  Scenario Outline: using hook # features/f.feature:2
    Then the hook is called    # features/f.feature:3

    Examples:
      | Number |
      | one    |
      | two    |

2 scenarios (2 passed)
2 steps (2 passed)

Then /^the world should be available in the hook$/ do
  $previous_world = self
  expect($hook_world).to eq(self)
end

Then /^what$/ do
  expect($hook_world).not_to eq($previous_world)
end

Around do |scenario, block|
  $hook_world = self
  block.call
end

Feature: Around hooks
  Scenario: using hook
    Then the world should be available in the hook

  Scenario: using the same hook
    Then what

Feature: Passing background sample

  Background:
    Given '10' cukes

  Scenario: passing background
    Then I should have '10' cukes

  Scenario: another passing background
    Then I should have '10' cukes

Feature: Passing background with scenario outlines sample

  Background:
    Given '10' cukes

  Scenario Outline: passing background
    Then I should have '<count>' cukes
    Examples:
      |count|
      | 10  |

  Scenario Outline: another passing background
    Then I should have '<count>' cukes
    Examples:
      |count|
      | 10  |

@background_tagged_before_on_outline
Feature: Background tagged Before on Outline

  Background:
    Given this step passes

  Scenario Outline: passing background
    Then I should have '<count>' cukes

    Examples:
      | count |
      | 888   |

Feature: Failing background sample

  Background:
    Given this step raises an error
    And '10' cukes

  Scenario: failing background
    Then I should have '10' cukes

  Scenario: another failing background
    Then I should have '10' cukes

Feature: Failing background with scenario outlines sample

  Background:
    Given this step raises an error

  Scenario Outline: failing background
    Then I should have '<count>' cukes
    Examples:
      |count|
      | 10  |

  Scenario Outline: another failing background
    Then I should have '<count>' cukes
    Examples:
      |count|
      | 10  |

Feature: Pending background sample

  Background:
    Given this step is pending

  Scenario: pending background
    Then I should have '10' cukes

  Scenario: another pending background
    Then I should have '10' cukes

Feature: Failing background after previously successful background sample

  Background:
    Given this step passes
    And '10' global cukes

  Scenario: passing background
    Then I should have '10' global cukes

  Scenario: failing background
    Then I should have '10' global cukes

Feature: Failing background after previously successful background sample

  Background:
    Given this step passes
    And '10' global cukes

  Scenario Outline: passing background
    Then I should have '<count>' global cukes

    Examples:
      | count |
      | 10    |

  Scenario Outline: failing background
    Then I should have '<count>' global cukes

    Examples:
      | count |
      | 10    |

Feature: Passing background with multiline args

  Background:
    Given table
      |a|b|
      |c|d|
    And multiline string
      """
      I'm a cucumber and I'm okay.
      I sleep all night and I test all day
      """

  Scenario: passing background
    Then the table should be
      |a|b|
      |c|d|
    Then the multiline string should be
      """
      I'm a cucumber and I'm okay.
      I sleep all night and I test all day
      """

  Scenario: another passing background
    Then the table should be
      |a|b|
      |c|d|
    Then the multiline string should be
      """
      I'm a cucumber and I'm okay.
      I sleep all night and I test all day
      """

Given /^'(.+)' cukes$/ do |cukes| x=1
  raise "We already have #{@cukes} cukes!" if @cukes
  @cukes = cukes
end

Given /^'(.+)' global cukes$/ do |cukes| x=1
  $scenario_runs ||= 0
  raise 'FAIL' if $scenario_runs >= 1
  $cukes = cukes
  $scenario_runs += 1
end

Then /^I should have '(.+)' global cukes$/ do |cukes| x=1
  expect($cukes).to eq cukes
end

Then /^I should have '(.+)' cukes$/ do |cukes| x=1
  expect(@cukes).to eq cukes
end

Before('@background_tagged_before_on_outline') do
  @cukes = '888'
end

After('@background_tagged_before_on_outline') do
  expect(@cukes).to eq '888'
end

Feature: Passing background sample

  Background:
    Given '10' cukes

  Scenario: another passing background
    Then I should have '10' cukes

1 scenario (1 passed)
2 steps (2 passed)

Feature: Passing background sample

  Background:
    Given '10' cukes

  Scenario: passing background
    Then I should have '10' cukes

  Scenario: another passing background
    Then I should have '10' cukes

2 scenarios (2 passed)
4 steps (4 passed)

Feature: Passing background with scenario outlines sample

  Background:
    Given '10' cukes

  Scenario Outline: passing background
    Then I should have '<count>' cukes

    Examples:
      | count |
      | 10    |

  Scenario Outline: another passing background
    Then I should have '<count>' cukes

    Examples:
      | count |
      | 10    |

2 scenarios (2 passed)
4 steps (4 passed)

@background_tagged_before_on_outline
Feature: Background tagged Before on Outline

  Background:
    Given this step passes

  Scenario Outline: passing background
    Then I should have '<count>' cukes

    Examples:
      | count |
      | 888   |

1 scenario (1 passed)
2 steps (2 passed)

Feature: Failing background sample

  Background:
    Given this step raises an error
      error (RuntimeError)
      ./features/step_definitions/steps.rb:2:in `/^this step raises an error$/'
      features/failing_background.feature:4:in `Given this step raises an error'
    And '10' cukes

  Scenario: failing background
    Then I should have '10' cukes

  Scenario: another failing background
    Then I should have '10' cukes

Failing Scenarios:
cucumber features/failing_background.feature:7
cucumber features/failing_background.feature:10

2 scenarios (2 failed)
6 steps (2 failed, 4 skipped)

Feature: Failing background with scenario outlines sample

  Background:
    Given this step raises an error
      error (RuntimeError)
      ./features/step_definitions/steps.rb:2:in `/^this step raises an error$/'
      features/scenario_outline_failing_background.feature:4:in `Given this step raises an error'

  Scenario Outline: failing background
    Then I should have '<count>' cukes

    Examples:
      | count |
      | 10    |

  Scenario Outline: another failing background
    Then I should have '<count>' cukes

    Examples:
      | count |
      | 10    |

Failing Scenarios:
cucumber features/scenario_outline_failing_background.feature:10
cucumber features/scenario_outline_failing_background.feature:16

2 scenarios (2 failed)
4 steps (2 failed, 2 skipped)

Feature: Pending background sample

  Background:
    Given this step is pending
      TODO (Cucumber::Pending)
      ./features/step_definitions/steps.rb:3:in `/^this step is pending$/'
      features/pending_background.feature:4:in `Given this step is pending'

  Scenario: pending background
    Then I should have '10' cukes

  Scenario: another pending background
    Then I should have '10' cukes

2 scenarios (2 pending)
4 steps (2 skipped, 2 pending)

Feature: Failing background after previously successful background sample

  Background:
    Given this step passes
    And '10' global cukes

  Scenario: passing background
    Then I should have '10' global cukes

  Scenario: failing background
    And '10' global cukes
      FAIL (RuntimeError)
      ./features/step_definitions/cuke_steps.rb:8:in `/^'(.+)' global cukes$/'
      features/failing_background_after_success.feature:5:in `And '10' global cukes'
    Then I should have '10' global cukes

Failing Scenarios:
cucumber features/failing_background_after_success.feature:10

2 scenarios (1 failed, 1 passed)
6 steps (1 failed, 1 skipped, 4 passed)

Feature: Failing background after previously successful background sample

  Background:
    Given this step passes
    And '10' global cukes

  Scenario Outline: passing background
    Then I should have '<count>' global cukes

    Examples:
      | count |
      | 10    |

  Scenario Outline: failing background
    Then I should have '<count>' global cukes

    Examples:
      | count |
      | 10    |
      FAIL (RuntimeError)
      ./features/step_definitions/cuke_steps.rb:8:in `/^'(.+)' global cukes$/'
      features/failing_background_after_success_outline.feature:5:in `And '10' global cukes'

Failing Scenarios:
cucumber features/failing_background_after_success_outline.feature:19

2 scenarios (1 failed, 1 passed)
6 steps (1 failed, 1 skipped, 4 passed)

Feature: Failing background after previously successful background sample

  Background:
    Given this step passes
    And '10' global cukes

  Scenario Outline: passing background
    Then I should have '<count>' global cukes

    Examples:

      Scenario: | 10 |
        Then I should have '10' global cukes

  Scenario Outline: failing background
    Then I should have '<count>' global cukes

    Examples:

      Scenario: | 10 |
        And '10' global cukes
      FAIL (RuntimeError)
      ./features/step_definitions/cuke_steps.rb:8:in `/^'(.+)' global cukes$/'
      features/failing_background_after_success_outline.feature:5:in `And '10' global cukes'
        Then I should have '10' global cukes

Failing Scenarios:
cucumber features/failing_background_after_success_outline.feature:19

2 scenarios (1 failed, 1 passed)
6 steps (1 failed, 1 skipped, 4 passed)

Given /^table$/ do |table| x=1
  @table = table
end

Given /^multiline string$/ do |string| x=1
  @multiline = string
end

Then /^the table should be$/ do |table| x=1
  expect(@table.raw).to eq table.raw
end

Then /^the multiline string should be$/ do |string| x=1
  expect(@multiline).to eq string
end

Feature: Passing background with multiline args

  Background:
    Given table
      | a | b |
      | c | d |
    And multiline string
      """
      I'm a cucumber and I'm okay.
      I sleep all night and I test all day
      """

  Scenario: passing background
    Then the table should be
      | a | b |
      | c | d |
    Then the multiline string should be
      """
      I'm a cucumber and I'm okay.
      I sleep all night and I test all day
      """

  Scenario: another passing background
    Then the table should be
      | a | b |
      | c | d |
    Then the multiline string should be
      """
      I'm a cucumber and I'm okay.
      I sleep all night and I test all day
      """

2 scenarios (2 passed)
8 steps (8 passed)

Feature: Feature name

  Scenario: Scenario name
    Given a step

names = []
Before do |scenario|
  expect(scenario).to_not respond_to(:scenario_outline)
  names << scenario.feature.name.split("\n").first
  names << scenario.name.split("\n").first
  if(names.size == 2)
    raise "NAMES:\n" + names.join("\n") + "\n"
  end
end

  NAMES:
  Feature name
  Scenario name

Feature: Feature name

  Scenario Outline: Scenario Outline name
    Given a <placeholder>

    Examples: Examples Table name
      | <placeholder> |
      | step          |

names = []
Before do |scenario|
  names << scenario.scenario_outline.feature.name.split("\n").first
  names << scenario.scenario_outline.name.split("\n").first
  names << scenario.name.split("\n").first
  if(names.size == 3)
    raise "NAMES:\n" + names.join("\n") + "\n"
  end
end

      NAMES:
      Feature name
      Scenario Outline name, Examples Table name (#1)
      Scenario Outline name, Examples Table name (#1)

# language: en-lol
OH HAI: STUFFING
  B4: HUNGRY
    I CAN HAZ EMPTY BELLY
  MISHUN: CUKES
    DEN KTHXBAI

# language: en-lol
OH HAI: STUFFING

  B4: HUNGRY
    I CAN HAZ EMPTY BELLY

  MISHUN: CUKES
    DEN KTHXBAI

1 scenario (1 undefined)
2 steps (2 undefined)

Feature: WIP
  @failing
  Scenario: Failing
    Given this step raises an error

  @undefined
  Scenario: Undefined
    Given this step is undefined

  @pending
  Scenario: Pending
    Given this step is pending

  @passing
  Scenario: Passing
    Given this step passes

Feature: Not WIP
  Scenario Outline: Passing
    Given this step <what>

    Examples:
      | what   |
      | passes |

Feature: WIP

  @failing
  Scenario: Failing
    Given this step raises an error
      error (RuntimeError)
      ./features/step_definitions/steps.rb:2:in `/^this step raises an error$/'
      features/wip.feature:4:in `Given this step raises an error'

Failing Scenarios:
cucumber features/wip.feature:3

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

The --wip switch was used, so the failures were expected. All is good.

Feature: WIP

  @undefined
  Scenario: Undefined
    Given this step is undefined

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

The --wip switch was used, so the failures were expected. All is good.

Feature: WIP

  @pending
  Scenario: Pending
    Given this step is pending
      TODO (Cucumber::Pending)
      ./features/step_definitions/steps.rb:3:in `/^this step is pending$/'
      features/wip.feature:12:in `Given this step is pending'

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

The --wip switch was used, so the failures were expected. All is good.

Feature: WIP

  @passing
  Scenario: Passing
    Given this step passes

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

The --wip switch was used, so I didn't expect anything to pass. These scenarios passed:
(::) passed scenarios (::)

features/wip.feature:15:in `Scenario: Passing'

Feature: Not WIP

  Scenario Outline: Passing
    Given this step <what>

    Examples:
      | what   |
      | passes |

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

The --wip switch was used, so I didn't expect anything to pass. These scenarios passed:
(::) passed scenarios (::)

features/passing_outline.feature:7:in `Scenario Outline: Passing, Examples (#1)'

Feature: I'll use my own
  Scenario: Just print me
    Given this step passes

module MyCustom
  class Formatter
    def initialize(runtime, io, options)
      @io = io
    end

    def before_test_case(test_case)
      feature = test_case.source.first
      scenario = test_case.source.last
      @io.puts feature.short_name.upcase
      @io.puts "  #{scenario.name.upcase}"
    end
  end
end

I'LL USE MY OWN
  JUST PRINT ME

module MyCustom
  class LegacyFormatter
    def initialize(runtime, io, options)
      @io = io
    end

    def before_feature(feature)
      @io.puts feature.short_name.upcase
    end

    def scenario_name(keyword, name, file_colon_line, source_indent)
      @io.puts "  #{name.upcase}"
    end
  end
end

I'LL USE MY OWN
  JUST PRINT ME

module MyCustom
  class MixedFormatter

    def initialize(runtime, io, options)
      @io = io
    end

    def before_test_case(test_case)
      feature = test_case.source.first
      @io.puts feature.short_name.upcase
    end

    def scenario_name(keyword, name, file_colon_line, source_indent)
      @io.puts "  #{name.upcase}"
    end
  end
end

I'LL USE MY OWN
  JUST PRINT ME

Feature:
  Scenario:
    Given my special step

require 'cucumber/core/filter'

MakeAnythingPass = Cucumber::Core::Filter.new do
  def test_case(test_case)
    activated_steps = test_case.test_steps.map do |test_step|
      test_step.with_action { }
    end
    test_case.with_steps(activated_steps).describe_to receiver
  end
end

AfterConfiguration do |config|
  config.filters << MakeAnythingPass.new
end

Feature:
  Scenario:
    Given this step passes

before_test_case
before_features
before_feature
before_tags
after_tags
feature_name
before_test_step
after_test_step
before_test_step
before_feature_element
before_tags
after_tags
scenario_name
before_steps
before_step
before_step_result
step_name
after_step_result
after_step
after_test_step
after_steps
after_feature_element
after_test_case
after_feature
after_features
done

Given I have a lot to say:
 """
 One
 Two
 Three
 """

Given /say/ do |text|
  puts text
end

One
Two
Three

Given I have some code for you:
 """ruby
 # hello
 """

Given /code/ do |text|
  puts text.content_type
end

ruby

Feature: test
  Scenario:
    Given this step fails

Feature: test

  Scenario:               # features/test.feature:2
    Given this step fails # features/step_definitions/steps.rb:4

1 scenario (1 skipped)
1 step (1 skipped)

Feature: test
  Scenario:
    Given this step fails

Feature: test

  Scenario:               # features/test.feature:2
    Given this step fails # features/step_definitions/steps.rb:4

1 scenario (1 skipped)
1 step (1 skipped)

Feature: test
  Scenario:
    Given this step is undefined

Feature: test

  Scenario:                      # features/test.feature:2
    Given this step is undefined # features/test.feature:3
      Undefined step: "this step is undefined" (Cucumber::Undefined)
      features/test.feature:3:in `Given this step is undefined'

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

Feature: High strung
  Scenario: Wired
    Given we're all wired

host: localhost
port: <%= ENV['PORT'] || 12345 %>

U

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

host: localhost
port: <%= ENV['PORT'] || 12345 %>

U

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

Given /^this step does something naughty$/ do x=1
  @naughty = true
end

class NaughtyScenarioException < Exception; end
After do
  if @naughty
    raise NaughtyScenarioException.new("This scenario has been very very naughty")
  end
end

Feature: Sample

  Scenario: Naughty Step
    Given this step does something naughty

  Scenario: Success
    Given this step passes

Feature: Sample

  Scenario: Naughty Step                   # features/naughty_step_in_scenario.feature:3
    Given this step does something naughty # features/step_definitions/naughty_steps.rb:1
      This scenario has been very very naughty (NaughtyScenarioException)
      ./features/support/env.rb:4:in `After'

  Scenario: Success        # features/naughty_step_in_scenario.feature:6
    Given this step passes # features/step_definitions/steps.rb:1

Failing Scenarios:
cucumber features/naughty_step_in_scenario.feature:3 # Scenario: Naughty Step

2 scenarios (1 failed, 1 passed)
2 steps (2 passed)

Feature: Sample

  Scenario Outline: Naughty Step
    Given this step <Might Work>

    Examples:
    | Might Work             |
    | passes                 |
    | does something naughty |
    | passes                 |

  Scenario: Success
    Given this step passes

Feature: Sample

  Scenario Outline: Naughty Step
    Given this step <Might Work>

    Examples:
      | Might Work             |
      | passes                 |
      | does something naughty |
      This scenario has been very very naughty (NaughtyScenarioException)
      ./features/support/env.rb:4:in `After'
      | passes                 |

  Scenario: Success
    Given this step passes

Failing Scenarios:
cucumber features/naughty_step_in_scenario_outline.feature:9

4 scenarios (1 failed, 3 passed)
4 steps (4 passed)

Feature: Sample

  Scenario: Naughty Step
    Given this step does something naughty

  Scenario: Success
    Given this step passes

.F.

Failing Scenarios:
cucumber features/naughty_step_in_scenario.feature:3 # Scenario: Naughty Step

2 scenarios (1 failed, 1 passed)
2 steps (2 passed)

Given /^this step does something naughty$/ do x=1
  @naughty = true
end

class NaughtyStepException < Exception; end
AfterStep do
  if @naughty
    raise NaughtyStepException.new("This step has been very very naughty")
  end
end

Feature: Sample

  Scenario: Naughty Step
    Given this step does something naughty

  Scenario: Success
    Given this step passes

Feature: Sample

  Scenario: Naughty Step                   # features/naughty_step_in_scenario.feature:3
    Given this step does something naughty # features/step_definitions/naughty_steps.rb:1
      This step has been very very naughty (NaughtyStepException)
      ./features/support/env.rb:4:in `AfterStep'
      features/naughty_step_in_scenario.feature:4:in `Given this step does something naughty'

  Scenario: Success        # features/naughty_step_in_scenario.feature:6
    Given this step passes # features/step_definitions/steps.rb:1

Failing Scenarios:
cucumber features/naughty_step_in_scenario.feature:3 # Scenario: Naughty Step

2 scenarios (1 failed, 1 passed)
2 steps (2 passed)

Feature: Sample

  Scenario Outline: Naughty Step
    Given this step <Might Work>

    Examples:
    | Might Work             |
    | passes                 |
    | does something naughty |
    | passes                 |

  Scenario: Success
    Given this step passes

Feature: Sample

  Scenario Outline: Naughty Step # features/naughty_step_in_scenario_outline.feature:3
    Given this step <Might Work> # features/naughty_step_in_scenario_outline.feature:4

    Examples:
      | Might Work             |
      | passes                 |
      | does something naughty |
      This step has been very very naughty (NaughtyStepException)
      ./features/support/env.rb:4:in `AfterStep'
      features/naughty_step_in_scenario_outline.feature:9:in `Given this step does something naughty'
      features/naughty_step_in_scenario_outline.feature:4:in `Given this step <Might Work>'
      | passes                 |

  Scenario: Success        # features/naughty_step_in_scenario_outline.feature:12
    Given this step passes # features/step_definitions/steps.rb:1

Failing Scenarios:
cucumber features/naughty_step_in_scenario_outline.feature:9 # Scenario Outline: Naughty Step, Examples (#2)

4 scenarios (1 failed, 3 passed)
4 steps (4 passed)

class SomeSetupException < Exception; end
class BadStepException < Exception; end
Before do
  raise SomeSetupException.new("I cannot even start this scenario")
end

Feature: Sample

  Scenario: Run a good step
    Given this step passes

Feature: Sample

  Scenario: Run a good step # features/naughty_step_in_scenario.feature:3
  I cannot even start this scenario (SomeSetupException)
  ./features/support/env.rb:4:in `Before'
    Given this step passes  # features/step_definitions/steps.rb:1

Failing Scenarios:
cucumber features/naughty_step_in_scenario.feature:3 # Scenario: Run a good step

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

Feature: Sample

  Background:
    Given this step passes

  Scenario: Run a good step
    Given this step passes

Feature: Sample

  Background:              # features/naughty_step_in_before.feature:3
  I cannot even start this scenario (SomeSetupException)
  ./features/support/env.rb:4:in `Before'
    Given this step passes # features/step_definitions/steps.rb:1

  Scenario: Run a good step # features/naughty_step_in_before.feature:6
    Given this step passes  # features/step_definitions/steps.rb:1

Failing Scenarios:
cucumber features/naughty_step_in_before.feature:6 # Scenario: Run a good step

1 scenario (1 failed)
2 steps (2 skipped)
0m0.012s

Feature: Sample

  Scenario: Run a good step
    Given this step passes

F-

Failing Scenarios:
cucumber features/naughty_step_in_scenario.feature:3 # Scenario: Run a good step

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

Around do |scenario, block|
  fail "this should be reported"
  block.call
end

Feature:
  Scenario:
    Given this step passes

Feature:

  Scenario:
  this should be reported (RuntimeError)
  ./features/support/env.rb:2:in `Around'

Failing Scenarios:
cucumber features/test.feature:2

1 scenario (1 failed)
0 steps

Around do |scenario, block|
  block.call
  fail "this should be reported"
end

Feature:
  Scenario:
    Given this step passes

Feature:

  Scenario:
    Given this step passes
      this should be reported (RuntimeError)
      ./features/support/env.rb:3:in `Around'

Failing Scenarios:
cucumber features/test.feature:2

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

Feature: I'll use my own
  because I'm worth it
  Scenario: just print step current line and feature file name
    Given step at line 4
    Given step at line 5

Given(/^step at line (.*)$/) {|line| }

module Jb
  class Formatter
    def initialize(runtime, io, options)
      @io = io
    end

    def before_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background, file_colon_line)
      @io.puts "step result event: #{file_colon_line}"
    end

    def step_name(keyword, step_match, status, source_indent, background, file_colon_line)
      @io.puts "step name event: #{file_colon_line}"
    end
  end
end

step result event: features/f.feature:4
step name event: features/f.feature:4
step result event: features/f.feature:5
step name event: features/f.feature:5

No such file or directory - features. You can use `cucumber --init` to get started.

puts 'this will not be shown'

this will not be shown

Feature:

  Scenario Outline:
    Given this step is undefined

  Examples:
    |foo|
    |bar|

Feature: Outline

  Scenario Outline: Will it blend?
    Given this step is pending
    And other step
    When I do something with <example>
    Then I should see something
    Examples:
      | example |
      | one     |
      | two     |
      | three   |

Feature: Feature with failing background step

  Background:
    Given this step fails

  Scenario:
    When I do something
    Then I should see something

makeYellow('scenario_1')

makeRed('scenario_1')

makeYellow('scenario_1')

makeRed('scenario_1')

makeYellow('scenario_1')

makeRed('scenario_1')

makeYellow('scenario_1')

makeRed('scenario_1')

  default: -r features

Using the default profile...

makeRed('scenario_0')

makeRed('background_0')

Feature: High strung
  Scenario: Wired
    Given we're all wired

host: localhost
port: 54321

undefined method `handle_yikes'

Given /^background step$/ do; $EventOrder.push(:background_step) end
Given /^scenario step$/ do; $EventOrder.push(:scenario_step) end

$EventOrder = []
Around('@around') do |scenario,block|
  $EventOrder.push :around_begin
  block.call
  $EventOrder.push :around_end
end
Before('@before') do
  $EventOrder.push :before
end
After('@after') do |scenario|
  $EventOrder.push :after
end
at_exit {
  puts "Event order: #{$EventOrder.join(' ')}"
}

@around
Feature: Around hooks cover background steps
  Background:
    Given background step
  Scenario:
    Given scenario step

@around
@before
@after
Feature: All hooks execute in expected order
  Background:
    Given background step
  Scenario:
    Given scenario step

Event order: around_begin background_step scenario_step around_end

Event order: around_begin before background_step scenario_step after around_end

Feature: High strung
  Scenario: Wired
    Given we're all wired

host: localhost
port: 54321

Feature: High strung

  Scenario: Wired
    Given we're all wired
      I'll do it later (Cucumber::Pending)
      features/wired.feature:3:in `Given we're all wired'

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

.

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

F

(::) failed steps (::)

The wires are down (Some.Foreign.ExceptionType from localhost:54321)
features/wired.feature:3:in `Given we're all wired'

Failing Scenarios:
cucumber features/wired.feature:2 # Scenario: Wired

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

.

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

Feature: High strung
  Scenario: Wired and more
    Given we're all:
      | wired |
      | high  |
      | happy |

.

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

Feature:
  Scenario Outline:
    Given we're all <arg>

    Examples:
      | arg   |
      | wired |

.

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

@a
Feature: One passing scenario, one failing scenario

  @b
  Scenario: Passing
    Given this step passes

  @c
  Scenario: Failing
    Given this step fails

Given /^I embed a screenshot/ do
  File.open("screenshot.png", "w") { |file| file << "foo" }
  embed "screenshot.png", "image/png"
end

Given /^I print from step definition/ do
  puts "from step definition"
end

Given /^I embed data directly/ do
  data = "YWJj"
  embed data, "mime-type;base64"
end

Feature: A screenshot feature

  Scenario:
    Given I embed a screenshot

Feature: An outline feature

  Scenario Outline: outline
    Given this step <status>

    Examples: examples1
      | status |
      | passes |
      | fails  |

    Examples: examples2
      | status |
      | passes |

Feature: A print from step definition feature

  Scenario:
    Given I print from step definition
    And I print from step definition

Feature: A print from step definition feature

  Scenario:
    Given I print from step definition
    And I print from step definition

Feature: An embed data directly feature

  Scenario:
    Given I embed data directly

  Scenario Outline:
    Given I embed data directly

Examples:
| dummy |
|  1    |
|  2    |

Feature:
  Scenario:
    Given this step passes
  Scenario Outline:
    Given this step <status>
    Examples:
    | status |
    | passes |

[
  {
    "uri": "features/one_passing_one_failing.feature",
    "keyword": "Feature",
    "id": "one-passing-scenario,-one-failing-scenario",
    "name": "One passing scenario, one failing scenario",
    "line": 2,
    "description": "",
    "tags": [
      {
        "name": "@a",
        "line": 1
      }
    ],
    "elements": [
      {
        "keyword": "Scenario",
        "id": "one-passing-scenario,-one-failing-scenario;passing",
        "name": "Passing",
        "line": 5,
        "description": "",
        "tags": [
          {
            "name": "@a",
            "line": 1
          },
          {
            "name": "@b",
            "line": 4
          }
        ],
        "type": "scenario",
        "steps": [
          {
            "keyword": "Given ",
            "name": "this step passes",
            "line": 6,
            "match": {
              "location": "features/step_definitions/steps.rb:1"
            },
            "result": {
              "status": "passed",
              "duration": 1
            }
          }
        ]
      },
      {
        "keyword": "Scenario",
        "id": "one-passing-scenario,-one-failing-scenario;failing",
        "name": "Failing",
        "line": 9,
        "description": "",
        "tags": [
          {
            "name": "@a",
            "line": 1
          },
          {
            "name": "@c",
            "line": 8
          }
        ],
        "type": "scenario",
        "steps": [
          {
            "keyword": "Given ",
            "name": "this step fails",
            "line": 10,
            "match": {
              "location": "features/step_definitions/steps.rb:4"
            },
            "result": {
              "status": "failed",
              "error_message": " (RuntimeError)\n./features/step_definitions/steps.rb:4:in `/^this step fails$/'\nfeatures/one_passing_one_failing.feature:10:in `Given this step fails'",
              "duration": 1
            }
          }
        ]
      }
    ]
  }
]

[
  {
    "uri": "features/one_passing_one_failing.feature",
    "keyword": "Feature",
    "id": "one-passing-scenario,-one-failing-scenario",
    "name": "One passing scenario, one failing scenario",
    "line": 2,
    "description": "",
    "tags": [
      {
        "name": "@a",
        "line": 1
      }
    ],
    "elements": [
      {
        "keyword": "Scenario",
        "id": "one-passing-scenario,-one-failing-scenario;passing",
        "name": "Passing",
        "line": 5,
        "description": "",
        "tags": [
          {
            "name": "@a",
            "line": 1
          },
          {
            "name": "@b",
            "line": 4
          }
        ],
        "type": "scenario",
        "steps": [
          {
            "keyword": "Given ",
            "name": "this step passes",
            "line": 6,
            "match": {
              "location": "features/step_definitions/steps.rb:1"
            },
            "result": {
              "status": "passed",
              "duration": 1
            }
          }
        ]
      },
      {
        "keyword": "Scenario",
        "id": "one-passing-scenario,-one-failing-scenario;failing",
        "name": "Failing",
        "line": 9,
        "description": "",
        "tags": [
          {
            "name": "@a",
            "line": 1
          },
          {
            "name": "@c",
            "line": 8
          }
        ],
        "type": "scenario",
        "steps": [
          {
            "keyword": "Given ",
            "name": "this step fails",
            "line": 10,
            "match": {
              "location": "features/step_definitions/steps.rb:4"
            },
            "result": {
              "status": "failed",
              "error_message": " (RuntimeError)\n./features/step_definitions/steps.rb:4:in `/^this step fails$/'\nfeatures/one_passing_one_failing.feature:10:in `Given this step fails'",
              "duration": 1
            }
          }
        ]
      }
    ]
  }
]

Feature: A DocString feature

  Scenario:
    Then I should fail with
      """
      a string
      """

Then /I should fail with/ do |s|
  raise RuntimeError, s
end

[
  {
    "id": "a-docstring-feature",
    "uri": "features/doc_string.feature",
    "keyword": "Feature",
    "name": "A DocString feature",
    "line": 1,
    "description": "",
    "elements": [
      {
        "id": "a-docstring-feature;",
        "keyword": "Scenario",
        "name": "",
        "line": 3,
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "keyword": "Then ",
            "name": "I should fail with",
            "line": 4,
            "doc_string": {
              "content_type": "",
              "value": "a string",
              "line": 5
            },
            "match": {
              "location": "features/step_definitions/steps.rb:1"
            },
            "result": {
              "status": "failed",
              "error_message": "a string (RuntimeError)\n./features/step_definitions/steps.rb:2:in `/I should fail with/'\nfeatures/doc_string.feature:4:in `Then I should fail with'",
              "duration": 1
            }
          }
        ]
      }
    ]
  }
]

[
  {
    "uri": "features/embed.feature",
    "id": "a-screenshot-feature",
    "keyword": "Feature",
    "name": "A screenshot feature",
    "line": 1,
    "description": "",
    "elements": [
      {
        "id": "a-screenshot-feature;",
        "keyword": "Scenario",
        "name": "",
        "line": 3,
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "keyword": "Given ",
            "name": "I embed a screenshot",
            "line": 4,
            "embeddings": [
              {
                "mime_type": "image/png",
                "data": "Zm9v"
              }
            ],
            "match": {
              "location": "features/step_definitions/json_steps.rb:1"
            },
            "result": {
              "status": "passed",
              "duration": 1
            }
          }
        ]
      }
    ]
  }
]

[
  {
    "uri": "features/outline.feature",
    "id": "an-outline-feature",
    "keyword": "Feature",
    "name": "An outline feature",
    "line": 1,
    "description": "",
    "elements": [
      {
        "id": "an-outline-feature;outline;examples1;2",
        "keyword": "Scenario Outline",
        "name": "outline",
        "description": "",
        "line": 8,
        "type": "scenario",
        "steps": [
          {
            "keyword": "Given ",
            "name": "this step passes",
            "line": 8,
            "match": {
              "location": "features/step_definitions/steps.rb:1"
            },
            "result": {
              "status": "passed",
              "duration": 1
            }
          }
        ]
      },
      {
        "id": "an-outline-feature;outline;examples1;3",
        "keyword": "Scenario Outline",
        "name": "outline",
        "description": "",
        "line": 9,
        "type": "scenario",
        "steps": [
          {
            "keyword": "Given ",
            "name": "this step fails",
            "line": 9,
            "match": {
              "location": "features/step_definitions/steps.rb:4"
            },
            "result": {
              "status": "failed",
              "error_message": " (RuntimeError)\n./features/step_definitions/steps.rb:4:in `/^this step fails$/'\nfeatures/outline.feature:9:in `Given this step fails'\nfeatures/outline.feature:4:in `Given this step <status>'",
              "duration": 1
            }
          }
        ]
      },
      {
        "id": "an-outline-feature;outline;examples2;2",
        "keyword": "Scenario Outline",
        "name": "outline",
        "description": "",
        "line": 13,
        "type": "scenario",
        "steps": [
          {
            "keyword": "Given ",
            "name": "this step passes",
            "line": 13,
            "match": {
              "location": "features/step_definitions/steps.rb:1"
            },
            "result": {
              "status": "passed",
              "duration": 1
            }
          }
        ]
      }
    ]
  }
]

[
  {
    "uri": "features/print_from_step_definition.feature",
    "id": "a-print-from-step-definition-feature",
    "keyword": "Feature",
    "name": "A print from step definition feature",
    "line": 1,
    "description": "",
    "elements": [
      {
        "id": "a-print-from-step-definition-feature;",
        "keyword": "Scenario",
        "name": "",
        "line": 3,
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "keyword": "Given ",
            "name": "I print from step definition",
            "line": 4,
            "output": [
              "from step definition"
            ],
            "match": {
              "location": "features/step_definitions/json_steps.rb:6"
            },
            "result": {
              "status": "passed",
              "duration": 1
            }
          },
          {
            "keyword": "And ",
            "name": "I print from step definition",
            "line": 5,
            "output": [
              "from step definition"
            ],
            "match": {
              "location": "features/step_definitions/json_steps.rb:6"
            },
            "result": {
              "status": "passed",
              "duration": 1
            }
          }
        ]
      }
    ]
  }
]

[
  {
    "uri": "features/outline.feature",
    "id": "an-outline-feature",
    "keyword": "Feature",
    "name": "An outline feature",
    "line": 1,
    "description": "",
    "elements": [
      {
        "id": "an-outline-feature;outline;examples1;2",
        "keyword": "Scenario Outline",
        "name": "outline",
        "line": 8,
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "keyword": "Given ",
            "name": "this step passes",
            "line": 8,
            "match": {
              "location": "features/step_definitions/steps.rb:1"
            },
            "result": {
              "status": "passed",
              "duration": 1
            }
          }
        ]
      },
      {
        "id": "an-outline-feature;outline;examples1;3",
        "keyword": "Scenario Outline",
        "name": "outline",
        "line": 9,
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "keyword": "Given ",
            "name": "this step fails",
            "line": 9,
            "match": {
              "location": "features/step_definitions/steps.rb:4"
            },
            "result": {
              "status": "failed",
              "error_message" : " (RuntimeError)\n./features/step_definitions/steps.rb:4:in `/^this step fails$/'\nfeatures/outline.feature:9:in `Given this step fails'\nfeatures/outline.feature:4:in `Given this step <status>'",
"duration": 1
            }
          }
        ]
      },
      {
        "id": "an-outline-feature;outline;examples2;2",
        "keyword": "Scenario Outline",
        "name": "outline",
        "line": 13,
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "keyword": "Given ",
            "name": "this step passes",
            "line": 13,
            "match": {
              "location": "features/step_definitions/steps.rb:1"
            },
            "result": {
              "status": "passed",
              "duration": 1
            }
          }
        ]
      }
    ]
  }
]

[
  {
    "uri": "features/embed_data_directly.feature",
    "id": "an-embed-data-directly-feature",
    "keyword": "Feature",
    "name": "An embed data directly feature",
    "line": 1,
    "description": "",
    "elements": [
      {
        "id": "an-embed-data-directly-feature;",
        "keyword": "Scenario",
        "name": "",
        "line": 3,
        "description": "",
        "type": "scenario",
        "steps": [
          {
            "keyword": "Given ",
            "name": "I embed data directly",
            "line": 4,
            "embeddings": [
              {
  "mime_type": "mime-type",
  "data": "YWJj"
              }
            ],
            "match": {
              "location": "features/step_definitions/json_steps.rb:10"
            },
            "result": {
              "status": "passed",
              "duration": 1
            }
          }
        ]
      },
      {
        "keyword": "Scenario Outline",
        "name": "",
        "line": 11,
        "description": "",
        "id": "an-embed-data-directly-feature;;;2",
        "type": "scenario",
        "steps": [
          {
            "keyword": "Given ",
            "name": "I embed data directly",
            "line": 11,
            "embeddings": [
              {
                "mime_type": "mime-type",
                "data": "YWJj"
              }
            ],
            "match": {
              "location": "features/step_definitions/json_steps.rb:10"
            },
            "result": {
              "status": "passed",
              "duration": 1
            }
          }
        ]
      },
      {
        "keyword": "Scenario Outline",
        "name": "",
        "line": 12,
        "description": "",
        "id": "an-embed-data-directly-feature;;;3",
        "type": "scenario",
        "steps": [
          {
            "keyword": "Given ",
            "name": "I embed data directly",
            "line": 12,
            "embeddings": [
              {
                "mime_type": "mime-type",
                "data": "YWJj"
              }
            ],
            "match": {
              "location": "features/step_definitions/json_steps.rb:10"
            },
            "result": {
              "status": "passed",
              "duration": 1
            }
          }
        ]
      }
    ]
  }
]

Before do
  puts "Before hook 1"
  embed "src", "mime_type", "label"
end

Before do
  puts "Before hook 2"
  embed "src", "mime_type", "label"
end

AfterStep do
  puts "AfterStep hook 1"
  embed "src", "mime_type", "label"
end

AfterStep do
  puts "AfterStep hook 2"
  embed "src", "mime_type", "label"
end

After do
  puts "After hook 1"
  embed "src", "mime_type", "label"
end

After do
  puts "After hook 2"
  embed "src", "mime_type", "label"
end

Feature: One passing scenario, one failing scenario

  Scenario: Passing
    Given this step passes

  Scenario: Failing
    Given this step fails

Feature: Subdirectory - One passing scenario, one failing scenario

  Scenario: Passing
    Given this step passes

  Scenario: Failing
    Given this step fails

Feature: Pending step

  Scenario: Pending
    Given this step is pending

  Scenario: Undefined
    Given this step is undefined

Feature: Pending step

  Scenario: Pending
    Given this step is pending

  Scenario: Undefined
    Given this step is undefined

Feature: Scenario outlines

  Scenario Outline: Using scenario outlines
    Given this step <type>

    Examples:
      | type         |
      | passes       |
      | fails        |
      | is pending   |
      | is undefined |

<?xml version="1.0" encoding="UTF-8"?>
<testsuite failures="1" errors="0" skipped="0" tests="2" time="0.05" name="One passing scenario, one failing scenario">
<testcase classname="One passing scenario, one failing scenario" name="Passing" time="0.05">
  <system-out>
    <![CDATA[]]>
  </system-out>
  <system-err>
    <![CDATA[]]>
  </system-err>
</testcase>
<testcase classname="One passing scenario, one failing scenario" name="Failing" time="0.05">
  <failure message="failed Failing" type="failed">
    <![CDATA[Scenario: Failing

Given this step fails

Message:
]]>
    <![CDATA[ (RuntimeError)
./features/step_definitions/steps.rb:4:in `/^this step fails$/'
features/one_passing_one_failing.feature:7:in `Given this step fails']]>
  </failure>
  <system-out>
    <![CDATA[]]>
  </system-out>
  <system-err>
    <![CDATA[]]>
  </system-err>
</testcase>
</testsuite>

<?xml version="1.0" encoding="UTF-8"?>
<testsuite failures="1" errors="0" skipped="0" tests="2" time="0.05" name="Subdirectory - One passing scenario, one failing scenario">
<testcase classname="Subdirectory - One passing scenario, one failing scenario" name="Passing" time="0.05">
  <system-out>
    <![CDATA[]]>
  </system-out>
  <system-err>
    <![CDATA[]]>
  </system-err>
</testcase>
<testcase classname="Subdirectory - One passing scenario, one failing scenario" name="Failing" time="0.05">
  <failure message="failed Failing" type="failed">
    <![CDATA[Scenario: Failing

Given this step fails

Message:
]]>
    <![CDATA[ (RuntimeError)
./features/step_definitions/steps.rb:4:in `/^this step fails$/'
features/some_subdirectory/one_passing_one_failing.feature:7:in `Given this step fails']]>
  </failure>
  <system-out>
    <![CDATA[]]>
  </system-out>
  <system-err>
    <![CDATA[]]>
  </system-err>
</testcase>
</testsuite>

<?xml version="1.0" encoding="UTF-8"?>
<testsuite failures="0" errors="0" skipped="2" tests="2" time="0.05" name="Pending step">
<testcase classname="Pending step" name="Pending" time="0.05">
  <skipped/>
  <system-out>
    <![CDATA[]]>
  </system-out>
  <system-err>
    <![CDATA[]]>
  </system-err>
</testcase>
<testcase classname="Pending step" name="Undefined" time="0.05">
  <skipped/>
  <system-out>
    <![CDATA[]]>
  </system-out>
  <system-err>
    <![CDATA[]]>
  </system-err>
</testcase>
</testsuite>

<?xml version="1.0" encoding="UTF-8"?>
<testsuite failures="2" errors="0" skipped="0" tests="2" time="0.05" name="Pending step">
<testcase classname="Pending step" name="Pending" time="0.05">
  <failure message="pending Pending" type="pending">
    <![CDATA[Scenario: Pending

Given this step is pending

Message:
]]>
    <![CDATA[TODO (Cucumber::Pending)
./features/step_definitions/steps.rb:3:in `/^this step is pending$/'
features/pending.feature:4:in `Given this step is pending']]>
  </failure>
  <system-out>
    <![CDATA[]]>
  </system-out>
  <system-err>
    <![CDATA[]]>
  </system-err>
</testcase>
<testcase classname="Pending step" name="Undefined" time="0.05">
  <failure message="undefined Undefined" type="undefined">
    <![CDATA[Scenario: Undefined

Given this step is undefined

Message:
]]>
    <![CDATA[Undefined step: "this step is undefined" (Cucumber::Core::Test::Result::Undefined)
features/pending.feature:7:in `Given this step is undefined']]>
  </failure>
  <system-out>
    <![CDATA[]]>
  </system-out>
  <system-err>
    <![CDATA[]]>
  </system-err>
</testcase>
</testsuite>

can't convert .* into String \(TypeError\)

You *must* specify --out DIR for the junit formatter

<?xml version="1.0" encoding="UTF-8"?>
<testsuite failures="3" errors="0" skipped="0" tests="4" time="0.05" name="Scenario outlines">
<testcase classname="Scenario outlines" name="Using scenario outlines (outline example : | passes |)" time="0.05">
  <system-out>
    <![CDATA[]]>
  </system-out>
  <system-err>
    <![CDATA[]]>
  </system-err>
</testcase>
<testcase classname="Scenario outlines" name="Using scenario outlines (outline example : | fails |)" time="0.05">
  <failure message="failed Using scenario outlines (outline example : | fails |)" type="failed">
    <![CDATA[Scenario Outline: Using scenario outlines

Example row: | fails |

Message:
]]>
    <![CDATA[ (RuntimeError)
./features/step_definitions/steps.rb:4:in `/^this step fails$/'
features/scenario_outline.feature:9:in `Given this step fails'
features/scenario_outline.feature:4:in `Given this step <type>']]>
  </failure>
  <system-out>
    <![CDATA[]]>
  </system-out>
  <system-err>
    <![CDATA[]]>
  </system-err>
</testcase>
<testcase classname="Scenario outlines" name="Using scenario outlines (outline example : | is pending |)" time="0.05">
  <failure message="pending Using scenario outlines (outline example : | is pending |)" type="pending">
    <![CDATA[Scenario Outline: Using scenario outlines

Example row: | is pending |

Message:
]]>
    <![CDATA[TODO (Cucumber::Pending)
./features/step_definitions/steps.rb:3:in `/^this step is pending$/'
features/scenario_outline.feature:10:in `Given this step is pending'
features/scenario_outline.feature:4:in `Given this step <type>']]>
  </failure>
  <system-out>
    <![CDATA[]]>
  </system-out>
  <system-err>
    <![CDATA[]]>
  </system-err>
</testcase>
<testcase classname="Scenario outlines" name="Using scenario outlines (outline example : | is undefined |)" time="0.05">
  <failure message="undefined Using scenario outlines (outline example : | is undefined |)" type="undefined">
    <![CDATA[Scenario Outline: Using scenario outlines

Example row: | is undefined |

Message:
]]>
    <![CDATA[Undefined step: "this step is undefined" (Cucumber::Core::Test::Result::Undefined)
features/scenario_outline.feature:11:in `Given this step is undefined'
features/scenario_outline.feature:4:in `Given this step <type>']]>
  </failure>
  <system-out>
    <![CDATA[]]>
  </system-out>
  <system-err>
    <![CDATA[]]>
  </system-err>
</testcase>
</testsuite>

<?xml version="1.0" encoding="UTF-8"?>
<testsuite failures="3" errors="0" skipped="0" tests="4" time="0.05" name="Scenario outlines">
<testcase classname="Scenario outlines" name="Using scenario outlines (outline example : | passes |)" time="0.05">
  <system-out>
    <![CDATA[]]>
  </system-out>
  <system-err>
    <![CDATA[]]>
  </system-err>
</testcase>
<testcase classname="Scenario outlines" name="Using scenario outlines (outline example : | fails |)" time="0.05">
  <failure message="failed Using scenario outlines (outline example : | fails |)" type="failed">
    <![CDATA[Scenario Outline: Using scenario outlines

Example row: | fails |

Message:
]]>
    <![CDATA[ (RuntimeError)
./features/step_definitions/steps.rb:4:in `/^this step fails$/'
features/scenario_outline.feature:9:in `Given this step fails'
features/scenario_outline.feature:4:in `Given this step <type>']]>
  </failure>
  <system-out>
    <![CDATA[]]>
  </system-out>
  <system-err>
    <![CDATA[]]>
  </system-err>
</testcase>
<testcase classname="Scenario outlines" name="Using scenario outlines (outline example : | is pending |)" time="0.05">
  <failure message="pending Using scenario outlines (outline example : | is pending |)" type="pending">
    <![CDATA[Scenario Outline: Using scenario outlines

Example row: | is pending |

Message:
]]>
    <![CDATA[TODO (Cucumber::Pending)
./features/step_definitions/steps.rb:3:in `/^this step is pending$/'
features/scenario_outline.feature:10:in `Given this step is pending'
features/scenario_outline.feature:4:in `Given this step <type>']]>
  </failure>
  <system-out>
    <![CDATA[]]>
  </system-out>
  <system-err>
    <![CDATA[]]>
  </system-err>
</testcase>
<testcase classname="Scenario outlines" name="Using scenario outlines (outline example : | is undefined |)" time="0.05">
  <failure message="undefined Using scenario outlines (outline example : | is undefined |)" type="undefined">
    <![CDATA[Scenario Outline: Using scenario outlines

Example row: | is undefined |

Message:
]]>
    <![CDATA[Undefined step: "this step is undefined" (Cucumber::Core::Test::Result::Undefined)
features/scenario_outline.feature:11:in `Given this step is undefined'
features/scenario_outline.feature:4:in `Given this step <type>']]>
  </failure>
  <system-out>
    <![CDATA[]]>
  </system-out>
  <system-err>
    <![CDATA[]]>
  </system-err>
</testcase>
</testsuite>

      | feature          | "Funcionalidade", "Característica", "Caracteristica"                                         |
      | background       | "Contexto", "Cenário de Fundo", "Cenario de Fundo", "Fundo"                                  |
      | scenario         | "Cenário", "Cenario"                                                                         |
      | scenario_outline | "Esquema do Cenário", "Esquema do Cenario", "Delineação do Cenário", "Delineacao do Cenario" |
      | examples         | "Exemplos", "Cenários", "Cenarios"                                                           |
      | given            | "* ", "Dado ", "Dada ", "Dados ", "Dadas "                                                   |
      | when             | "* ", "Quando "                                                                              |
      | then             | "* ", "Então ", "Entao "                                                                     |
      | and              | "* ", "E "                                                                                   |
      | but              | "* ", "Mas "                                                                                 |
      | given (code)     | "Dado", "Dada", "Dados", "Dadas"                                                             |
      | when (code)      | "Quando"                                                                                     |
      | then (code)      | "Então", "Entao"                                                                             |
      | and (code)       | "E"                                                                                          |
      | but (code)       | "Mas"                                                                                        |

Given(/foo/i)  { }
Given(/b.r/xm) { }

require 'cucumber'
puts Cucumber::StepDefinitions.new.to_json

[
  {"source": "foo", "flags": "i"},
  {"source": "b.r", "flags": "mx"}
]

Given(/foo/)  { }
Given(/b.r/x) { }

require 'cucumber'
puts Cucumber::StepDefinitions.new(:autoload_code_paths => ['my_weird']).to_json

[
  {"source": "foo", "flags": ""},
  {"source": "b.r", "flags": "x"}
]

Given two turtles

Given /a turtle/ do
  puts "turtle!"
end

Given /two turtles/ do
  steps %{
    Given a turtle
    And a turtle
  }
end

turtle!

turtle!

Given /two turtles/ do
  step "a turtle"
  step "a turtle"
end

turtle!

turtle!

Given /turtles:/ do |table|
  table.hashes.each do |row|
    puts row[:name]
  end
end

Given /two turtles/ do
  steps %{
    Given turtles:
      | name      |
      | Sturm     |
      | Liouville |
  }
end

Sturm

Liouville

  Given /two turtles/ do
    steps %Q{
      Given turtles:
         """
         Sturm
         Liouville
         """
    }
  end

Given /turtles:/ do |string|
  puts string
end

Sturm
Liouville

Given /two turtles/ do
  step "I have a couple turtles"
end

When(/I have a couple turtles/) { raise 'error' }

error (RuntimeError)
./features/step_definitions/steps2.rb:5:in `/I have a couple turtles/'
./features/step_definitions/steps2.rb:2:in `/two turtles/'
features/test_feature_1.feature:3:in `Given two turtles'

Failing Scenarios:
cucumber features/test_feature_1.feature:2 # Scenario: Test Scenario 1

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

Feature: Calling undefined step

  Scenario: Call directly
    Given a step that calls an undefined step

  Scenario: Call via another
    Given a step that calls a step that calls an undefined step

Given /^a step that calls an undefined step$/ do
  step 'this does not exist'
end

Given /^a step that calls a step that calls an undefined step$/ do
  step 'a step that calls an undefined step'
end

Feature: Calling undefined step

  Scenario: Call directly
    Given a step that calls an undefined step
      Undefined dynamic step: "this does not exist" (Cucumber::UndefinedDynamicStep)
      ./features/step_definitions/steps.rb:2:in `/^a step that calls an undefined step$/'
      features/call_undefined_step_from_step_def.feature:4:in `Given a step that calls an undefined step'

  Scenario: Call via another
    Given a step that calls a step that calls an undefined step
      Undefined dynamic step: "this does not exist" (Cucumber::UndefinedDynamicStep)
      ./features/step_definitions/steps.rb:2:in `/^a step that calls an undefined step$/'
      ./features/step_definitions/steps.rb:6:in `/^a step that calls a step that calls an undefined step$/'
      features/call_undefined_step_from_step_def.feature:7:in `Given a step that calls a step that calls an undefined step'

Failing Scenarios:
cucumber features/call_undefined_step_from_step_def.feature:3
cucumber features/call_undefined_step_from_step_def.feature:6

2 scenarios (2 failed)
2 steps (2 failed)

前提 two turtles

# -*- coding: utf-8 -*-
前提 /a turtle/ do
  puts "turtle!"
end

# -*- coding: utf-8 -*-
前提 /two turtles/ do
  steps %{
    前提 a turtle
    かつ a turtle
  }
end

turtle!

turtle!

Given two turtles

Given /turtles:/ do |table|
  table.hashes.each do |row|
    puts row[:name]
  end
end

Given /two turtles/ do
  step %{turtles:}, table(%{
  | name      |
  | Sturm     |
  | Liouville |
  })
end

Sturm

Liouville

Given /two turtles/ do
  step %{turtles:}, "Sturm and Lioville"
end

Given /turtles:/ do |text|
  puts text
end

Sturm and Lioville

Given /two turtles/ do
  step %{turtles:}, doc_string('Sturm and Lioville','math')
end

Given /turtles:/ do |text|
  puts text.content_type
end

math

module Driver
  def do_action
    @done = true
  end

  def assert_done
    expect(@done).to be true
  end
end
World(Driver)

When /I do the action/, :do_action
Then /The action should be done/, :assert_done

Feature:
  Scenario:
    When I do the action
    Then the action should be done

class Thing
  def do_action
    @done = true
  end

  def assert_done
    expect(@done).to be true
  end
end

module Driver
  def thing
    @thing ||= Thing.new
  end
end
World(Driver)

When /I do the action to the thing/, :do_action, :on => lambda { thing }
Then /The thing should be done/, :assert_done, :on => lambda { thing }

Feature:
  Scenario:
    When I do the action to the thing
    Then the thing should be done

AfterConfiguration do |config|
  config.options[:blah]
end

Deprecated

AfterConfiguration do |config|
  config.formats << ['html', config.out_stream]
end

html

AfterConfiguration do |config|
  config.out_stream << "AfterConfiguration hook read feature directories: #{config.feature_dirs.join(', ')}"
end

AfterConfiguration hook read feature directories: features

Given /^I use puts with text "(.*)"$/ do |ann|
  puts(ann)
end

Given /^I use multiple putss$/ do
  puts("Multiple")
  puts("Announce","Me")
end

Given /^I use message (.+) in line (.+) (?:with result (.+))$/ do |ann, line, result|
  puts("Last message") if line == "3"
  puts("Line: #{line}: #{ann}")
  fail if result =~ /fail/i
end

Given /^I use puts and step fails$/ do
  puts("Announce with fail")
  fail
end

Given /^I puts the world$/ do
  puts(self)
end

Feature:

  Scenario:
    Given I use puts with text "Ann"
    And this step passes

  Scenario:
    Given I use multiple putss
    And this step passes

  Scenario Outline:
    Given I use message <ann> in line <line>

    Examples:
      | line | ann   |
      | 1    | anno1 |
      | 2    | anno2 |
      | 3    | anno3 |

  Scenario:
    Given I use puts and step fails
    And this step passes

  Scenario Outline:
    Given I use message <ann> in line <line> with result <result>

    Examples:
      | line | ann   | result |
      | 1    | anno1 | fail   |
      | 2    | anno2 | pass   |

Feature: puts_world
  Scenario: puts_world
    Given I puts the world

Feature:

  Scenario:
    Given I use puts with text "Ann"
      Ann
    And this step passes

  Scenario:
    Given I use multiple putss
      Multiple
      Announce
      Me
    And this step passes

  Scenario Outline:
    Given I use message <ann> in line <line>

    Examples:
      | line | ann   |
      | 1    | anno1 |
      | 2    | anno2 |
      | 3    | anno3 |

  Scenario:
    Given I use puts and step fails
      Announce with fail
       (RuntimeError)
      ./features/step_definitions/puts_steps.rb:18:in `/^I use puts and step fails$/'
      features/f.feature:21:in `Given I use puts and step fails'
    And this step passes

  Scenario Outline:
    Given I use message <ann> in line <line> with result <result>

    Examples:
      | line | ann   | result |
      | 1    | anno1 | fail   |  Line: 1: anno1
       (RuntimeError)
      ./features/step_definitions/puts_steps.rb:13:in `/^I use message (.+) in line (.+) (?:with result (.+))$/'
      features/f.feature:29:in `Given I use message anno1 in line 1 with result fail'
      features/f.feature:25:in `Given I use message <ann> in line <line> with result <result>'
      | 2    | anno2 | pass   |  Line: 2: anno2

Ann
..
Multiple

Announce

Me
..UUU
Announce with fail
F-
Line: 1: anno1
F
Line: 2: anno2
.

Feature:

  Scenario Outline:
    Given this step is undefined

  Examples:
    |foo|
    |bar|

  default: -r features

Using the default profile...

Feature:
  Scenario:
    Given this step passes

Before do
  puts "Before hook"
 end

AfterStep do
  puts "AfterStep hook"
end

After do
  puts "After hook"
raise "error"
end

Feature:

  Scenario:
      Before hook
    Given this step passes
      AfterStep hook
      After hook
      error (RuntimeError)
      ./features/step_definitions/output_steps.rb:11:in `After'

Failing Scenarios:
cucumber features/test.feature:2

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

Feature: Sample
  Scenario: this is a test
    Given this step raises an error

default: features/sample.feature --require features/support/env.rb -v
super: features/sample.feature --require features/support/super_env.rb -v

Using the super profile...

<% requires = "--require features/support/super_env.rb" %>
super: <%= "features/sample.feature #{requires} -v" %>

Using the super profile...

Using the default and super profiles...

Could not find profile: 'foo'

Defined profiles in cucumber.yml:
  * default
  * super

Disabling profiles...

Disabling profiles...