bryanl-gherkin 2.11.1.1

data/spec/gherkin/formatter/json_formatter_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+require 'stringio'
+require 'gherkin/formatter/json_formatter'
+require 'gherkin/formatter/model'
+
+module Gherkin
+  module Formatter
+    describe JSONFormatter do
+      it "renders results" do
+        io = StringIO.new
+        f = JSONFormatter.new(io)
+        f.uri("f.feature")
+        f.feature(Model::Feature.new([], [], "Feature", "ff", "", 1, "ff"))
+        f.scenario(Model::Scenario.new([], [], "Scenario", "ss", "", 2, "ff/ss"))
+
+        f.step(Model::Step.new([], "Given ", "g", 3, nil, nil))
+        f.match(Model::Match.new([], "def.rb:33"))
+        f.result(Model::Result.new(:passed, 1, nil))
+
+        f.step(Model::Step.new([], "When ", "w", 4, nil, nil))
+        f.match(Model::Match.new([], "def.rb:44"))
+        f.result(Model::Result.new(:passed, 1, nil))
+
+        f.after(Model::Match.new([], "def.rb:55"), Model::Result.new(:passed, 22, nil))
+
+        f.eof
+        f.done
+        
+        expected = %{
+          [
+            {
+              "id": "ff",
+              "uri": "f.feature",
+              "keyword": "Feature",
+              "name": "ff",
+              "line": 1,
+              "description": "",
+              "elements": [
+                {
+                  "id": "ff/ss",
+                  "keyword": "Scenario",
+                  "name": "ss",
+                  "line": 2,
+                  "description": "",
+                  "type": "scenario",
+                  "steps": [
+                    {
+                      "keyword": "Given ",
+                      "name": "g",
+                      "line": 3,
+                      "match": {
+                        "location": "def.rb:33"
+                      },
+                      "result": {
+                        "status": "passed",
+                        "duration": 1
+                      }
+                    },
+                    {
+                      "keyword": "When ",
+                      "name": "w",
+                      "line": 4,
+                      "match": {
+                        "location": "def.rb:44"
+                      },
+                      "result": {
+                        "status": "passed",
+                        "duration": 1
+                      }
+                    }
+                  ],
+                  "after": [
+                    {
+                      "match":{
+                        "location":"def.rb:55"
+                      },
+                      "result":{
+                        "status":"passed",
+                        "duration": 22
+                      }
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        }
+        JSON.parse(expected).should == JSON.parse(io.string)
+      end
+    end
+  end
+end

data/spec/gherkin/formatter/model_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+require 'gherkin/formatter/model'
+require 'gherkin/formatter/argument'
+
+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
+
+      describe Step do
+        it "should provide arguments for outline tokens" do
+          step = Step.new([], 'Given ', "I have <number> cukes in <whose> belly", 10, nil, nil)
+          step.outline_args.map{|arg| [arg.offset, arg.val]}.should == [[7, "<number>"], [25, "<whose>"]]
+        end
+
+        it "should provide no arguments when there are no outline tokens" do
+          step = Step.new([], 'Given ', "I have 33 cukes in my belly", 10, nil, nil)
+          step.outline_args.to_a.should == []
+        end
+      end
+    end
+  end
+end

data/spec/gherkin/formatter/pretty_formatter_spec.rb

@@ -0,0 +1,177 @@
+# 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 'gherkin/parser/parser'
+require 'stringio'
+
+module Gherkin
+  module Formatter
+    describe PrettyFormatter do
+      include AnsiEscapes
+
+      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, false)
+          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
+
+      before do
+        @io = StringIO.new
+        @f = Gherkin::Formatter::PrettyFormatter.new(@io, false, true)
+      end
+
+      it "should print comments when scenario is longer" do
+        @f.uri("features/foo.feature")
+        @f.feature(Model::Feature.new([], [], "Feature", "Hello", "World", 1, "hello"))
+
+        @f.scenario(Model::Scenario.new([], [], "Scenario", "The scenario", "", 4, "the-scenario"))
+        @f.step(Model::Step.new([], "Given ", "some stuff", 5, nil, nil))
+        @f.step(Model::Step.new([], "When ", "foo", 6, nil, nil))
+
+        @f.match(Model::Match.new([], "features/step_definitions/bar.rb:56"))
+        @f.result(Model::Result.new('passed', 22, nil))
+
+        @f.match(Model::Match.new([], "features/step_definitions/bar.rb:96"))
+        @f.result(Model::Result.new('passed', 33, nil))
+
+        assert_io(%{Feature: Hello
+  World
+
+  Scenario: The scenario #{comments}# features/foo.feature:4#{reset}
+    #{executing}Given #{reset}#{executing}some stuff#{reset}     #{comments}# features/step_definitions/bar.rb:56#{reset}
+#{up(1)}    #{passed}Given #{reset}#{passed}some stuff#{reset}     #{comments}# features/step_definitions/bar.rb:56#{reset}
+    #{executing}When #{reset}#{executing}foo#{reset}             #{comments}# features/step_definitions/bar.rb:96#{reset}
+#{up(1)}    #{passed}When #{reset}#{passed}foo#{reset}             #{comments}# features/step_definitions/bar.rb:96#{reset}
+})
+      end
+
+      it "should print comments when step is longer" do
+        @f.uri("features/foo.feature")
+        @f.feature(Model::Feature.new([], [], "Feature", "Hello", "World", 1, "hello"))
+        step = Model::Step.new([], "Given ", "some stuff that is longer", 5, nil, nil)
+        match = Model::Match.new([], "features/step_definitions/bar.rb:56")
+        result = Model::Result.new('passed', 0, nil)
+
+        @f.scenario(Model::Scenario.new([], [], "Scenario", "The scenario", "", 4, "the-scenario"))
+        @f.step(step)
+        @f.match(match)
+        @f.result(result)
+
+        assert_io(%{Feature: Hello
+  World
+
+  Scenario: The scenario            #{comments}# features/foo.feature:4#{reset}
+    #{executing}Given #{reset}#{executing}some stuff that is longer#{reset} #{comments}# features/step_definitions/bar.rb:56#{reset}
+#{up(1)}    #{passed}Given #{reset}#{passed}some stuff that is longer#{reset} #{comments}# features/step_definitions/bar.rb:56#{reset}
+})
+      end
+
+      it "should highlight arguments for regular steps" do
+        @f.uri("foo.feature")
+        @f.scenario(Model::Scenario.new([], [], "Scenario", "Lots of cukes", "", 3, "lots-of-cukes"))
+        @f.step(Model::Step.new([], "Given ", "I have 999 cukes in my belly", 3, nil, nil))
+        @f.match(Model::Match.new([Gherkin::Formatter::Argument.new(7, '999')], nil))
+        @f.result(Model::Result.new('passed', 6, nil))
+
+        assert_io(
+          "\n" +
+          "  Scenario: Lots of cukes              \e[90m# foo.feature:3\e[0m\n" +
+          "    #{executing}Given #{reset}#{executing}I have #{reset}#{executing_arg}999#{reset}#{executing} cukes in my belly#{reset}\n" +
+          "#{up(1)}    #{passed}Given #{reset}#{passed}I have #{reset}#{passed_arg}999#{reset}#{passed} cukes in my belly#{reset}\n"
+        )
+      end
+
+      # See https://github.com/cucumber/gherkin/pull/171
+      it "should highlight arguments when there are optional arguments" do
+        @f.uri("foo.feature")
+        @f.scenario(Model::Scenario.new([], [], "Scenario", "Lots of cukes", "", 3, "lots-of-cukes"))
+        @f.step(Model::Step.new([], "Given ", "I have 999 cukes in my belly", 3, nil, nil))
+        @f.match(Model::Match.new([
+          Gherkin::Formatter::Argument.new(nil, nil), # An optional argument
+          Gherkin::Formatter::Argument.new(7, '999')
+        ], nil))
+        @f.result(Model::Result.new('passed', 6, nil))
+
+        assert_io(
+          "\n" +
+          "  Scenario: Lots of cukes              \e[90m# foo.feature:3\e[0m\n" +
+          "    #{executing}Given #{reset}#{executing}I have #{reset}#{executing_arg}999#{reset}#{executing} cukes in my belly#{reset}\n" +
+          "#{up(1)}    #{passed}Given #{reset}#{passed}I have #{reset}#{passed_arg}999#{reset}#{passed} cukes in my belly#{reset}\n"
+        )
+      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
+        f = Gherkin::Formatter::PrettyFormatter.new(io, true, false)
+        f.__send__(:table, [Gherkin::Formatter::Model::DataTableRow.new([], ['|', '\\'], 1)])
+        io.string.should == '      | \\| | \\\\ |' + "\n"
+      end
+    end
+  end
+end

data/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/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 text(text)
+        "(#{text})"
+      end
+    end
+    
+    class BracketFormat
+      def text(text)
+        "[#{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/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/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/spec/gherkin/i18n_spec.rb

@@ -0,0 +1,241 @@
+#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 recognize keywords that are a little ambiguous" do
+        lexer = Gherkin::Lexer::I18nLexer.new(@listener, false)
+        scan_file(lexer, "i18n_fr2.feature")
+        @listener.to_sexp.should == [
+          [:comment, "#language:fr", 1],
+          [:feature, "Fonctionnalité", "i18n", "", 2],
+          [:scenario, "Scénario", "Le French", "", 4],
+          [:step, "Etant donné ", "qqch", 5],
+          [:step, "Etant donnée ", "qqch", 6],
+          [:step, "Etant donnés ", "qqch", 7],
+          [:step, "Etant données ", "qqch", 8],
+          [: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
+
+      it "should recognize keywords in Portuguese (1st variant)" do
+        lexer = Gherkin::Lexer::I18nLexer.new(@listener, false)
+        scan_file(lexer, "i18n_pt1.feature")
+        @listener.to_sexp.should == [
+          [:comment, "# language: pt", 1],
+          [:feature, "Funcionalidade", "Reconhece \"Funcionalidade\"", "", 2],
+          [:background, "Contexto", "Reconhece \"Contexto\"", "", 4],
+          [:scenario, "Cenário", "Reconhece \"Cenário\" com acento", "", 6],
+          [:scenario, "Cenario", "Reconhece \"Cenário\" sem acento", "", 8],
+          [:scenario_outline, "Esquema do Cenário", "Reconhece \"Esquema do Cenário\" com acento", "", 10],
+          [:step, "Dado ", "que <Valor> é um valor e que reconhece \"Dado\";", 11],
+          [:step, "Dada ", "a afirmação de que reconhece \"Dada\";", 12],
+          [:step, "Dados ", "os factos acima e ainda que reconhece \"Dados\";", 13],
+          [:step, "Dadas ", "as afirmações acima e ainda que reconhece \"Dadas\";", 14],
+          [:step, "Quando ", "reconhece \"Quando\";", 15],
+          [:step, "Então ", "também reconhece \"Então\" com acento e", 16],
+          [:step, "Entao ", "também reconhece \"Então\" sem acento;", 17],
+          [:step, "E ", "reconhece \"E\";", 18],
+          [:step, "Mas ", "também reconhece \"Mas\".", 19],
+          [:examples, "Exemplos", "Reconhece \"Exemplos\"", "", 21],
+          [:row, ["Valor"], 22],
+          [:row, ["1"], 23],
+          [:scenario_outline, "Esquema do Cenario", "Reconhece \"Esquema do Cenário\" sem acento", "", 25],
+          [:step, "Dado ", "que <Valor> é um valor;", 26],
+          [:examples, "Cenários", "Reconhece \"Cenários\" com acento", "", 28],
+          [:row, ["Valor"], 29],
+          [:row, ["1"], 30],
+          [:scenario_outline, "Delineação do Cenário", "Reconhece \"Delineação do Cenário\" com acento", "", 32],
+          [:step, "Dado ", "que <Valor> é um valor;", 33],
+          [:examples, "Cenarios", "Reconhece \"Cenários\" sem acento", "", 35],
+          [:row, ["Valor"], 36],
+          [:row, ["1"], 37],
+          [:scenario_outline, "Delineacao do Cenario", "Reconhece \"Delineação do Cenário\" sem acento", "", 39],
+          [:step, "Dado ", "que <Valor> é um valor;", 40],
+          [:examples, "Exemplos", "Reconhece \"Exemplos\"", "", 42],
+          [:row, ["Valor"], 43],
+          [:row, ["1"], 44],
+          [:eof]
+        ]
+      end
+
+      it "should recognize keywords in Portuguese (2nd variant)" do
+        lexer = Gherkin::Lexer::I18nLexer.new(@listener, false)
+        scan_file(lexer, "i18n_pt2.feature")
+        @listener.to_sexp.should == [
+          [:comment, "# language: pt", 1],
+          [:feature, "Característica", "Reconhece \"Característica\" com acento", "", 2],
+          [:background, "Cenário de Fundo", "Reconhece \"Cenário de Fundo\" com acento", "", 4],
+          [:eof]
+        ]
+      end
+
+      it "should recognize keywords in Portuguese (3rd variant)" do
+        lexer = Gherkin::Lexer::I18nLexer.new(@listener, false)
+        scan_file(lexer, "i18n_pt3.feature")
+        @listener.to_sexp.should == [
+          [:comment, "# language: pt", 1],
+          [:feature, "Caracteristica", "Reconhece \"Característica\" sem acento", "", 2],
+          [:background, "Cenario de Fundo", "Reconhece \"Cenário de Fundo\" sem acento", "", 4],
+          [:eof]
+        ]
+      end
+
+      it "should recognize keywords in Portuguese (4th variant)" do
+        lexer = Gherkin::Lexer::I18nLexer.new(@listener, false)
+        scan_file(lexer, "i18n_pt4.feature")
+        @listener.to_sexp.should == [
+          [:comment, "# language: pt", 1],
+          [:feature, "Característica", "Reconhece \"Característica\" com acento", "", 2],
+          [:background, "Fundo", "Reconhece \"Fundo\"", "", 4],
+          [: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
+
+        it "should print available languages" do
+          ("\n" + Gherkin::I18n.language_table).should == %{
+      | ar        | Arabic              | العربية           |
+      | bg        | Bulgarian           | български         |
+      | bm        | Malay               | Bahasa Melayu     |
+      | 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  |
+      | is        | Icelandic           | Íslenska          |
+      | 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ă            |
+      | 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
+
+        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é ", "Etant donnée ", "Etant donnés ", "Etant données ", "Étant donné ", "Étant donnée ", "Étant donnés ", "Étant données " |
+      | when             | "* ", "Quand ", "Lorsque ", "Lorsqu'"                                                                                                                 |
+      | then             | "* ", "Alors "                                                                                                                                        |
+      | and              | "* ", "Et "                                                                                                                                           |
+      | but              | "* ", "Mais "                                                                                                                                         |
+      | given (code)     | "Soit", "Etantdonné", "Etantdonnée", "Etantdonnés", "Etantdonnées", "Étantdonné", "Étantdonnée", "Étantdonnés", "Étantdonnées"                        |
+      | when (code)      | "Quand", "Lorsque", "Lorsqu"                                                                                                                          |
+      | then (code)      | "Alors"                                                                                                                                               |
+      | and (code)       | "Et"                                                                                                                                                  |
+      | but (code)       | "Mais"                                                                                                                                                |
+}
+        end
+      end
+    end
+  end
+end