square-cucumber 0.3.12.2

data/spec/cucumber/cli/drb_client_spec.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+
+module Cucumber
+  module Cli
+    describe DRbClient do
+      before(:each) do
+        @args = ['features']
+        @error_stream = StringIO.new
+        @out_stream = StringIO.new
+
+        @drb_object = mock('DRbObject', :run => true)
+        DRbObject.stub!(:new_with_uri).and_return(@drb_object)
+      end
+
+      it "starts up a druby service" do
+        DRb.should_receive(:start_service).with("druby://localhost:0")
+        DRbClient.run(@args, @error_stream, @out_stream)
+      end
+
+      it "connects to the DRb server" do
+        DRbObject.should_receive(:new_with_uri).with("druby://127.0.0.1:8990")
+        DRbClient.run(@args, @error_stream, @out_stream)
+      end
+
+      it "runs the fearures on the DRb server" do
+        @drb_object.should_receive(:run).with(@args, @error_stream, @out_stream)
+        DRbClient.run(@args, @error_stream, @out_stream)
+      end
+
+      it "returns raises an error when it can't connect to the server" do
+        DRbObject.stub!(:new_with_uri).and_raise(DRb::DRbConnError)
+        running { DRbClient.run(@args, @error_stream, @out_stream) }.should raise_error(DRbClientError, "No DRb server is running.")
+      end
+
+      it "returns the result from the DRb server call" do
+        @drb_object.should_receive(:run).and_return('foo')
+        DRbClient.run(@args, @error_stream, @out_stream).should == 'foo'
+      end
+
+    end
+  end
+end

data/spec/cucumber/cli/main_spec.rb

@@ -0,0 +1,140 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'yaml'
+begin
+  require 'spec/runner/differs/default' # RSpec >=1.2.4
+rescue ::LoadError
+  require 'spec/expectations/differs/default' # RSpec <=1.2.3
+end
+
+module Cucumber
+  module Cli
+    describe Main do
+      before(:each) do
+        @out = StringIO.new
+        @err = StringIO.new
+        Kernel.stub!(:exit).and_return(nil)
+      end
+
+      describe "verbose mode" do
+
+        before(:each) do
+          @empty_feature = Ast::Feature.new(nil, Ast::Comment.new(''), Ast::Tags.new(2, []), "Feature", [])
+          Dir.stub!(:[])
+        end
+
+        it "should show ruby files required" do
+          @cli = Main.new(%w{--verbose --require example.rb}, @out)
+          @cli.stub!(:require)
+
+          @cli.execute!(Object.new.extend(StepMother))
+
+          @out.string.should include('example.rb')
+        end
+
+        it "should show feature files parsed" do
+          @cli = Main.new(%w{--verbose example.feature}, @out)
+          @cli.stub!(:require)
+
+          FeatureFile.stub!(:new).and_return(mock("feature file", :parse => @empty_feature))
+
+          @cli.execute!(Object.new.extend(StepMother))
+
+          @out.string.should include('example.feature')
+        end
+
+      end
+
+      describe "diffing" do
+
+        before :each do
+          @configuration = mock('Configuration', :null_object => true, :drb? => false)
+          Configuration.should_receive(:new).and_return(@configuration)
+
+          @step_mother = mock('StepMother', :null_object => true)
+
+          @cli = Main.new(nil, @out)
+        end
+
+        it "uses Spec Differ::Default when diff is enabled" do
+          @configuration.should_receive(:diff_enabled?).and_return(true)
+
+          ::Spec::Expectations::Differs::Default.should_receive(:new)
+
+          @cli.execute!(@step_mother)
+        end
+
+        it "does not use Spec Differ::Default when diff is disabled" do
+          @configuration.should_receive(:diff_enabled?).and_return(false)
+
+          ::Spec::Expectations::Differs::Default.should_not_receive(:new)
+
+          @cli.execute!(@step_mother)
+        end
+
+      end
+
+      describe "--format with class" do
+
+       describe "in module" do
+
+          it "should resolve each module until it gets Formatter class" do
+            cli = Main.new(%w{--format ZooModule::MonkeyFormatterClass}, nil)
+            mock_module = mock('module')
+            Object.stub!(:const_defined?).and_return(true)
+            mock_module.stub!(:const_defined?).and_return(true)
+
+            f = stub('formatter', :null_object => true)
+
+            Object.should_receive(:const_get).with('ZooModule').and_return(mock_module)
+            mock_module.should_receive(:const_get).with('MonkeyFormatterClass').and_return(mock('formatter class', :new => f))
+
+            cli.execute!(Object.new.extend(StepMother))
+          end
+
+        end
+      end
+
+      context "--drb" do
+        before(:each) do
+          @configuration = mock('Configuration', :drb? => true, :null_object => true)
+          Configuration.stub!(:new).and_return(@configuration)
+
+          @args = ['features']
+
+          @cli = Main.new(@args, @out, @err)
+          @step_mother = mock('StepMother', :null_object => true)
+        end
+
+        it "delegates the execution to the DRB client passing the args and streams" do
+          DRbClient.should_receive(:run).with(@args, @err, @out).and_return(true)
+          @cli.execute!(@step_mother)
+        end
+
+        it "returns the result from the DRbClient" do
+          DRbClient.stub!(:run).and_return('foo')
+          @cli.execute!(@step_mother).should == 'foo'
+        end
+
+        it "ceases execution if the DrbClient is able to perform the execution" do
+          DRbClient.stub!(:run).and_return(true)
+          @configuration.should_not_receive(:build_formatter_broadcaster)
+          @cli.execute!(@step_mother)
+        end
+
+        context "when the DrbClient is unable to perfrom the execution" do
+          before { DRbClient.stub!(:run).and_raise(DRbClientError.new('error message.')) }
+
+          it "alerts the user that execution will be performed locally" do
+            @cli.execute!(@step_mother)
+            @err.string.should include("WARNING: error message. Running features locally:")
+          end
+
+          it "reparses the configuration since the --drb flag causes the initial parsing to short circuit" do
+            @configuration.should_receive(:parse!).exactly(:twice)
+            @cli.execute!(@step_mother)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/cucumber/core_ext/proc_spec.rb

