cucumber 2.0.0.rc.4 → 4.0.0.rc.2

data/features/docs/cli/run_specific_scenarios.feature

@@ -1,130 +0,0 @@
-Feature: Run specific scenarios
-
-  You can choose to run a specific scenario using the file:line format,
-  or you can pass in a file with a list of scenarios using @-notation.
-
-  Background:
-    Given the standard step definitions
-
-  Scenario: Two scenarios, run just one of them
-    Given a file named "features/test.feature" with:
-      """
-      Feature: 
-        Scenario:
-          Given this step is undefined
-
-        Scenario: Hit
-          Given this step passes
-      """
-    When I run `cucumber features/test.feature:5 -f progress`
-    Then it should pass with:
-      """
-      1 scenario (1 passed)
-      """
-
-  Scenario: Single example from a scenario outline
-    Given a file named "features/test.feature" with:
-      """
-      Feature:
-        Scenario Outline:
-          Given this step <something>
-
-          Examples:
-            | something    |
-            | is undefined |
-            | fails        |
-
-        Scenario: Miss
-          Given this step passes
-      """
-    When I run `cucumber features/test.feature:8 -f progress`
-    Then it should fail with:
-      """
-      1 scenario (1 failed)
-      """
-
-  @spawn
-  Scenario: Specify 2 line numbers where one is a tag
-    Given a file named "features/test.feature" with:
-      """
-      Feature: Sample
-
-        @two @three
-        Scenario:
-          Given this step passes
-
-        @four
-        Scenario:
-          Given this step passes
-      """
-    When I run `cucumber -q features/test.feature:3:8`
-    Then it should pass with:
-      """
-      2 scenarios (2 passed)
-      2 steps (2 passed)
-      """
-
-  Scenario: Specify the line number of a row
-    Given a file named "features/test.feature" with:
-      """
-      Feature: Sample
-        Scenario: Passing
-          Given this step is a table step
-            | a | b |
-            | c | d |
-
-      """
-    When I run `cucumber -q features/test.feature:4`
-    Then it should pass with:
-      """
-      Feature: Sample
-
-        Scenario: Passing
-          Given this step is a table step
-            | a | b |
-            | c | d |
-
-      1 scenario (1 passed)
-      1 step (1 passed)
-
-      """
-
-  Scenario: Use @-notation to specify a file containing feature file list
-    Given a file named "features/test.feature" with:
-      """
-      Feature: Sample
-        Scenario: Passing
-          Given this step passes
-      """
-    And a file named "list-of-features.txt" with:
-      """
-      features/test.feature:2
-      """
-    When I run `cucumber -q @list-of-features.txt`
-    Then it should pass with:
-      """
-      Feature: Sample
-
-        Scenario: Passing
-          Given this step passes
-
-      1 scenario (1 passed)
-      1 step (1 passed)
-      """
-
-  Scenario: Specify order of scenarios
-    Given a file named "features/test.feature" with:
-      """
-      Feature: 
-        Scenario:
-          Given this step passes
-
-        Scenario:
-          Given this step fails
-      """
-    When I run `cucumber features/test.feature:5 features/test.feature:3 -f progress`
-    Then it should fail with:
-      """
-      F.
-      """
-

data/features/docs/cli/showing_differences.feature

@@ -1,43 +0,0 @@
-Feature: Showing differences to expected output
-
-  Cucumber will helpfully show you the expectation error that your
-  testing library gives you, in the context of the failing scenario.
-  When using RSpec, for example, this will show the difference between
-  the expected and the actual output.
-
-  Scenario: Run single failing scenario with default diff enabled
-    Given a file named "features/failing_expectation.feature" with:
-      """
-      Feature: Failing expectation
-
-        Scenario: Failing expectation
-          Given failing expectation
-      """
-    And a file named "features/step_definitions/steps.rb" with:
-      """
-      Given /^failing expectation$/ do x=1
-        expect('this').to eq 'that'
-      end
-      """
-    When I run `cucumber -q features/failing_expectation.feature`
-    Then it should fail with:
-      """
-      Feature: Failing expectation
-      
-        Scenario: Failing expectation
-          Given failing expectation
-            
-            expected: "that"
-                 got: "this"
-            
-            (compared using ==)
-             (RSpec::Expectations::ExpectationNotMetError)
-            ./features/step_definitions/steps.rb:2:in `/^failing expectation$/'
-            features/failing_expectation.feature:4:in `Given failing expectation'
-
-      Failing Scenarios:
-      cucumber features/failing_expectation.feature:3
-
-      1 scenario (1 failed)
-      1 step (1 failed)
-      """

