vim-jar 0.0.3 → 0.1.0

data/bundler/ruby/1.8/gems/gherkin-2.2.9/spec/gherkin/fixtures/scenario_outline_with_tags.feature

@@ -0,0 +1,13 @@
+Feature: Bug 67
+
+  @wip
+  Scenario Outline: WIP
+    When blah
+
+    Examples:
+      | a |
+      | b |
+      | c |
+
+  Scenario: Not WIP
+    When blah

data/bundler/ruby/1.8/gems/gherkin-2.2.9/spec/gherkin/fixtures/scenario_without_steps.feature

@@ -0,0 +1,5 @@
+Feature: f
+
+  Scenario: a
+
+  Scenario: b

data/bundler/ruby/1.8/gems/gherkin-2.2.9/spec/gherkin/fixtures/simple_with_comments.feature

@@ -0,0 +1,7 @@
+# Here is a comment
+Feature: Feature Text
+# Here is another # comment
+  Scenario: Reading a Scenario
+# Here is a third comment
+    Given there is a step
+# Here is a fourth comment

data/bundler/ruby/1.8/gems/gherkin-2.2.9/spec/gherkin/fixtures/simple_with_tags.feature

@@ -0,0 +1,11 @@
+# FC
+@ft
+Feature: hi
+
+@st1 @st2   
+Scenario: First
+Given Pepper
+
+@st3 
+@st4    @ST5  @#^%&ST6**!
+Scenario: Second

data/bundler/ruby/1.8/gems/gherkin-2.2.9/spec/gherkin/fixtures/with_bom.feature

@@ -0,0 +1,3 @@
+Feature: Feature Text
+  Scenario: Reading a Scenario
+    Given there is a step

data/bundler/ruby/1.8/gems/gherkin-2.2.9/spec/gherkin/formatter/colors_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+require 'gherkin/formatter/colors'
+
+module Gherkin
+  module Formatter
+    describe Colors do
+      include Gherkin::Formatter::Colors
+
+      it "should colour stuff red" do
+        failed("hello").should == "\e[31mhello\e[0m"
+      end
+
+      it "should be possible to specify no colouring" do
+        uncolored(failed("hello")).should == "hello"
+      end
+    end
+  end
+end

data/bundler/ruby/1.8/gems/gherkin-2.2.9/spec/gherkin/formatter/filter_formatter_spec.rb