@@ -0,0 +1,54 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'cucumber/core_ext/instance_exec'
+
+describe Proc do
+  it "should remove extraneous path info for file" do
+    proc = lambda {|a,b|}
+    proc.file_colon_line.should =~ /^spec\/cucumber\/core_ext\/proc_spec\.rb:6/
+  end
+  
+  it "should raise ArityMismatchError for too many args (expecting 0)" do
+    lambda {
+      Object.new.cucumber_instance_exec(true, 'foo', 1) do
+      end
+    }.should raise_error(Cucumber::ArityMismatchError, "Your block takes 0 arguments, but the Regexp matched 1 argument.")
+  end
+
+  it "should raise ArityMismatchError for too many args (expecting 1)" do
+    lambda {
+      Object.new.cucumber_instance_exec(true, 'foo', 1,2) do |a|
+      end
+    }.should raise_error(Cucumber::ArityMismatchError, "Your block takes 1 argument, but the Regexp matched 2 arguments.")
+  end
+
+  it "should raise ArityMismatchError for too few args (expecting 1)" do
+    lambda {
+      Object.new.cucumber_instance_exec(true, 'foo') do |a|
+      end
+    }.should raise_error(Cucumber::ArityMismatchError, "Your block takes 1 argument, but the Regexp matched 0 arguments.")
+  end
+
+  it "should raise ArityMismatchError for too few args (expecting 2)" do
+    lambda {
+      Object.new.cucumber_instance_exec(true, 'foo', 1) do |a,b|
+      end
+    }.should raise_error(Cucumber::ArityMismatchError, "Your block takes 2 arguments, but the Regexp matched 1 argument.")
+  end
+
+  if Cucumber::RUBY_1_9
+    it "should allow varargs" do
+      lambda {
+        Object.new.cucumber_instance_exec(true, 'foo', 1) do |*args|
+        end
+      }.should_not raise_error(Cucumber::ArityMismatchError)
+    end
+  else
+    # Ruby 1.8
+    it "should not allow varargs because Ruby 1.8 reports same arity as with no args, so we can't really tell the difference." do
+      lambda {
+        Object.new.cucumber_instance_exec(true, 'foo', 1) do |*args|
+        end
+      }.should raise_error(Cucumber::ArityMismatchError, "Your block takes 0 arguments, but the Regexp matched 1 argument.")
+    end
+  end
+end

data/spec/cucumber/core_ext/string_spec.rb

