casecumber 1.0.2.1

data/examples/v8/features/step_definitions/fib_steps.js

@@ -0,0 +1,49 @@
+Before(function(){
+  fibResult = 0;
+});
+
+Before(['@do-fibonnacci-in-before-hook', '@reviewed'], function(){
+  fibResult = fibonacciSeries(3);
+});
+
+After(function(){
+  //throw 'Sabotage scenario';
+});
+
+Transform(/^(\d+)$/, function(n){
+  return parseInt(n);
+});
+
+When(/^I ask Javascript to calculate fibonacci up to (\d+)$/, function(n){
+  assertEqual(fibResult, 0);
+  fibResult = fibonacciSeries(n);
+});
+
+When(/^I ask Javascript to calculate fibonacci up to (\d+) with formatting$/, function(n){
+  assertEqual(0, fibResult)
+  fibResult = fibonacciSeriesFormatted(n);
+});
+
+Then(/^it should give me (\[.*\])$/, function(expectedResult){
+  assertEqual(expectedResult, fibResult)
+});
+
+Then(/^it should give me:$/, function(string){
+  assertEqual(string, fibResult);
+});
+
+Then(/^it should contain:$/, function(table){
+  var hashes = table.hashes;
+  assertMatches(hashes[0]['cell 1'], fibResult);
+  assertMatches(hashes[0]['cell 2'], fibResult);
+});
+
+Then(/^it should give me (\[.*\]) via calling another step definition$/, function(expectedResult){
+  Given("I ask Javascript to calculate fibonacci up to 2");
+  assertEqual(expectedResult, fibResult);
+});
+
+Then(/^it should calculate fibonacci up to (\d+) giving me (\[.*\])/, function(n, expectedResult){
+  steps("Given I ask Javascript to calculate fibonacci up to "+ n + "\n" +
+        "Then it should give me "+ expectedResult);
+});

data/examples/v8/features/support/env.js

@@ -0,0 +1,14 @@
+//The path is relative to the folder which contains the features folder
+World(['lib/fibonacci.js']);
+
+function assertEqual(expected, actual){
+  if(expected != actual){
+    throw 'Expected <' + expected + "> but got <" + actual + ">";
+  }
+}
+
+function assertMatches(expected, actual){
+  if(actual.indexOf(expected) == -1){
+    throw 'Expected <' + expected + "> to contain <" + actual + "> but it did not";
+  }
+}

data/examples/v8/lib/fibonacci.js

@@ -0,0 +1,19 @@
+function fibonacci(n){
+  return n<2?n:fibonacci(n-1)+fibonacci(n-2);
+}
+
+var fibonacciSeries = function(fibonacciLimit) {
+  var result = Array();
+  var currentfibonacciValue = fibonacci(1);
+  var i = 2;
+  while(currentfibonacciValue < fibonacciLimit) {
+    result.push(currentfibonacciValue);
+    currentfibonacciValue  = fibonacci(i);
+    i++;
+  }
+  return "[" + result.join(", ") + "]";
+}
+
+var fibonacciSeriesFormatted = function(fibonacciLimit){
+  return "\n'" + fibonacciSeries(fibonacciLimit) + "'\n"
+}

data/examples/watir/.gitignore

@@ -0,0 +1,2 @@
+*.html
+*.png

data/examples/watir/README.textile

@@ -0,0 +1,16 @@
+Here you'll find examples for Watir, FireWatir, SafariWatir and Celerity.
+All of these browser libraries have the same API, so the example code will
+work with all of them.
+
+Just run with:
+
+  rake cucumber
+  
+This will use Watir/IE if you're on Windows, and SafariWatir/Safari if you're on OS X.
+You can force the use of FireWatir/Firefox on any platform like this:
+
+  rake features FIREWATIR=true
+  
+And finally, you can use Celerity by running in JRuby:
+
+  jruby -S rake cucumber

data/examples/watir/Rakefile

@@ -0,0 +1,12 @@
+$:.unshift(File.dirname(__FILE__) + '/../../lib')
+require 'cucumber/rake/task'
+
+Cucumber::Rake::Task.new do |t|
+  t.cucumber_opts = %w{--format pretty}
+end
+
+Cucumber::Rake::Task.new(:cucumber_screenshot) do |t|
+  t.cucumber_opts = %w{--format html --out report.html}
+end
+
+task :default => :cucumber