@@ -0,0 +1,167 @@
+# encoding: utf-8
+require 'stringio'
+require 'spec_helper'
+require 'gherkin/parser/parser'
+require 'gherkin/formatter/filter_formatter'
+require 'gherkin/formatter/pretty_formatter'
+
+module Gherkin
+  module Formatter
+    describe FilterFormatter do
+      include Colors
+
+      attr_accessor :file
+
+      before do
+        self.file = 'complex_for_filtering.feature'
+      end
+
+      def verify_filter(filters, *line_ranges)
+        io = StringIO.new
+        pretty_formatter = Gherkin::Formatter::PrettyFormatter.new(io, true)
+        filter_formatter = Gherkin::Formatter::FilterFormatter.new(pretty_formatter, filters)
+        parser = Gherkin::Parser::Parser.new(filter_formatter)
+
+        path = File.dirname(__FILE__) + "/../fixtures/" + file
+        source = File.new(path).read + "# __EOF__"
+        parser.parse(source, path, 0)
+        
+        source_lines = source.split("\n")
+        expected = (line_ranges.map do |line_range|
+          source_lines[(line_range.first-1..line_range.last-1)]
+        end.flatten).join("\n").gsub(/# __EOF__/, '')
+        io.string.should == expected
+      end
+
+      context "tags" do
+        it "should filter on feature tag" do
+          verify_filter(['@tag1'], 1..61)
+        end
+
+        it "should filter on scenario tag" do
+          verify_filter(['@tag4'], 1..19)
+        end
+
+        it "should filter on abother scenario tag" do
+          verify_filter(['@tag3'], 1..37)
+        end
+
+        it "should filter on scenario outline tag" do
+          verify_filter(['@more'], 1..14, 46..61)
+        end
+
+        it "should filter on first examples tag" do
+          verify_filter(['@neat'], 1..14, 46..55)
+        end
+
+        it "should filter on second examples tag" do
+          verify_filter(['@hamster'], 1..14, 46..49, 56..61)
+        end
+
+        it "should not replay examples from ignored scenario outline" do
+          self.file = 'scenario_outline_with_tags.feature'
+          verify_filter(['~@wip'], 1..2, 12..14)
+        end
+      end
+
+      context "names" do
+        it "should filter on scenario name" do
+          verify_filter([/Reading a Scenario/], 1..19)
+        end
+
+        it "should filter on scenario outline name" do
+          verify_filter([/More/], 1..14, 46..61)
+        end
+
+        it "should filter on first examples name" do
+          verify_filter([/Neato/], 1..14, 46..55)
+        end
+
+        it "should filter on second examples name" do
+          verify_filter([/Rodents/], 1..14, 46..49, 56..61)
+        end
+
+        it "should filter on various names" do
+          self.file = 'hantu_pisang.feature'
+          verify_filter([/Pisang/], 1..8, 19..32)
+        end
+
+        it "should filter on background name" do
+          self.file = 'hantu_pisang.feature'
+          verify_filter([/The background/], 1..5)
+        end
+      end
+
+      context "lines" do
+        context "on the same line as feature element keyword" do
+          it "should filter on scenario without line" do
+            self.file = 'scenario_without_steps.feature'
+            verify_filter([3], 1..4)
+          end
+
+          it "should filter on scenario line" do
+            verify_filter([16], 1..19)
+          end
+
+          it "should filter on scenario outline line" do
+            verify_filter([47], 1..14, 46..61)
+          end
+
+          it "should filter on first examples line" do
+            verify_filter([51], 1..14, 46..55)
+          end
+
+          it "should filter on second examples line" do
+            verify_filter([57], 1..14, 46..49, 56..61)
+          end
+        end
+
+        context "on the same line as step keyword" do
+          it "should filter on step line" do
+            verify_filter([17], 1..19)
+          end
+
+          it "should filter on scenario outline line" do
+            verify_filter([48], 1..14, 46..61)
+          end
+        end
+
+        context "on examples header line" do
+          it "should filter on first table" do
+            verify_filter([52], 1..14, 46..55)
+          end
+
+          it "should filter on second table" do
+            verify_filter([58], 1..14, 46..49, 56..61)
+          end
+        end
+
+        context "on examples example line" do
+          it "should filter on first table" do
+            verify_filter([53], 1..14, 46..53, 55..55)
+          end
+        end
+
+        context "on tag line" do
+          it "should filter on first tag" do
+            verify_filter([15], 1..19)
+          end
+        end
+
+        context "multiline argument" do
+          it "should filter on table line" do
+            verify_filter([36], 1..14, 20..37)
+          end
+
+          it "should filter on first pystring quote" do
+            verify_filter([41], 1..14, 38..45)
+          end
+
+          it "should filter on last pystring quote" do
+            verify_filter([44], 1..14, 38..45)
+          end
+        end
+      end
+    end
+  end
+end

data/bundler/ruby/1.8/gems/gherkin-2.2.9/spec/gherkin/formatter/model_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+require 'gherkin/formatter/model'
+
+module Gherkin
+  module Formatter
+    module Model
+      describe Tag do
+        it "should be equal when name is equal" do
+          tags = [Tag.new('@x', 1), Tag.new('@y', 2), Tag.new('@x', 3)]
+          tags.to_a.uniq.length.should == 2
+        end
+      end
+    end
+  end
+end

data/bundler/ruby/1.8/gems/gherkin-2.2.9/spec/gherkin/formatter/pretty_formatter_spec.rb

@@ -0,0 +1,147 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'gherkin/formatter/pretty_formatter'
+require 'gherkin/formatter/argument'
+require 'gherkin/formatter/model'
+require 'gherkin/listener/formatter_listener'
+require 'stringio'
+
+module Gherkin
+  module Formatter
+    describe PrettyFormatter do
+      include Colors
+
+      def assert_io(s)
+        actual = @io.string
+        actual.gsub!(/\e\[m/, "\e[0m") # JANSI resets without the 0.
+        actual.should == s
+      end
+      
+      def assert_pretty(input, expected_output=input)
+        [true, false].each do |force_ruby|
+          io = StringIO.new
+          pf = Gherkin::Formatter::PrettyFormatter.new(io, true)
+          parser = Gherkin::Parser::Parser.new(pf, true, "root", force_ruby)
+          parser.parse(input, "test.feature", 0)
+          output = io.string
+          output.should == expected_output
+        end
+      end
+
+      def result(status, error_message, arguments, stepdef_location)
+        Model::Result.new(status, error_message, arguments, stepdef_location)
+      end
+
+      before do
+        @io = StringIO.new
+        @colf = Gherkin::Formatter::PrettyFormatter.new(@io, false)
+      end
+
+      it "should print comments when scenario is longer" do
+        @colf.uri("features/foo.feature")
+        @colf.feature(Model::Feature.new([], [], "Feature", "Hello", "World", 1))
+        step1 = Model::Step.new([], "Given ", "some stuff", 5, nil, result('passed', nil, [], "features/step_definitions/bar.rb:56"))
+        step2 = Model::Step.new([], "When ", "foo", 6, nil, result('passed', nil, [], "features/step_definitions/bar.rb:96"))
+        @colf.steps([step1, step2])
+        @colf.scenario(Model::Scenario.new([], [], "Scenario", "The scenario", "", 4))
+        @colf.step(step1)
+        @colf.step(step2)
+
+        assert_io(%{Feature: Hello
+  World
+
+  Scenario: The scenario #{grey('# features/foo.feature:4')}
+    #{green('Given ')}#{green('some stuff')}     #{grey('# features/step_definitions/bar.rb:56')}
+    #{green('When ')}#{green('foo')}             #{grey('# features/step_definitions/bar.rb:96')}
+})
+      end
+
+      it "should print comments when step is longer" do
+        @colf.uri("features/foo.feature")
+        @colf.feature(Model::Feature.new([], [], "Feature", "Hello", "World", 1))
+        step = Model::Step.new([], "Given ", "some stuff that is longer", 5, nil, result('passed', nil, [], "features/step_definitions/bar.rb:56"))
+        @colf.steps([step])
+        @colf.scenario(Model::Scenario.new([], [], "Scenario", "The scenario", "", 4))
+        @colf.step(step)
+
+        assert_io(%{Feature: Hello
+  World
+
+  Scenario: The scenario            #{grey('# features/foo.feature:4')}
+    #{green('Given ')}#{green('some stuff that is longer')} #{grey('# features/step_definitions/bar.rb:56')}
+})
+      end
+
+      it "should highlight arguments for regular steps" do
+        step = Model::Step.new([], "Given ", "I have 999 cukes in my belly", 3, nil, result('passed', nil, [Gherkin::Formatter::Argument.new(7, '999')], nil))
+        @colf.steps([step])
+        @colf.step(step)
+        if defined?(JRUBY_VERSION)
+          # Not terribly readable. The result on Java is different because JANSI uses semicolons when there are several codes.
+          assert_io("    \e[32mGiven \e[0m\e[32mI have \e[0m\e[32;1m999\e[0m\e[32m cukes in my belly\e[0m\n")
+        else
+          assert_io("    #{green('Given ')}#{green('I have ')}#{green(bold('999'))}#{green(' cukes in my belly')}\n")
+        end
+      end
+
+      it "should prettify scenario" do
+        assert_pretty(%{Feature: Feature Description
+  Some preamble
+
+  Scenario: Scenario Description
+    description has multiple lines
+
+    Given there is a step
+      """
+      with
+        pystrings
+      """
+    And there is another step
+      | æ   | \\|o |
+      | \\|a | ø\\\\ |
+    Then we will see steps
+})
+      end
+
+
+      it "should prettify scenario outline with table" do
+        assert_pretty(%{# A feature comment
+@foo
+Feature: Feature Description
+  Some preamble
+  on several
+  lines
+
+  # A Scenario Outline comment
+  @bar
+  Scenario Outline: Scenario Ouline Description
+    Given there is a
+      """
+      string with <foo>
+      """
+    And a table with
+      | <bar> |
+      | <baz> |
+
+    @zap @boing
+    Examples: Examples Description
+      | foo    | bar  | baz         |
+      | Banana | I    | am hungry   |
+      | Beer   | You  | are thirsty |
+      | Bed    | They | are tired   |
+})
+      end
+
+      it "should preserve tabs" do
+        assert_pretty(IO.read(File.dirname(__FILE__) + '/tabs.feature'), IO.read(File.dirname(__FILE__) + '/spaces.feature'))
+      end
+
+      it "should escape backslashes and pipes" do
+        io = StringIO.new
+        l = Gherkin::Formatter::PrettyFormatter.new(io, true)
+        l.__send__(:table, [Gherkin::Formatter::Model::Row.new([], ['|', '\\'], nil)])
+        io.string.should == '      | \\| | \\\\ |' + "\n"
+      end
+    end
+  end
+end

data/bundler/ruby/1.8/gems/gherkin-2.2.9/spec/gherkin/formatter/spaces.feature

@@ -0,0 +1,9 @@
+Feature: Adding
+
+  Scenario: Add two numbers
+    Given the following input:
+      """
+      hello
+      """
+    When the calculator is run
+    Then the output should be 4

data/bundler/ruby/1.8/gems/gherkin-2.2.9/spec/gherkin/formatter/step_printer_spec.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'gherkin/formatter/step_printer'
+require 'gherkin/formatter/argument'
+require 'stringio'
+
+module Gherkin
+  module Formatter
+    class ParenthesisFormat
+      def write_text(io, text)
+        io.write("(#{text})")
+      end
+    end
+    
+    class BracketFormat
+      def write_text(io, text)
+        io.write("[#{text}]")
+      end
+    end
+    
+    describe StepPrinter do
+      before do
+        @io = StringIO.new
+        @p = StepPrinter.new
+        @pf = ParenthesisFormat.new
+        @bf = BracketFormat.new
+      end
+
+      it "should replace 0 args" do
+        @p.write_step(@io, @pf, @bf, "I have 10 cukes", [])
+        @io.string.should == "(I have 10 cukes)"
+      end
+
+      it "should replace 1 arg" do
+        @p.write_step(@io, @pf, @bf, "I have 10 cukes", [Argument.new(7, '10')])
+        @io.string.should == "(I have )[10]( cukes)"
+      end
+      
+      it "should replace 1 unicode arg" do
+        @p.write_step(@io, @pf, @bf, "I hæve øæ cåkes", [Argument.new(7, 'øæ')])
+        @io.string.should == "(I hæve )[øæ]( cåkes)"
+      end
+      
+      it "should replace 2 args" do
+        @p.write_step(@io, @pf, @bf, "I have 10 yellow cukes in my belly", [Argument.new(7, '10'), Argument.new(17, 'cukes')])
+        @io.string.should == "(I have )[10]( yellow )[cukes]( in my belly)"
+      end
+
+      it "should replace 2 unicode args" do
+        @p.write_step(@io, @pf, @bf, "Æslåk likes æøå", [Argument.new(0, 'Æslåk'), Argument.new(12, 'æøå')])
+        @io.string.should == "[Æslåk]( likes )[æøå]"
+      end
+    end
+  end
+end

data/bundler/ruby/1.8/gems/gherkin-2.2.9/spec/gherkin/formatter/tabs.feature

@@ -0,0 +1,9 @@
+Feature: Adding
+
+	Scenario: Add two numbers
+		Given the following input:
+			"""
+			hello
+			"""
+		When the calculator is run
+		Then the output should be 4

data/bundler/ruby/1.8/gems/gherkin-2.2.9/spec/gherkin/formatter/tag_count_formatter_spec.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'gherkin/parser/parser'
+require 'gherkin/formatter/tag_count_formatter'
+
+module Gherkin
+  module Formatter
+    describe TagCountFormatter do
+      it "should count tags" do
+        tag_counts = {}
+        dummy = Gherkin::SexpRecorder.new
+        formatter = Gherkin::Formatter::TagCountFormatter.new(dummy, tag_counts)
+        parser = Gherkin::Parser::Parser.new(formatter)
+
+        f = File.new(File.dirname(__FILE__) + "/../fixtures/complex_with_tags.feature").read
+        parser.parse(f, 'f.feature', 0)
+        
+        tag_counts.should == {
+          "@hamster" => ["f.feature:58"],
+          "@tag1"    => ["f.feature:18","f.feature:23","f.feature:39","f.feature:52","f.feature:58"],
+          "@tag2"    => ["f.feature:18","f.feature:23","f.feature:39","f.feature:52","f.feature:58"],
+          "@tag3"    => ["f.feature:18", "f.feature:23"],
+          "@tag4"    => ["f.feature:18"],
+          "@neat"    => ["f.feature:52"],
+          "@more"    => ["f.feature:52", "f.feature:58"]
+        }
+      end
+    end
+  end
+end

data/bundler/ruby/1.8/gems/gherkin-2.2.9/spec/gherkin/i18n_spec.rb

@@ -0,0 +1,153 @@
+#encoding: utf-8
+require 'spec_helper'
+
+module Gherkin
+  module Lexer
+    describe I18n do
+      before do
+        @listener = Gherkin::SexpRecorder.new
+      end
+
+      def scan_file(lexer, file)
+        lexer.scan(File.new(File.dirname(__FILE__) + "/fixtures/" + file).read)
+      end
+
+      it "should recognize keywords in the language of the lexer" do
+        lexer = Gherkin::Lexer::I18nLexer.new(@listener, false)
+        scan_file(lexer, "i18n_no.feature")
+        @listener.to_sexp.should == [
+          [:comment, "#language:no", 1],
+          [:feature, "Egenskap", "i18n support", "", 2],
+          [:scenario, "Scenario", "Parsing many languages", "", 4],
+          [:step, "Gitt ", "Gherkin supports many languages", 5],
+          [:step, "Når ",  "Norwegian keywords are parsed", 6],
+          [:step, "Så ", "they should be recognized", 7],
+          [:eof]
+        ]
+      end
+
+      it "should parse languages without a space after keywords" do
+        lexer = Gherkin::Lexer::I18nLexer.new(@listener, false)
+        scan_file(lexer, "i18n_zh-CN.feature")
+        @listener.to_sexp.should == [
+          [:comment, "#language:zh-CN", 1],
+          [:feature, "功能", "加法", "", 2],
+          [:scenario, "场景", "两个数相加", "", 4],
+          [:step, "假如", "我已经在计算器里输入6", 5],
+          [:step, "而且", "我已经在计算器里输入7", 6],
+          [:step, "当", "我按相加按钮", 7],
+          [:step, "那么", "我应该在屏幕上看到的结果是13", 8],
+          [:eof]
+        ] 
+      end
+
+      it "should parse languages with spaces after some keywords but not others" do
+        lexer = Gherkin::Lexer::I18nLexer.new(@listener, false)
+        scan_file(lexer, "i18n_fr.feature")
+        @listener.to_sexp.should == [
+          [:comment, "#language:fr", 1],
+          [:feature, "Fonctionnalité", "Addition", "", 2],
+          [:scenario_outline, "Plan du scénario", "Addition de produits dérivés", "", 3],
+          [:step, "Soit ", "une calculatrice", 4],
+          [:step, "Etant donné ", "qu'on tape <a>", 5],
+          [:step, "Et ", "qu'on tape <b>", 6],
+          [:step, "Lorsqu'", "on tape additionner", 7],
+          [:step, "Alors ", "le résultat doit être <somme>", 8],
+          [:examples, "Exemples", "", "", 10],
+          [:row, %w{a b somme}, 11],
+          [:row, %w{2 2 4}, 12],
+          [:row, %w{2 3 5}, 13],
+          [:eof]
+        ]
+      end
+
+      describe 'keywords' do
+        it "should have code keywords without space, comma, exclamation or apostrophe" do
+          ['Avast', 'Akkor', 'Etantdonné', 'Lorsque', '假設'].each do |code_keyword|
+            Gherkin::I18n.code_keywords.should include(code_keyword)
+          end
+        end
+
+        it "should reject the bullet stars" do
+          Gherkin::I18n.code_keywords.should_not include('*')
+        end
+
+        it "should report keyword regexp" do
+          Gherkin::I18n.keyword_regexp(:step).should =~ /\|Quando \|Quand \|Quan \|Pryd \|Pokud \|/
+        end
+
+        unless defined?(JRUBY_VERSION)
+        it "should print available languages" do
+          ("\n" + Gherkin::I18n.language_table).should == %{
+      | ar        | Arabic                 | العربية              |
+      | bg        | Bulgarian              | български            |
+      | ca        | Catalan                | català               |
+      | cs        | Czech                  | Česky                |
+      | cy-GB     | Welsh                  | Cymraeg              |
+      | da        | Danish                 | dansk                |
+      | de        | German                 | Deutsch              |
+      | en        | English                | English              |
+      | en-Scouse | Scouse                 | Scouse               |
+      | en-au     | Australian             | Australian           |
+      | en-lol    | LOLCAT                 | LOLCAT               |
+      | en-pirate | Pirate                 | Pirate               |
+      | en-tx     | Texan                  | Texan                |
+      | eo        | Esperanto              | Esperanto            |
+      | es        | Spanish                | español              |
+      | et        | Estonian               | eesti keel           |
+      | fi        | Finnish                | suomi                |
+      | fr        | French                 | français             |
+      | he        | Hebrew                 | עברית                |
+      | hr        | Croatian               | hrvatski             |
+      | hu        | Hungarian              | magyar               |
+      | id        | Indonesian             | Bahasa Indonesia     |
+      | it        | Italian                | italiano             |
+      | ja        | Japanese               | 日本語                  |
+      | ko        | Korean                 | 한국어                  |
+      | lt        | Lithuanian             | lietuvių kalba       |
+      | lu        | Luxemburgish           | Lëtzebuergesch       |
+      | lv        | Latvian                | latviešu             |
+      | nl        | Dutch                  | Nederlands           |
+      | no        | Norwegian              | norsk                |
+      | pl        | Polish                 | polski               |
+      | pt        | Portuguese             | português            |
+      | ro        | Romanian               | română               |
+      | ro-RO     | Romanian (diacritical) | română (diacritical) |
+      | ru        | Russian                | русский              |
+      | sk        | Slovak                 | Slovensky            |
+      | sr-Cyrl   | Serbian                | Српски               |
+      | sr-Latn   | Serbian (Latin)        | Srpski (Latinica)    |
+      | sv        | Swedish                | Svenska              |
+      | tr        | Turkish                | Türkçe               |
+      | uk        | Ukrainian              | Українська           |
+      | uz        | Uzbek                  | Узбекча              |
+      | vi        | Vietnamese             | Tiếng Việt           |
+      | zh-CN     | Chinese simplified     | 简体中文                 |
+      | zh-TW     | Chinese traditional    | 繁體中文                 |
+}
+        end
+        end
+
+        it "should print keywords for a given language" do
+          ("\n" + Gherkin::I18n.get('fr').keyword_table).should == %{
+      | feature          | "Fonctionnalité"                       |
+      | background       | "Contexte"                             |
+      | scenario         | "Scénario"                             |
+      | scenario_outline | "Plan du scénario", "Plan du Scénario" |
+      | examples         | "Exemples"                             |
+      | given            | "* ", "Soit ", "Etant donné "          |
+      | when             | "* ", "Quand ", "Lorsque ", "Lorsqu'"  |
+      | then             | "* ", "Alors "                         |
+      | and              | "* ", "Et "                            |
+      | but              | "* ", "Mais "                          |
+      | given (code)     | "Soit", "Etantdonné"                   |
+      | when (code)      | "Quand", "Lorsque", "Lorsqu"           |
+      | then (code)      | "Alors"                                |
+      | and (code)       | "Et"                                   |
+      | but (code)       | "Mais"                                 |
+}
+        end
+      end
+    end
+  end
+end

data/bundler/ruby/1.8/gems/gherkin-2.2.9/spec/gherkin/java_lexer_spec.rb

@@ -0,0 +1,20 @@
+#encoding: utf-8
+if defined?(JRUBY_VERSION)
+require 'spec_helper'
+
+module Gherkin
+  module JavaLexer
+    describe "Java Lexer" do
+      before do
+        @listener = Gherkin::SexpRecorder.new
+        @lexer = Java::GherkinLexer::I18nLexer.new(@listener)
+      end
+
+      it_should_behave_like "a Gherkin lexer"
+      it_should_behave_like "a Gherkin lexer lexing tags"
+      it_should_behave_like "a Gherkin lexer lexing py_strings"
+      it_should_behave_like "a Gherkin lexer lexing rows"
+    end
+  end
+end
+end