@@ -0,0 +1,42 @@
+require File.dirname(__FILE__) + '/../../../lib/cucumber/core_ext/string'
+
+describe String, "#gzub" do
+  it "should format groups with format string" do
+    "I ate 1 egg this morning".gzub(/I (\w+) (\d+) (\w+) this (\w+)/, "<span>%s</span>").should ==
+    "I <span>ate</span> <span>1</span> <span>egg</span> this <span>morning</span>"
+  end
+
+  it "should format groups with format string when there are dupes" do
+    "I bob 1 bo this bobs".gzub(/I (\w+) (\d+) (\w+) this (\w+)/, "<span>%s</span>").should ==
+    "I <span>bob</span> <span>1</span> <span>bo</span> this <span>bobs</span>"
+  end
+
+  it "should format groups with block" do
+    f = "I ate 1 egg this morning".gzub(/I (\w+) (\d+) (\w+) this (\w+)/) do |m|
+      "<span>#{m}</span>"
+    end
+    f.should == "I <span>ate</span> <span>1</span> <span>egg</span> this <span>morning</span>"
+  end
+
+  it "should format groups with proc object" do
+    proc = lambda do |m|
+      "<span>#{m}</span>"
+    end
+    f = "I ate 1 egg this morning".gzub(/I (\w+) (\d+) (\w+) this (\w+)/, proc)
+    f.should == "I <span>ate</span> <span>1</span> <span>egg</span> this <span>morning</span>"
+  end
+  
+  it "should format groups with block with not all placeholders having a value" do
+    f = "another member named Bob joins the group".gzub(/(a|another) (user|member) named ([^ ]+)( who is not logged in)?/) do |m|
+      "<span>#{m}</span>"
+    end
+    f.should == "<span>another</span> <span>member</span> named <span>Bob</span> joins the group"
+  end
+
+  it "should format match groups in a textile table row" do
+    f = "I ate 1 egg this morning".gzub(/I (\w+) (\d+) (\w+) this (\w+)/) do |m|
+      "<span>#{m}</span>"
+    end
+    f.should == "I <span>ate</span> <span>1</span> <span>egg</span> this <span>morning</span>"
+  end
+end

data/spec/cucumber/formatter/ansicolor_spec.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'cucumber/formatter/ansicolor'
+
+module Cucumber
+  module Formatter
+    describe ANSIColor do
+      include ANSIColor
+      
+      after do
+        ::Term::ANSIColor.coloring = true
+      end
+      
+      it "should wrap passed_param with bold green and reset to green" do
+        passed_param("foo").should == "\e[32m\e[1mfoo\e[0m\e[0m\e[32m"
+      end
+
+      it "should wrap passed in green" do
+        passed("foo").should == "\e[32mfoo\e[0m"
+      end
+
+      it "should not reset passed if there are no arguments" do
+        passed.should == "\e[32m"
+      end
+
+      it "should wrap comments in grey" do
+        comment("foo").should == "\e[90mfoo\e[0m"
+      end
+      
+      it "should not generate ansi codes when colors are disabled" do
+        ::Term::ANSIColor.coloring = false
+        passed("foo").should == "foo"
+      end
+    end
+  end
+end

data/spec/cucumber/formatter/color_io_spec.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'cucumber/formatter/color_io'
+
+module Cucumber
+  module Formatter
+    describe ColorIO do
+      describe "<<" do
+        it "should convert to a print using kernel" do
+          color_io = ColorIO.new
+          
+          Kernel.should_receive(:print).with("monkeys")
+          
+          color_io << "monkeys"
+        end
+        
+        it "should allow chained <<" do
+          color_io = ColorIO.new
+
+          Kernel.should_receive(:print).with("monkeys")
+          Kernel.should_receive(:print).with(" are tasty")
+          
+          color_io << "monkeys" <<  " are tasty"
+        end
+      end
+    end
+  end
+end

data/spec/cucumber/formatter/duration_spec.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'cucumber/formatter/duration'
+
+module Cucumber
+  module Formatter
+    describe Duration do
+      include Duration
+      
+      it "should format ms" do
+        format_duration(0.002103).should == '0m0.002s'
+      end
+
+      it "should format m" do
+        format_duration(61.002503).should == '1m1.003s'
+      end
+
+      it "should format h" do
+        format_duration(3661.002503).should == '61m1.003s'
+      end
+    end
+  end
+end