data/examples/watir/cucumber.yml

@@ -0,0 +1 @@
+default: --format html --out report.html --format pretty

data/examples/watir/features/search.feature

@@ -0,0 +1,12 @@
+Feature: Search
+  In order to learn more
+  As an information seeker
+  I want to find more information
+
+  Scenario: Find what I'm looking for
+    Given I am on the Google search page
+    When I search for "cucumber github"
+    Then I should see
+      """
+      GitHub
+      """

data/examples/watir/features/step_definitions/search_steps.rb

@@ -0,0 +1,26 @@
+# Full Watir API: http://wtr.rubyforge.org/rdoc/
+# Full RSpec API: http://rspec.rubyforge.org/
+
+Given 'I am on the Google search page' do
+  @browser.goto 'http://www.google.com/'
+end
+
+When /I search for "(.*)"/ do |query|
+  @browser.text_field(:name, 'q').set(query)
+  @browser.button(:name, 'btnG').click
+end
+
+Then /I should see/ do |text|
+  @browser.text.should =~ /#{text}/m
+end
+
+# To avoid step definitions that are tightly coupled to your user interface,
+# consider creating classes for your pages - such as this:
+# http://github.com/cucumber/cucumber/tree/v0.1.15/examples/watir/features/step_definitons/search_steps.rb
+#
+# You may keep the page classes along your steps, or even better, put them in separate files, e.g.
+# support/pages/google_search.rb
+#
+# This technique is called "Page Objects", and you can read more about it here:
+# http://github.com/marekj/watirloo/tree/master
+# We're not using this technique here, since we want to illustrate the basics only.

data/examples/watir/features/support/env.rb

@@ -0,0 +1,32 @@
+begin require 'rspec/expectations'; rescue LoadError; require 'spec/expectations'; end
+
+if ENV['FIREWATIR']
+  require 'firewatir'
+  Browser = FireWatir::Firefox
+else
+  case RUBY_PLATFORM
+  when /darwin/
+    require 'safariwatir'
+    Browser = Watir::Safari
+  when /win32|mingw/
+    require 'watir'
+    Browser = Watir::IE
+  when /java/
+    require 'celerity'
+    Browser = Celerity::Browser
+  else
+    raise "This platform is not supported (#{PLATFORM})"
+  end
+end
+
+# "before all"
+browser = Browser.new
+
+Before do
+  @browser = browser
+end
+
+# "after all"
+at_exit do
+  browser.close
+end

data/examples/watir/features/support/screenshots.rb

@@ -0,0 +1,47 @@
+# This is an example of how you can set up screenshots for your
+# browser testing. Just run cucumber with --format html --out report.html
+#
+# The code below will work on OS X or Windows (with IE Watir only).
+# Adding support for other platforms should be easy - as long as there is a 
+# ruby library or command line tool to take pictures.
+#
+module Screenshots
+  if Cucumber::OS_X
+    def embed_screenshot(id)
+      `screencapture -t png #{id}.png`
+      embed("#{id}.png", "image/png")
+    end
+  elsif Cucumber::WINDOWS
+    # http://wtr.rubyforge.org/rdoc/classes/Watir/ScreenCapture.html
+    require 'watir/screen_capture'
+    include Watir::ScreenCapture
+    def embed_screenshot(id)
+      screen_capture("#{id}.jpg", true)
+      embed("#{id}.jpg", "image/jpeg")
+    end
+  else
+    # Other platforms...
+    def embed_screenshot(id)
+      STDERR.puts "Sorry - no screenshots on your platform yet."
+    end
+  end
+end
+World(Screenshots)
+
+After do
+  embed_screenshot("screenshot-#{Time.new.to_i}")
+end
+
+# Other variants:
+#
+# Only take screenshot on failures
+#
+#   After do |scenario|
+#     embed_screenshot("screenshot-#{Time.new.to_i}") if scenario.failed?
+#   end
+#
+# Only take screenshot for scenarios or features tagged @screenshot
+#
+#   After(@screenshot) do
+#     embed_screenshot("screenshot-#{Time.new.to_i}")
+#   end