data/features/docs/cli/specifying_multiple_formatters.feature

@@ -1,44 +0,0 @@
-@spawn
-Feature: Running multiple formatters
-
-  When running cucumber, you are able to using multiple different
-  formatters and redirect the output to text files.
-
-  Scenario: Multiple formatters and outputs
-    Given a file named "features/test.feature" with:
-    """
-    Feature: Lots of undefined
-
-      Scenario: Implement me
-        Given it snows in Sahara
-        Given it's 40 degrees in Norway
-        And it's 40 degrees in Norway
-        When I stop procrastinating
-        And there is world peace
-    """
-    When I run `cucumber --no-color --format progress --out progress.txt --format pretty --out pretty.txt --no-source --dry-run --no-snippets features/test.feature`
-    Then the stderr should not contain anything
-    Then the file "progress.txt" should contain:
-      """
-      UUUUU
-
-      1 scenario (1 undefined)
-      5 steps (5 undefined)
-
-      """
-    And the file "pretty.txt" should contain:
-      """
-      Feature: Lots of undefined
-
-        Scenario: Implement me
-          Given it snows in Sahara
-          Given it's 40 degrees in Norway
-          And it's 40 degrees in Norway
-          When I stop procrastinating
-          And there is world peace
-
-      1 scenario (1 undefined)
-      5 steps (5 undefined)
-
-      """
-

data/features/docs/cli/strict_mode.feature

@@ -1,41 +0,0 @@
-Feature: Strict mode
-
-  Using the `--strict` flag will cause cucumber to fail unless all the
-  step definitions have been defined.
-
-  Background:
-    Given a file named "features/missing.feature" with:
-    """
-    Feature: Missing
-      Scenario: Missing
-        Given this step passes
-    """
-
-  Scenario: Fail with --strict
-    When I run `cucumber -q features/missing.feature --strict`
-    Then it should fail with:
-      """
-      Feature: Missing
-
-        Scenario: Missing
-          Given this step passes
-            Undefined step: "this step passes" (Cucumber::Undefined)
-            features/missing.feature:3:in `Given this step passes'
-
-      1 scenario (1 undefined)
-      1 step (1 undefined)
-      """
-
-  Scenario: Succeed with --strict
-    Given the standard step definitions
-    When I run `cucumber -q features/missing.feature --strict`
-    Then it should pass with:
-    """
-    Feature: Missing
-
-      Scenario: Missing
-        Given this step passes
-
-    1 scenario (1 passed)
-    1 step (1 passed)
-    """

data/features/docs/defining_steps/nested_steps.feature