data/spec/cucumber/formatter/progress_spec.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'cucumber/formatter/progress'
+
+module Cucumber
+  module Formatter
+    describe Progress do
+
+      before(:all) do
+        Term::ANSIColor.coloring = false
+      end
+
+      before(:each) do
+        @out = StringIO.new
+        @progress = Progress.new(mock("step mother"), @out, {})
+      end
+
+      describe "visiting a table cell value without a status" do
+        it "should take the status from the last run step" do
+          @progress.visit_step_result('', '', nil, :failed, nil, 10, nil)
+          @progress.visit_table_cell_value('value', 10, nil)
+
+          @out.string.should == "FF"
+        end
+      end
+
+      describe "visiting a table cell which is a table header" do
+        it "should not output anything" do
+          @progress.visit_table_cell_value('value', 10, :skipped_param)
+
+          @out.string.should == ""
+        end
+      end
+
+    end
+  end
+end

data/spec/cucumber/parser/feature_parser_spec.rb

@@ -0,0 +1,387 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'cucumber/parser/i18n/language'
+
+module Cucumber
+  module Parser
+    describe Feature do
+      before do
+        @parser = I18n::Language['en'].parser
+      end
+
+      def parse(text)
+        feature = @parser.parse_or_fail(text)
+      end
+
+      def parse_file(file)
+        FeatureFile.new(File.dirname(__FILE__) + "/../treetop_parser/" + file).parse
+      end
+
+      def parse_example_file(file)
+        FeatureFile.new(File.dirname(__FILE__) + "/../../../examples/" + file).parse
+      end
+
+      describe "Comments" do
+        it "should parse a file with only a one line comment" do
+          parse(%{# My comment
+Feature: hi
+}).to_sexp.should ==
+          [:feature, nil, "Feature: hi",
+            [:comment, "# My comment\n"]]
+        end
+
+        it "should parse a file with only a multiline comment" do
+          parse(%{# Hello
+# World
+Feature: hi
+}).to_sexp.should ==
+          [:feature, nil, "Feature: hi",
+            [:comment, "# Hello\n# World\n"]]
+        end
+
+        it "should parse a file with no comments" do
+          parse("Feature: hi\n").to_sexp.should ==
+          [:feature, nil, "Feature: hi"]
+        end
+
+        it "should parse a file with only a multiline comment with newlines" do
+          parse("# Hello\n\n# World\n").to_sexp.should == 
+          [:feature, nil, "", 
+            [:comment, "# Hello\n\n# World\n"]]
+        end
+        
+        it "should not consume comments as part of a multiline name" do
+          parse("Feature: hi\n Scenario: test\n\n#hello\n Scenario: another").to_sexp.should ==
+            [:feature, nil, "Feature: hi", 
+             [:scenario, 2, "Scenario:", "test"], 
+             [:scenario, 5, "Scenario:", "another", 
+              [:comment, "#hello\n "]]]
+        end
+      end
+
+      describe "Tags" do
+        it "should parse a file with tags on a feature" do
+          parse("# My comment\n@hello @world Feature: hi\n").to_sexp.should ==
+          [:feature, nil, "Feature: hi",
+            [:comment, "# My comment\n"],
+            [:tag, "hello"],
+            [:tag, "world"]]
+        end
+
+        it "should not take the tags as part of a multiline name feature element" do
+          parse("Feature: hi\n Scenario: test\n\n@hello Scenario: another").to_sexp.should ==
+          [:feature, nil, "Feature: hi",
+           [:scenario, 2, "Scenario:", "test"], 
+           [:scenario, 4, "Scenario:", "another", 
+             [:tag, "hello"]]]
+        end
+
+        it "should parse a file with tags on a scenario" do
+          parse(%{# FC
+  @ft
+Feature: hi
+
+  @st1 @st2   
+  Scenario: First
+    Given Pepper
+
+@st3 
+   @st4    @ST5  @#^%&ST6**!
+  Scenario: Second}).to_sexp.should ==
+          [:feature, nil, "Feature: hi",
+            [:comment, "# FC\n  "],
+            [:tag, "ft"],
+            [:scenario, 6, 'Scenario:', 'First',
+              [:tag, "st1"], [:tag, "st2"],
+              [:step_invocation, 7, "Given", "Pepper"]
+            ],
+            [:scenario, 11, 'Scenario:', 'Second',
+              [:tag, "st3"], [:tag, "st4"], [:tag, "ST5"], [:tag, "#^%&ST6**!"]]]
+        end
+      end
+      
+      describe "Background" do
+        it "should have steps" do
+          parse("Feature: Hi\nBackground:\nGiven I am a step\n").to_sexp.should ==
+          [:feature, nil, "Feature: Hi",
+            [:background, 2, "Background:",
+              [:step, 3, "Given", "I am a step"]]]
+        end
+        
+        it "should allow multiline names" do
+          parse(%{Feature: Hi
+Background: It is my ambition to say 
+            in ten sentences
+            what others say 
+            in a whole book.
+Given I am a step}).to_sexp.should ==
+          [:feature, nil, "Feature: Hi",
+            [:background, 2, "Background:", "It is my ambition to say\nin ten sentences\nwhat others say\nin a whole book.",
+              [:step, 6, "Given", "I am a step"]]]
+        end
+      end
+
+      describe "Scenarios" do
+        it "can be empty" do
+          parse("Feature: Hi\n\nScenario: Hello\n").to_sexp.should ==
+          [:feature, nil, "Feature: Hi",
+            [:scenario, 3, "Scenario:", "Hello"]]
+        end
+
+        it "should allow whitespace lines after the Scenario line" do
+          parse(%{Feature: Foo
+
+Scenario: bar
+
+  Given baz})
+        end
+            
+        it "should have steps" do
+          parse("Feature: Hi\nScenario: Hello\nGiven I am a step\n").to_sexp.should ==
+          [:feature, nil, "Feature: Hi",
+            [:scenario, 2, "Scenario:", "Hello",
+              [:step_invocation, 3, "Given", "I am a step"]]]
+        end
+
+        it "should have steps with inline table" do
+          parse(%{Feature: Hi
+Scenario: Hello
+Given I have a table
+|a|b|
+}).to_sexp.should ==
+          [:feature, nil, "Feature: Hi",
+            [:scenario, 2, "Scenario:", "Hello",
+              [:step_invocation, 3, "Given", "I have a table",
+                [:table,
+                  [:row, 4,
+                    [:cell, "a"],
+                    [:cell, "b"]]]]]]
+        end
+
+        it "should have steps with inline py_string" do
+          parse(%{Feature: Hi
+Scenario: Hello
+Given I have a string
+
+
+   """
+  hello
+  world
+  """
+
+}).to_sexp.should ==
+          [:feature, nil, "Feature: Hi",
+            [:scenario, 2, "Scenario:", "Hello",
+              [:step_invocation, 3, "Given", "I have a string",
+                [:py_string, "hello\nworld"]]]]
+        end
+        
+        it "should allow multiline names" do
+          parse(%{Feature: Hi
+Scenario: It is my ambition to say
+          in ten sentences
+          what others say 
+          in a whole book.
+Given I am a step
+
+}).to_sexp.should ==
+          [:feature, nil, "Feature: Hi",
+            [:scenario, 2, "Scenario:", "It is my ambition to say\nin ten sentences\nwhat others say\nin a whole book.",
+              [:step_invocation, 6, "Given", "I am a step"]]]
+        end
+
+        it "should ignore gherkin keywords which are parts of other words in the name" do
+          parse(%{Feature: Parser bug
+Scenario: I have a Button
+          Buttons are great
+  Given I have it
+}).to_sexp.should ==
+            [:feature, nil, "Feature: Parser bug",
+            [:scenario, 2, "Scenario:", "I have a Button\nButtons are great",
+              [:step_invocation, 4, "Given", "I have it"]]]
+
+        end
+      end
+
+      describe "Scenario Outlines" do
+        it "can be empty" do
+          parse(%{Feature: Hi
+Scenario Outline: Hello
+Given a <what> cucumber
+Examples:
+|what|
+|green|
+}).to_sexp.should ==
+          [:feature, nil, "Feature: Hi",
+            [:scenario_outline, "Scenario Outline:", "Hello",
+              [:step, 3, "Given", "a <what> cucumber"],
+              [:examples, "Examples:", "",
+                [:table, 
+                  [:row, 5,
+                    [:cell, "what"]], 
+                  [:row, 6,
+                    [:cell, "green"]]]]]]
+        end
+
+        it "should have line numbered steps with inline table" do
+          parse(%{Feature: Hi
+Scenario Outline: Hello
+
+Given I have a table
+
+|<a>|<b>|
+Examples:
+|a|b|
+|c|d|
+}).to_sexp.should ==
+          [:feature, nil, "Feature: Hi",
+            [:scenario_outline, "Scenario Outline:", "Hello",
+              [:step, 4, "Given", "I have a table",
+                [:table, 
+                  [:row, 6,
+                    [:cell, "<a>"], 
+                    [:cell, "<b>"]]]],
+            [:examples, "Examples:", "",
+              [:table,
+                [:row, 8,
+                  [:cell, "a"], 
+                  [:cell, "b"]],
+                [:row, 9,
+                  [:cell, "c"], 
+                  [:cell, "d"]]]]]]
+        end
+
+        it "should have examples" do
+          parse("Feature: Hi
+
+  Scenario Outline: Hello
+
+  Given I have a table
+    |1|2|
+
+  Examples:
+|x|y|
+|5|6|
+
+").to_sexp.should ==
+          [:feature, nil, "Feature: Hi",
+            [:scenario_outline, "Scenario Outline:", "Hello",
+              [:step, 5, "Given", "I have a table",
+                [:table,
+                  [:row, 6, 
+                    [:cell, "1"],
+                    [:cell, "2"]]]],
+              [:examples, "Examples:", "",
+                [:table,
+                  [:row, 9,
+                    [:cell, "x"],
+                    [:cell, "y"]],
+                  [:row, 10,
+                    [:cell, "5"],
+                    [:cell, "6"]]]]]]
+        end
+
+        it "should allow multiline names" do
+          parse(%{Feature: Hi
+Scenario Outline: It is my ambition to say 
+          in ten sentences
+          what others say 
+          in a whole book.
+Given I am a step
+
+}).to_sexp.should ==
+          [:feature, nil, "Feature: Hi",
+            [:scenario_outline, "Scenario Outline:", "It is my ambition to say\nin ten sentences\nwhat others say\nin a whole book.",
+              [:step, 6, "Given", "I am a step"]]]
+        end
+        
+        it "should allow Examples to have multiline names" do
+          parse(%{Feature: Hi
+Scenario Outline: name
+Given I am a step
+
+Examples: I'm a multiline name
+          and I'm ok
+|x|
+|5|
+
+}).to_sexp.should ==
+          [:feature, nil, "Feature: Hi",
+            [:scenario_outline, "Scenario Outline:", "name",
+              [:step, 3, "Given", "I am a step"],
+              [:examples, "Examples:", "I'm a multiline name\nand I'm ok",
+                [:table,
+                  [:row, 7,
+                    [:cell, "x"]],
+                  [:row, 8,
+                    [:cell, "5"]]]]]]
+        end
+
+        it "should allow Examples to have multiline names" do
+            parse(%{Feature: Hi
+Scenario: When I have when in scenario
+          I should be fine
+Given I am a step
+}).to_sexp.should ==
+            [:feature, nil, "Feature: Hi",
+              [:scenario, 2, "Scenario:", "When I have when in scenario\nI should be fine",
+                [:step_invocation, 4, "Given", "I am a step"]]]
+          end
+      end
+
+      describe "Syntax" do
+        it "should parse empty_feature" do
+          parse_file("empty_feature.feature")
+        end
+
+        it "should parse empty_scenario" do
+          parse_file("empty_scenario.feature")
+        end
+
+        it "should parse empty_scenario_outline" do
+          parse_file("empty_scenario_outline.feature")
+        end
+
+        it "should parse fit_scenario" do
+          parse_file("multiline_steps.feature")
+        end
+
+        it "should parse scenario_outline" do
+          parse_file("scenario_outline.feature")
+        end
+      end
+
+      describe "Filtering" do
+        it "should filter outline tables" do
+          ff = FeatureFile.new(
+            File.dirname(__FILE__) + '/../../../examples/self_test/features/outline_sample.feature:12')
+          f = ff.parse({:lang => 'en'})
+          f.to_sexp.should ==
+          [:feature,
+           "./spec/cucumber/parser/../../../examples/self_test/features/outline_sample.feature",
+           "Feature: Outline Sample",
+           [:scenario_outline,
+            "Scenario Outline:",
+            "Test state",
+            [:step, 6, "Given", "<state> without a table"],
+            [:step, 7, "Given", "<other_state> without a table"],
+            [:examples,
+             "Examples:",
+             "Rainbow colours",
+             [:table,
+              [:row, 9, [:cell, "state"], [:cell, "other_state"]],
+#              [:row, 10, [:cell, "missing"], [:cell, "passing"]],
+#              [:row, 11, [:cell, "passing"], [:cell, "passing"]],
+              [:row, 12, [:cell, "failing"], [:cell, "passing"]]]]
+            # ,
+            # [:examples,
+            #  "Examples:",
+            #  "Only passing",
+            #  [:table,
+            #   [:row, 14, [:cell, "state"], [:cell, "other_state"]],
+            #   [:row, 15, [:cell, "passing"], [:cell, "passing"]]]]]
+              ]]
+        end
+      end
+    end
+  end
+end