data/features/background.feature

@@ -0,0 +1,498 @@
+Feature: Background
+  In order to provide a context to my scenarios within a feature
+  As a feature editor
+  I want to write a background section in my features.
+
+  Background:
+    Given a file named "features/passing_background.feature" with:
+      """
+      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
+      """
+    And a file named "features/scenario_outline_passing_background.feature" with:
+      """
+      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  |
+      """
+    And a file named "features/background_tagged_before_on_outline.feature" with:
+      """
+      @background_tagged_before_on_outline
+      Feature: Background tagged Before on Outline
+
+        Background: 
+          Given passing without a table
+
+        Scenario Outline: passing background
+          Then I should have '<count>' cukes
+
+          Examples: 
+            | count |
+            | 888   |
+      """
+    And a file named "features/failing_background.feature" with:
+      """
+      Feature: Failing background sample
+
+        Background:
+          Given failing without a table
+          And '10' cukes
+
+        Scenario: failing background
+          Then I should have '10' cukes
+
+        Scenario: another failing background
+          Then I should have '10' cukes
+      """
+    And a file named "features/scenario_outline_failing_background.feature" with:
+      """
+      Feature: Failing background with scenario outlines sample
+
+        Background:
+          Given failing without a table
+
+        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  |
+      """
+    And a file named "features/pending_background.feature" with:
+      """
+      Feature: Pending background sample
+
+        Background:
+          Given pending
+
+        Scenario: pending background
+          Then I should have '10' cukes
+
+        Scenario: another pending background
+          Then I should have '10' cukes
+      """
+    And a file named "features/failing_background_after_success.feature" with:
+      """
+      Feature: Failing background after previously successful background sample
+
+        Background:
+          Given passing without a table
+          And '10' global cukes
+
+        Scenario: passing background
+          Then I should have '10' global cukes
+
+        Scenario: failing background
+          Then I should have '10' global cukes
+      """
+    And a file named "features/multiline_args_background.feature" with:
+      """
+      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
+            \"\"\"
+      """
+    And a file named "features/step_definitions/steps.rb" with:
+      """
+      def flunker
+        raise "FAIL"
+      end
+
+      Given /^'(.+)' cukes$/ do |cukes| x=1
+        raise "We already have #{@cukes} cukes!" if @cukes
+        @cukes = cukes
+      end
+
+      Given(/^passing without a table$/) do
+      end
+
+      Given /^failing without a table$/ do x=1
+        flunker
+      end
+
+      Given /^'(.+)' global cukes$/ do |cukes| x=1
+        $scenario_runs ||= 0
+        flunker if $scenario_runs >= 1
+        $cukes = cukes
+        $scenario_runs += 1
+      end
+
+      Then /^I should have '(.+)' global cukes$/ do |cukes| x=1
+        $cukes.should == cukes
+      end
+
+      Then /^I should have '(.+)' cukes$/ do |cukes| x=1
+        @cukes.should == cukes
+      end
+
+      Before('@background_tagged_before_on_outline') do
+        @cukes = '888'
+      end
+
+      After('@background_tagged_before_on_outline') do
+        @cukes.should == '888'
+      end
+      """
+
+  Scenario: run a specific scenario with a background
+    When I run `cucumber -q features/passing_background.feature:9`
+    Then it should pass with exactly:
+    """
+    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)
+    0m0.012s
+
+    """
+  
+  Scenario: run a feature with a background that passes
+    When I run `cucumber -q features/passing_background.feature`
+    Then it should pass with exactly:
+    """
+    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)
+    0m0.012s
+
+    """
+
+  Scenario: run a feature with scenario outlines that has a background that passes
+    When I run `cucumber -q features/scenario_outline_passing_background.feature`
+    Then it should pass with exactly:
+    """
+    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)
+    0m0.012s
+
+    """
+
+  Scenario: run a feature with scenario outlines that has a background that passes
+    When I run `cucumber -q features/background_tagged_before_on_outline.feature`
+    Then it should pass with exactly:
+    """
+    @background_tagged_before_on_outline
+    Feature: Background tagged Before on Outline
+
+      Background: 
+        Given passing without a table
+
+      Scenario Outline: passing background
+        Then I should have '<count>' cukes
+
+        Examples: 
+          | count |
+          | 888   |
+
+    1 scenario (1 passed)
+    2 steps (2 passed)
+    0m0.012s
+
+    """
+
+  Scenario: run a feature with a background that fails
+    When I run `cucumber -q features/failing_background.feature`
+    Then it should fail with exactly:
+    """
+    Feature: Failing background sample
+
+      Background: 
+        Given failing without a table
+          FAIL (RuntimeError)
+          ./features/step_definitions/steps.rb:2:in `flunker'
+          ./features/step_definitions/steps.rb:14:in `/^failing without a table$/'
+          features/failing_background.feature:4:in `Given failing without a table'
+        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
+    
+    2 scenarios (1 failed, 1 skipped)
+    6 steps (1 failed, 5 skipped)
+    0m0.012s
+    
+    """
+
+  Scenario: run a feature with scenario outlines that has a background that fails
+    When I run `cucumber -q features/scenario_outline_failing_background.feature`
+    Then it should fail with exactly:
+    """
+    Feature: Failing background with scenario outlines sample
+
+      Background: 
+        Given failing without a table
+          FAIL (RuntimeError)
+          ./features/step_definitions/steps.rb:2:in `flunker'
+          ./features/step_definitions/steps.rb:14:in `/^failing without a table$/'
+          features/scenario_outline_failing_background.feature:4:in `Given failing without a table'
+
+      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:6
+
+    2 scenarios (1 failed, 1 skipped)
+    4 steps (1 failed, 3 skipped)
+    0m0.012s
+    
+    """
+
+  Scenario: run a feature with a background that is pending
+    When I run `cucumber -q features/pending_background.feature`
+    Then it should pass with exactly:
+    """
+    Feature: Pending background sample
+
+      Background: 
+        Given pending
+
+      Scenario: pending background
+        Then I should have '10' cukes
+
+      Scenario: another pending background
+        Then I should have '10' cukes
+
+    2 scenarios (2 undefined)
+    4 steps (2 skipped, 2 undefined)
+    0m0.012s
+    
+    """
+
+  Scenario: background passes with first scenario but fails with second
+    When I run `cucumber -q features/failing_background_after_success.feature`
+    Then it should fail with exactly:
+    """
+    Feature: Failing background after previously successful background sample
+
+      Background: 
+        Given passing without a table
+        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/steps.rb:2:in `flunker'
+          ./features/step_definitions/steps.rb:19: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)
+    0m0.012s
+    
+    """
+
+  Scenario: background with multline args
+    Given a file named "features/step_definitions/multiline_steps.rb" with:
+      """
+      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
+        @table.raw.should == table.raw
+      end
+
+      Then /^the multiline string should be$/ do |string| x=1
+        @multiline.should == string
+      end
+      """
+    When I run `cucumber -q features/multiline_args_background.feature`
+    Then it should pass with exactly:
+      """
+      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)
+      0m0.012s
+    
+      """
+
+  Scenario: https://rspec.lighthouseapp.com/projects/16211/tickets/329
+    Given a file named "features/only_background_and_hooks.feature" with:
+      """
+      Feature: woo yeah
+
+        Background: Whatever
+          Given whatever
+
+      """
+    And a file named "features/only_background_and_hooks_steps.rb" with:
+      """
+      begin require 'rspec/expectations'; rescue LoadError; require 'spec/expectations'; end
+
+      Before do
+        $before = true
+      end
+
+      After do
+        $after = true
+      end
+
+      Given(/^whatever$/) { $before.should == true; $step = true }
+
+      at_exit do
+        $before.should == true
+        $step.should == true
+        $after.should == true
+      end
+      """
+    When I run `cucumber features/only_background_and_hooks.feature`
+    Then it should pass with exactly:
+      """
+      Feature: woo yeah
+
+        Background: Whatever # features/only_background_and_hooks.feature:3
+          Given whatever     # features/only_background_and_hooks_steps.rb:11
+
+      0 scenarios
+      1 step (1 passed)
+      0m0.012s
+
+      """