@@ -1,129 +0,0 @@
-Feature: Nested Steps
-
-  Background:
-    Given a scenario with a step that looks like this:
-      """gherkin
-      Given two turtles
-      """
-    And a step definition that looks like this:
-      """ruby
-      Given /a turtle/ do
-        puts "turtle!"
-      end
-      """
-
-  Scenario: Use #steps to call several steps at once
-    Given a step definition that looks like this:
-      """ruby
-      Given /two turtles/ do
-        steps %{
-          Given a turtle
-          And a turtle
-        }
-      end
-      """
-    When I run the feature with the progress formatter
-    Then the output should contain:
-      """
-      turtle!
-
-      turtle!
-
-      """
-
-  Scenario: Use #step to call a single step
-    Given a step definition that looks like this:
-      """ruby
-      Given /two turtles/ do
-        step "a turtle"
-        step "a turtle"
-      end
-      """
-    When I run the feature with the progress formatter
-    Then the output should contain:
-      """
-      turtle!
-
-      turtle!
-
-      """
-
-  Scenario: Use #steps to call a table
-    Given a step definition that looks like this:
-      """ruby
-      Given /turtles:/ do |table|
-        table.hashes.each do |row|
-          puts row[:name]
-        end
-      end
-      """
-    And a step definition that looks like this:
-      """ruby
-      Given /two turtles/ do
-        steps %{
-          Given turtles:
-            | name      |
-            | Sturm     |
-            | Liouville |
-        }
-      end
-      """
-    When I run the feature with the progress formatter
-    Then the output should contain:
-      """
-      Sturm
-
-      Liouville
-
-      """
-
-  Scenario: Use #steps to call a multi-line string
-    Given a step definition that looks like this:
-      """ruby
-        Given /two turtles/ do
-          steps %Q{
-            Given turtles:
-               \"\"\"
-               Sturm
-               Liouville
-               \"\"\"
-          }
-        end
-      """
-    And a step definition that looks like this:
-      """ruby
-      Given /turtles:/ do |string|
-        puts string
-      end
-      """
-    When I run the feature with the progress formatter
-    Then the output should contain:
-      """
-      Sturm
-      Liouville
-      """
-
-  @spawn
-  Scenario: Backtrace doesn't skip nested steps
-    Given a step definition that looks like this:
-      """ruby
-      Given /two turtles/ do
-        step "I have a couple turtles"
-      end
-
-      When(/I have a couple turtles/) { raise 'error' }
-      """
-    When I run the feature with the progress formatter
-    Then it should fail with:
-      """
-      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)
-      """

data/features/docs/defining_steps/nested_steps_i18n.feature

@@ -1,34 +0,0 @@
-Feature: Nested Steps in I18n
-
-  Background:
-    Given a scenario with a step that looks like this in japanese:
-      """gherkin
-      前提 two turtles
-      """
-    And a step definition that looks like this:
-      """ruby
-      # -*- coding: utf-8 -*-
-      前提 /a turtle/ do
-        puts "turtle!"
-      end
-      """
-
-  Scenario: Use #steps to call several steps at once
-    Given a step definition that looks like this:
-      """ruby
-      # -*- coding: utf-8 -*-
-      前提 /two turtles/ do
-        steps %{
-          前提 a turtle
-          かつ a turtle
-        }
-      end
-      """
-    When I run the feature with the progress formatter
-    Then the output should contain:
-      """
-      turtle!
-
-      turtle!
-
-      """

data/features/docs/defining_steps/nested_steps_with_second_arg.feature

@@ -1,73 +0,0 @@
-Feature: Nested Steps with either table or doc string
-
-  Background:
-    Given a scenario with a step that looks like this:
-      """gherkin
-      Given two turtles
-      """
-
-  Scenario: Use #step with table
-    Given a step definition that looks like this:
-      """ruby
-      Given /turtles:/ do |table|
-        table.hashes.each do |row|
-          puts row[:name]
-        end
-      end
-      """
-    And a step definition that looks like this:
-      """ruby
-      Given /two turtles/ do
-        step %{turtles:}, table(%{
-        | name      |
-        | Sturm     |
-        | Liouville |
-        })
-      end
-      """
-    When I run the feature with the progress formatter
-    Then the output should contain:
-      """
-      Sturm
-
-      Liouville
-
-      """
-
-  Scenario: Use #step with docstring
-    Given a step definition that looks like this:
-      """ruby
-      Given /two turtles/ do
-        step %{turtles:}, "Sturm and Lioville"
-      end
-      """
-    And a step definition that looks like this:
-      """ruby
-      Given /turtles:/ do |text|
-        puts text
-      end
-      """
-    When I run the feature with the progress formatter
-    Then the output should contain:
-      """
-      Sturm and Lioville
-      """
-
-  Scenario: Use #step with docstring and content-type
-    Given a step definition that looks like this:
-      """ruby
-      Given /two turtles/ do
-        step %{turtles:}, doc_string('Sturm and Lioville','math')
-      end
-      """
-    And a step definition that looks like this:
-      """ruby
-      Given /turtles:/ do |text|
-        puts text.content_type
-      end
-      """
-    When I run the feature with the progress formatter
-    Then the output should contain:
-      """
-      math
-      """