cuke_modeler 1.0.4 → 1.1.0

data/testing/rspec/spec/integration/gherkin_2_adapter_spec.rb

@@ -3,54 +3,54 @@ require "#{File.dirname(__FILE__)}/../spec_helper"
 
 describe 'Gherkin2Adapter, Integration', :gherkin2 => true do
 
-  let(:source_text) { '@tag1 @tag2 @tag3
-                       Feature: A feature with everything it could have
+  let(:source_text) { "@tag1 @tag2 @tag3
+                       #{@feature_keyword}: A feature with everything it could have
 
                        Including a description
                        and then some.
 
-                         Background:
+                         #{@background_keyword}:
 
                          Background
                          description
 
-                           * a step
+                           #{@step_keyword} a step
                              | value1 |
-                           * another step
+                           #{@step_keyword} another step
 
                          @scenario_tag
-                         Scenario:
+                         #{@scenario_keyword}:
 
                          Scenario
                          description
 
-                           * a step
-                           * another step
-                             """"
+                           #{@step_keyword} a step
+                           #{@step_keyword} another step
+                             \"\"\"
                              some text
-                             """
+                             \"\"\"
 
                          @outline_tag
-                         Scenario Outline:
+                         #{@outline_keyword}:
 
                          Outline
                          description
 
-                           * a step
+                           #{@step_keyword} a step
                              | value2 |
-                           * another step
-                             """
+                           #{@step_keyword} another step
+                             \"\"\"
                              some text
-                             """
+                             \"\"\"
 
                          @example_tag
-                         Examples:
+                         #{@example_keyword}:
 
                          Example
                          description
 
                            | param |
-                           | value |' }
+                           | value |" }
   let(:feature) { CukeModeler::Feature.new(source_text) }
 
 

data/testing/rspec/spec/integration/gherkin_3_adapter_spec.rb

@@ -3,54 +3,54 @@ require "#{File.dirname(__FILE__)}/../spec_helper"
 
 describe 'Gherkin3Adapter, Integration', :gherkin3 => true do
 
-  let(:source_text) { '@tag1 @tag2 @tag3
-                       Feature: A feature with everything it could have
+  let(:source_text) { "@tag1 @tag2 @tag3
+                       #{@feature_keyword}: A feature with everything it could have
 
                        Including a description
                        and then some.
 
-                         Background:
+                         #{@background_keyword}:
 
                          Background
                          description
 
-                           * a step
+                           #{@step_keyword} a step
                              | value1 |
-                           * another step
+                           #{@step_keyword} another step
 
                          @scenario_tag
-                         Scenario:
+                         #{@scenario_keyword}:
 
                          Scenario
                          description
 
-                           * a step
-                           * another step
-                             """"
+                           #{@step_keyword} a step
+                           #{@step_keyword} another step
+                             \"\"\"
                              some text
-                             """
+                             \"\"\"
 
                          @outline_tag
-                         Scenario Outline:
+                         #{@outline_keyword}:
 
                          Outline
                          description
 
-                           * a step
+                           #{@step_keyword} a step
                              | value2 |
-                           * another step
-                             """
+                           #{@step_keyword} another step
+                             \"\"\"
                              some text
-                             """
+                             \"\"\"
 
                          @example_tag
-                         Examples:
+                         #{@example_keyword}:
 
                          Example
                          description
 
                            | param |
-                           | value |' }
+                           | value |" }
   let(:feature) { CukeModeler::Feature.new(source_text) }
 
 

data/testing/rspec/spec/integration/gherkin_4_adapter_spec.rb

@@ -3,54 +3,54 @@ require "#{File.dirname(__FILE__)}/../spec_helper"
 
 describe 'Gherkin4Adapter, Integration', :gherkin4 => true do
 
-  let(:source_text) { '@tag1 @tag2 @tag3
-                       Feature: A feature with everything it could have
+  let(:source_text) { "@tag1 @tag2 @tag3
+                       #{@feature_keyword}: A feature with everything it could have
 
                        Including a description
                        and then some.
 
-                         Background:
+                         #{@background_keyword}:
 
                          Background
                          description
 
-                           * a step
+                           #{@step_keyword} a step
                              | value1 |
-                           * another step
+                           #{@step_keyword} another step
 
                          @scenario_tag
-                         Scenario:
+                         #{@scenario_keyword}:
 
                          Scenario
                          description
 
-                           * a step
-                           * another step
-                             """"
+                           #{@step_keyword} a step
+                           #{@step_keyword} another step
+                             \"\"\"
                              some text
-                             """
+                             \"\"\"
 
                          @outline_tag
-                         Scenario Outline:
+                         #{@outline_keyword}:
 
                          Outline
                          description
 
-                           * a step
+                           #{@step_keyword} a step
                              | value2 |
-                           * another step
-                             """
+                           #{@step_keyword} another step
+                             \"\"\"
                              some text
-                             """
+                             \"\"\"
 
                          @example_tag
-                         Examples:
+                         #{@example_keyword}:
 
                          Example
                          description
 
                            | param |
-                           | value |' }
+                           | value |" }
   let(:feature) { CukeModeler::Feature.new(source_text) }
 
 

data/testing/rspec/spec/integration/outline_integration_spec.rb

@@ -15,21 +15,21 @@ describe 'Outline, Integration' do
   describe 'unique behavior' do
 
     it 'can be instantiated with the minimum viable Gherkin', :gherkin4 => true do
-      source = "Scenario Outline:"
+      source = "#{@outline_keyword}:"
 
       expect { clazz.new(source) }.to_not raise_error
     end
 
     it 'can be instantiated with the minimum viable Gherkin', :gherkin2 => true do
-      source = "Scenario Outline:"
+      source = "#{@outline_keyword}:"
 
       expect { clazz.new(source) }.to_not raise_error
     end
 
     # gherkin 3.x does not accept incomplete outlines
     it 'can be instantiated with the minimum viable Gherkin', :gherkin3 => true do
-      source = "Scenario Outline:
-                Examples:
+      source = "#{@outline_keyword}:
+                #{@example_keyword}:
                   | param |
                   | value |"
 
@@ -37,7 +37,7 @@ describe 'Outline, Integration' do
     end
 
     it 'stores the original data generated by the parsing adapter', :gherkin4 => true do
-      outline = clazz.new("@tag\nScenario Outline: test outline\ndescription\n* a step\nExamples:\n|param|\n|value|")
+      outline = clazz.new("@tag\n#{@outline_keyword}: test outline\ndescription\n#{@step_keyword} a step\n#{@example_keyword}:\n|param|\n|value|")
       data = outline.parsing_data
 
       expect(data.keys).to match_array([:type, :tags, :location, :keyword, :name, :steps, :examples, :description])
@@ -45,7 +45,7 @@ describe 'Outline, Integration' do
     end
 
     it 'stores the original data generated by the parsing adapter', :gherkin3 => true do
-      outline = clazz.new("@tag\nScenario Outline: test outline\ndescription\n* a step\nExamples:\n|param|\n|value|")
+      outline = clazz.new("@tag\n#{@outline_keyword}: test outline\ndescription\n#{@step_keyword} a step\n#{@example_keyword}:\n|param|\n|value|")
       data = outline.parsing_data
 
       expect(data.keys).to match_array([:type, :tags, :location, :keyword, :name, :steps, :examples, :description])
@@ -53,7 +53,7 @@ describe 'Outline, Integration' do
     end
 
     it 'stores the original data generated by the parsing adapter', :gherkin2 => true do
-      outline = clazz.new("@tag\nScenario Outline: test outline\ndescription\n* a step\nExamples:\n|param|\n|value|")
+      outline = clazz.new("@tag\n#{@outline_keyword}: test outline\ndescription\n#{@step_keyword} a step\n#{@example_keyword}:\n|param|\n|value|")
       data = outline.parsing_data
 
       expect(data.keys).to match_array(['keyword', 'name', 'line', 'description', 'id', 'type', 'examples', 'steps', 'tags'])
@@ -61,19 +61,18 @@ describe 'Outline, Integration' do
     end
 
     it 'provides a descriptive filename when being parsed from stand alone text' do
-      source = "bad outline text \n Scenario Outline:\n And a step\n @foo "
+      source = "bad outline text \n #{@outline_keyword}:\n #{@step_keyword} a step\n @foo "
 
       expect { clazz.new(source) }.to raise_error(/'cuke_modeler_stand_alone_outline\.feature'/)
     end
 
     it 'properly sets its child models' do
-      source = ['@a_tag',
-                '  Scenario Outline:',
-                '    * a step',
-                '  Examples:',
-                '    | param |',
-                '    | value |']
-      source = source.join("\n")
+      source = "@a_tag
+                  #{@outline_keyword}:
+                    #{@step_keyword} a step
+                  #{@example_keyword}:
+                    | param |
+                    | value |"
 
       outline = clazz.new(source)
       example = outline.examples.first
@@ -85,18 +84,16 @@ describe 'Outline, Integration' do
       expect(tag.parent_model).to equal(outline)
     end
 
-
     describe 'getting ancestors' do
 
       before(:each) do
-        source = ['Feature: Test feature',
-                  '',
-                  '  Scenario Outline: Test test',
-                  '    * a step',
-                  '  Examples: Test example',
-                  '    | a param |',
-                  '    | a value |']
-        source = source.join("\n")
+        source = "#{@feature_keyword}: Test feature
+
+                    #{@outline_keyword}: Test test
+                      #{@step_keyword} a step
+                    #{@example_keyword}: Test example
+                      | a param |
+                      | a value |"
 
         file_path = "#{@default_file_directory}/outline_test_file.feature"
         File.open(file_path, 'w') { |file| file.write(source) }
@@ -130,447 +127,455 @@ describe 'Outline, Integration' do
         expect(ancestor).to be_nil
       end
 
+    end
+
+
+    describe 'model population' do
 
-      describe 'model population' do
+      context 'from source text' do
 
-        context 'from source text' do
+        let(:source_text) { "#{@outline_keyword}:" }
+        let(:outline) { clazz.new(source_text) }
 
-          it "models the outline's source line" do
-            source_text = 'Feature:
 
-                             Scenario Outline: foo
-                               * step
-                             Examples:
+        # gherkin 3.x does not accept incomplete outlines
+        it "models the outline's keyword", :gherkin3 => false do
+          expect(outline.keyword).to eq("#{@outline_keyword}")
+        end
+
+        it "models the outline's source line" do
+          source_text = "#{@feature_keyword}:
+
+                             #{@outline_keyword}: foo
+                               #{@step_keyword} step
+                             #{@example_keyword}:
                                | param |
-                               | value |'
-            outline = CukeModeler::Feature.new(source_text).tests.first
+                               | value |"
+          outline = CukeModeler::Feature.new(source_text).tests.first
 
-            expect(outline.source_line).to eq(3)
-          end
+          expect(outline.source_line).to eq(3)
+        end
 
 
-          context 'a filled outline' do
+        context 'a filled outline' do
 
-            let(:source_text) { '@tag1 @tag2 @tag3
-                                 Scenario Outline: Foo
+          let(:source_text) { "@tag1 @tag2 @tag3
+                                 #{@outline_keyword}: Foo
                                      Scenario description.
 
                                    Some more.
                                        Even more.
 
-                                   Given a <setup> step
-                                   When an action step
-                                   Then a <verification> step
+                                   #{@step_keyword} a <setup> step
+                                   #{@step_keyword} an action step
+                                   #{@step_keyword} a <verification> step
 
-                                 Examples: example 1
+                                 #{@example_keyword}: example 1
                                    | setup | verification |
                                    | x     | y            |
-                                 Examples: example 2
+                                 #{@example_keyword}: example 2
                                    | setup | verification |
-                                   | a     | b            |' }
-            let(:outline) { clazz.new(source_text) }
-
+                                   | a     | b            |" }
+          let(:outline) { clazz.new(source_text) }
 
-            it "models the outline's name" do
-              expect(outline.name).to eq('Foo')
-            end
 
-            it "models the outline's description" do
-              description = outline.description.split("\n")
+          it "models the outline's name" do
+            expect(outline.name).to eq('Foo')
+          end
 
-              expect(description).to eq(['  Scenario description.',
-                                         '',
-                                         'Some more.',
-                                         '    Even more.'])
-            end
+          it "models the outline's description" do
+            description = outline.description.split("\n", -1)
 
-            it "models the outline's steps" do
-              step_names = outline.steps.collect { |step| step.text }
+            expect(description).to eq(['  Scenario description.',
+                                       '',
+                                       'Some more.',
+                                       '    Even more.'])
+          end
 
-              expect(step_names).to eq(['a <setup> step', 'an action step', 'a <verification> step'])
-            end
+          it "models the outline's steps" do
+            step_names = outline.steps.collect { |step| step.text }
 
-            it "models the outline's tags" do
-              tag_names = outline.tags.collect { |tag| tag.name }
+            expect(step_names).to eq(['a <setup> step', 'an action step', 'a <verification> step'])
+          end
 
-              expect(tag_names).to eq(['@tag1', '@tag2', '@tag3'])
-            end
+          it "models the outline's tags" do
+            tag_names = outline.tags.collect { |tag| tag.name }
 
-            it "models the outline's examples" do
-              example_names = outline.examples.collect { |example| example.name }
+            expect(tag_names).to eq(['@tag1', '@tag2', '@tag3'])
+          end
 
-              expect(example_names).to eq(['example 1', 'example 2'])
-            end
+          it "models the outline's examples" do
+            example_names = outline.examples.collect { |example| example.name }
 
+            expect(example_names).to eq(['example 1', 'example 2'])
           end
 
+        end
 
-          # gherkin 3.x does not accept incomplete outlines
-          context 'an empty outline', :gherkin3 => false do
 
-            let(:source_text) { 'Scenario Outline:' }
-            let(:outline) { clazz.new(source_text) }
+        # gherkin 3.x does not accept incomplete outlines
+        context 'an empty outline', :gherkin3 => false do
 
+          let(:source_text) { "#{@outline_keyword}:" }
+          let(:outline) { clazz.new(source_text) }
 
-            it "models the outline's name" do
-              expect(outline.name).to eq('')
-            end
 
-            it "models the outline's description" do
-              expect(outline.description).to eq('')
-            end
+          it "models the outline's name" do
+            expect(outline.name).to eq('')
+          end
 
-            it "models the outline's steps" do
-              expect(outline.steps).to eq([])
-            end
+          it "models the outline's description" do
+            expect(outline.description).to eq('')
+          end
 
-            it "models the outline's tags" do
-              expect(outline.tags).to eq([])
-            end
+          it "models the outline's steps" do
+            expect(outline.steps).to eq([])
+          end
 
-            it "models the outline's examples" do
-              expect(outline.examples).to eq([])
-            end
+          it "models the outline's tags" do
+            expect(outline.tags).to eq([])
+          end
 
+          it "models the outline's examples" do
+            expect(outline.examples).to eq([])
           end
 
         end
 
-        it 'trims whitespace from its source description' do
-          source = ['Scenario Outline:',
-                    '  ',
-                    '        description line 1',
-                    '',
-                    '   description line 2',
-                    '     description line 3               ',
-                    '',
-                    '',
-                    '',
-                    '  * a step',
-                    '',
-                    'Examples:',
-                    '|param|',
-                    '|value|']
-          source = source.join("\n")
+      end
 
-          outline = clazz.new(source)
-          description = outline.description.split("\n")
+    end
 
-          expect(description).to eq(['     description line 1',
-                                     '',
-                                     'description line 2',
-                                     '  description line 3'])
-        end
+    it 'trims whitespace from its source description' do
+      source = ["#{@outline_keyword}:",
+                '  ',
+                '        description line 1',
+                '',
+                '   description line 2',
+                '     description line 3               ',
+                '',
+                '',
+                '',
+                "  #{@step_keyword} a step",
+                '',
+                "#{@example_keyword}:",
+                '|param|',
+                '|value|']
+      source = source.join("\n")
 
-      end
+      outline = clazz.new(source)
+      description = outline.description.split("\n", -1)
+
+      expect(description).to eq(['     description line 1',
+                                 '',
+                                 'description line 2',
+                                 '  description line 3'])
+    end
 
 
-      describe 'comparison' do
+    describe 'comparison' do
 
-        it 'is equal to a background with the same steps' do
-          source = "Scenario Outline:
-                      * step 1
-                      * step 2
-                    Examples:
+      it 'is equal to a background with the same steps' do
+        source = "#{@outline_keyword}:
+                      #{@step_keyword} step 1
+                      #{@step_keyword} step 2
+                    #{@example_keyword}:
                       | param |
                       | value |"
-          outline = clazz.new(source)
+        outline = clazz.new(source)
 
-          source = "Background:
-                      * step 1
-                      * step 2"
-          background_1 = CukeModeler::Background.new(source)
+        source = "#{@background_keyword}:
+                      #{@step_keyword} step 1
+                      #{@step_keyword} step 2"
+        background_1 = CukeModeler::Background.new(source)
 
-          source = "Background:
-                      * step 2
-                      * step 1"
-          background_2 = CukeModeler::Background.new(source)
+        source = "#{@background_keyword}:
+                      #{@step_keyword} step 2
+                      #{@step_keyword} step 1"
+        background_2 = CukeModeler::Background.new(source)
 
 
-          expect(outline).to eq(background_1)
-          expect(outline).to_not eq(background_2)
-        end
+        expect(outline).to eq(background_1)
+        expect(outline).to_not eq(background_2)
+      end
 
-        it 'is equal to a scenario with the same steps' do
-          source = "Scenario Outline:
-                      * step 1
-                      * step 2
-                    Examples:
+      it 'is equal to a scenario with the same steps' do
+        source = "#{@outline_keyword}:
+                      #{@step_keyword} step 1
+                      #{@step_keyword} step 2
+                    #{@example_keyword}:
                       | param |
                       | value |"
-          outline = clazz.new(source)
+        outline = clazz.new(source)
 
-          source = "Scenario:
-                      * step 1
-                      * step 2"
-          scenario_1 = CukeModeler::Scenario.new(source)
+        source = "#{@scenario_keyword}:
+                      #{@step_keyword} step 1
+                      #{@step_keyword} step 2"
+        scenario_1 = CukeModeler::Scenario.new(source)
 
-          source = "Scenario:
-                      * step 2
-                      * step 1"
-          scenario_2 = CukeModeler::Scenario.new(source)
+        source = "#{@scenario_keyword}:
+                      #{@step_keyword} step 2
+                      #{@step_keyword} step 1"
+        scenario_2 = CukeModeler::Scenario.new(source)
 
 
-          expect(outline).to eq(scenario_1)
-          expect(outline).to_not eq(scenario_2)
-        end
+        expect(outline).to eq(scenario_1)
+        expect(outline).to_not eq(scenario_2)
+      end
 
-        it 'is equal to an outline with the same steps' do
-          source = "Scenario Outline:
-                      * step 1
-                      * step 2
-                    Examples:
+      it 'is equal to an outline with the same steps' do
+        source = "#{@outline_keyword}:
+                      #{@step_keyword} step 1
+                      #{@step_keyword} step 2
+                    #{@example_keyword}:
                       | param |
                       | value |"
-          outline_1 = clazz.new(source)
+        outline_1 = clazz.new(source)
 
-          source = "Scenario Outline:
-                      * step 1
-                      * step 2
-                    Examples:
+        source = "#{@outline_keyword}:
+                      #{@step_keyword} step 1
+                      #{@step_keyword} step 2
+                    #{@example_keyword}:
                       | param |
                       | value |"
-          outline_2 = clazz.new(source)
+        outline_2 = clazz.new(source)
 
-          source = "Scenario Outline:
-                      * step 2
-                      * step 1
-                    Examples:
+        source = "#{@outline_keyword}:
+                      #{@step_keyword} step 2
+                      #{@step_keyword} step 1
+                    #{@example_keyword}:
                       | param |
                       | value |"
-          outline_3 = clazz.new(source)
+        outline_3 = clazz.new(source)
 
 
-          expect(outline_1).to eq(outline_2)
-          expect(outline_1).to_not eq(outline_3)
-        end
+        expect(outline_1).to eq(outline_2)
+        expect(outline_1).to_not eq(outline_3)
+      end
+
+    end
+
+
+    describe 'outline output' do
+
+      it 'can be remade from its own output' do
+        source = "@tag1 @tag2 @tag3
+                  #{@outline_keyword}: An outline with everything it could have
+
+                  Some description.
+                  Some more description.
 
+                    #{@step_keyword} a step
+                      | value |
+                    #{@step_keyword} a <value> step
+                      \"\"\"
+                        some string
+                      \"\"\"
+
+        #{@example_keyword}:
+
+                  Some description.
+                  Some more description.
+
+                    | value |
+                    | x     |
+
+                  @example_tag
+                  #{@example_keyword}:
+                    | value |
+                    | y     |"
+        outline = clazz.new(source)
+
+        outline_output = outline.to_s
+        remade_outline_output = clazz.new(outline_output).to_s
+
+        expect(remade_outline_output).to eq(outline_output)
       end
 
 
-      describe 'outline output' do
+      context 'from source text' do
 
-        it 'can be remade from its own output' do
-          source = ['@tag1 @tag2 @tag3',
-                    'Scenario Outline: An outline with everything it could have',
-                    '',
-                    'Some description.',
-                    'Some more description.',
-                    '',
-                    '  * a step',
-                    '    | value |',
-                    '  * a <value> step',
-                    '    """',
-                    '      some string',
-                    '    """',
-                    '',
-                    'Examples:',
-                    '',
-                    'Some description.',
-                    'Some more description.',
-                    '',
-                    '  | value |',
-                    '  | x     |',
-                    '',
-                    '@example_tag',
-                    'Examples:',
-                    '  | value |',
-                    '  | y     |']
+        # gherkin 3.x does not accept incomplete outlines
+        it 'can output an empty outline', :gherkin3 => false do
+          source = ["#{@outline_keyword}:"]
           source = source.join("\n")
           outline = clazz.new(source)
 
-          outline_output = outline.to_s
-          remade_outline_output = clazz.new(outline_output).to_s
+          outline_output = outline.to_s.split("\n", -1)
 
-          expect(remade_outline_output).to eq(outline_output)
+          expect(outline_output).to eq(["#{@outline_keyword}:"])
         end
 
+        # gherkin 3.x does not accept incomplete outlines
+        it 'can output a outline that has a name', :gherkin3 => false do
+          source = ["#{@outline_keyword}: test outline"]
+          source = source.join("\n")
+          outline = clazz.new(source)
 
-        context 'from source text' do
-
-          # gherkin 3.x does not accept incomplete outlines
-          it 'can output an empty outline', :gherkin3 => false do
-            source = ['Scenario Outline:']
-            source = source.join("\n")
-            outline = clazz.new(source)
-
-            outline_output = outline.to_s.split("\n")
+          outline_output = outline.to_s.split("\n", -1)
 
-            expect(outline_output).to eq(['Scenario Outline:'])
-          end
+          expect(outline_output).to eq(["#{@outline_keyword}: test outline"])
+        end
 
-          # gherkin 3.x does not accept incomplete outlines
-          it 'can output a outline that has a name', :gherkin3 => false do
-            source = ['Scenario Outline: test outline']
-            source = source.join("\n")
-            outline = clazz.new(source)
+        # gherkin 3.x does not accept incomplete outlines
+        it 'can output a outline that has a description', :gherkin3 => false do
+          source = ["#{@outline_keyword}:",
+                    'Some description.',
+                    'Some more description.']
+          source = source.join("\n")
+          outline = clazz.new(source)
 
-            outline_output = outline.to_s.split("\n")
+          outline_output = outline.to_s.split("\n", -1)
 
-            expect(outline_output).to eq(['Scenario Outline: test outline'])
-          end
+          expect(outline_output).to eq(["#{@outline_keyword}:",
+                                        '',
+                                        'Some description.',
+                                        'Some more description.'])
+        end
 
-          # gherkin 3.x does not accept incomplete outlines
-          it 'can output a outline that has a description', :gherkin3 => false do
-            source = ['Scenario Outline:',
-                      'Some description.',
-                      'Some more description.']
-            source = source.join("\n")
-            outline = clazz.new(source)
+        # gherkin 3.x does not accept incomplete outlines
+        it 'can output a outline that has steps', :gherkin3 => false do
+          source = ["#{@outline_keyword}:",
+                    "  #{@step_keyword} a step",
+                    '    | value |',
+                    "  #{@step_keyword} another step",
+                    '    """',
+                    '    some string',
+                    '    """']
+          source = source.join("\n")
+          outline = clazz.new(source)
 
-            outline_output = outline.to_s.split("\n")
+          outline_output = outline.to_s.split("\n", -1)
 
-            expect(outline_output).to eq(['Scenario Outline:',
-                                          '',
-                                          'Some description.',
-                                          'Some more description.'])
-          end
+          expect(outline_output).to eq(["#{@outline_keyword}:",
+                                        "  #{@step_keyword} a step",
+                                        '    | value |',
+                                        "  #{@step_keyword} another step",
+                                        '    """',
+                                        '    some string',
+                                        '    """'])
+        end
 
-          # gherkin 3.x does not accept incomplete outlines
-          it 'can output a outline that has steps', :gherkin3 => false do
-            source = ['Scenario Outline:',
-                      '  * a step',
-                      '    | value |',
-                      '  * another step',
-                      '    """',
-                      '    some string',
-                      '    """']
-            source = source.join("\n")
-            outline = clazz.new(source)
-
-            outline_output = outline.to_s.split("\n")
-
-            expect(outline_output).to eq(['Scenario Outline:',
-                                          '  * a step',
-                                          '    | value |',
-                                          '  * another step',
-                                          '    """',
-                                          '    some string',
-                                          '    """'])
-          end
+        # gherkin 3.x does not accept incomplete outlines
+        it 'can output a outline that has tags', :gherkin3 => false do
+          source = ['@tag1 @tag2',
+                    '@tag3',
+                    "#{@outline_keyword}:"]
+          source = source.join("\n")
+          outline = clazz.new(source)
 
-          # gherkin 3.x does not accept incomplete outlines
-          it 'can output a outline that has tags', :gherkin3 => false do
-            source = ['@tag1 @tag2',
-                      '@tag3',
-                      'Scenario Outline:']
-            source = source.join("\n")
-            outline = clazz.new(source)
+          outline_output = outline.to_s.split("\n", -1)
 
-            outline_output = outline.to_s.split("\n")
+          expect(outline_output).to eq(['@tag1 @tag2 @tag3',
+                                        "#{@outline_keyword}:"])
+        end
 
-            expect(outline_output).to eq(['@tag1 @tag2 @tag3',
-                                          'Scenario Outline:'])
-          end
+        it 'can output a outline that has examples' do
+          source = ["#{@outline_keyword}:",
+                    "#{@step_keyword} a step",
+                    "#{@example_keyword}:",
+                    '| value |',
+                    '| x     |',
+                    "#{@example_keyword}:",
+                    '| value |',
+                    '| y     |']
+          source = source.join("\n")
+          outline = clazz.new(source)
 
-          it 'can output a outline that has examples' do
-            source = ['Scenario Outline:',
-                      '* a step',
-                      'Examples:',
-                      '| value |',
-                      '| x     |',
-                      'Examples:',
-                      '| value |',
-                      '| y     |']
-            source = source.join("\n")
-            outline = clazz.new(source)
-
-            outline_output = outline.to_s.split("\n")
-
-            expect(outline_output).to eq(['Scenario Outline:',
-                                          '  * a step',
-                                          '',
-                                          'Examples:',
-                                          '  | value |',
-                                          '  | x     |',
-                                          '',
-                                          'Examples:',
-                                          '  | value |',
-                                          '  | y     |'])
-          end
+          outline_output = outline.to_s.split("\n", -1)
+
+          expect(outline_output).to eq(["#{@outline_keyword}:",
+                                        "  #{@step_keyword} a step",
+                                        '',
+                                        "#{@example_keyword}:",
+                                        '  | value |',
+                                        '  | x     |',
+                                        '',
+                                        "#{@example_keyword}:",
+                                        '  | value |',
+                                        '  | y     |'])
+        end
 
-          it 'can output a outline that has everything' do
-            source = ['@tag1 @tag2 @tag3',
-                      'Scenario Outline: A outline with everything it could have',
-                      'Including a description',
-                      'and then some.',
-                      '* a step',
-                      '|value|',
-                      '* another step',
-                      '"""',
-                      'some string',
-                      '"""',
-                      '',
-                      'Examples:',
-                      '',
-                      'Some description.',
-                      'Some more description.',
-                      '',
-                      '| value |',
-                      '| x     |',
-                      '',
-                      '@example_tag',
-                      'Examples:',
-                      '| value |',
-                      '| y     |']
-            source = source.join("\n")
-            outline = clazz.new(source)
-
-            outline_output = outline.to_s.split("\n")
-
-            expect(outline_output).to eq(['@tag1 @tag2 @tag3',
-                                          'Scenario Outline: A outline with everything it could have',
-                                          '',
-                                          'Including a description',
-                                          'and then some.',
-                                          '',
-                                          '  * a step',
-                                          '    | value |',
-                                          '  * another step',
-                                          '    """',
-                                          '    some string',
-                                          '    """',
-                                          '',
-                                          'Examples:',
-                                          '',
-                                          'Some description.',
-                                          'Some more description.',
-                                          '',
-                                          '  | value |',
-                                          '  | x     |',
-                                          '',
-                                          '@example_tag',
-                                          'Examples:',
-                                          '  | value |',
-                                          '  | y     |'])
-          end
+        it 'can output a outline that has everything' do
+          source = ['@tag1 @tag2 @tag3',
+                    "#{@outline_keyword}: A outline with everything it could have",
+                    'Including a description',
+                    'and then some.',
+                    "#{@step_keyword} a step",
+                    '|value|',
+                    "#{@step_keyword} another step",
+                    '"""',
+                    'some string',
+                    '"""',
+                    '',
+                    "#{@example_keyword}:",
+                    '',
+                    'Some description.',
+                    'Some more description.',
+                    '',
+                    '| value |',
+                    '| x     |',
+                    '',
+                    '@example_tag',
+                    "#{@example_keyword}:",
+                    '| value |',
+                    '| y     |']
+          source = source.join("\n")
+          outline = clazz.new(source)
 
+          outline_output = outline.to_s.split("\n", -1)
+
+          expect(outline_output).to eq(['@tag1 @tag2 @tag3',
+                                        "#{@outline_keyword}: A outline with everything it could have",
+                                        '',
+                                        'Including a description',
+                                        'and then some.',
+                                        '',
+                                        "  #{@step_keyword} a step",
+                                        '    | value |',
+                                        "  #{@step_keyword} another step",
+                                        '    """',
+                                        '    some string',
+                                        '    """',
+                                        '',
+                                        "#{@example_keyword}:",
+                                        '',
+                                        'Some description.',
+                                        'Some more description.',
+                                        '',
+                                        '  | value |',
+                                        '  | x     |',
+                                        '',
+                                        '@example_tag',
+                                        "#{@example_keyword}:",
+                                        '  | value |',
+                                        '  | y     |'])
         end
 
+      end
 
-        context 'from abstract instantiation' do
 
-          let(:outline) { clazz.new }
+      context 'from abstract instantiation' do
 
+        let(:outline) { clazz.new }
 
-          it 'can output an outline that has only tags' do
-            outline.tags = [CukeModeler::Tag.new]
 
-            expect { outline.to_s }.to_not raise_error
-          end
+        it 'can output an outline that has only tags' do
+          outline.tags = [CukeModeler::Tag.new]
 
-          it 'can output an outline that has only steps' do
-            outline.steps = [CukeModeler::Step.new]
+          expect { outline.to_s }.to_not raise_error
+        end
 
-            expect { outline.to_s }.to_not raise_error
-          end
+        it 'can output an outline that has only steps' do
+          outline.steps = [CukeModeler::Step.new]
 
-          it 'can output an outline that has only examples' do
-            outline.examples = [CukeModeler::Example.new]
+          expect { outline.to_s }.to_not raise_error
+        end
 
-            expect { outline.to_s }.to_not raise_error
-          end
+        it 'can output an outline that has only examples' do
+          outline.examples = [CukeModeler::Example.new]
 
+          expect { outline.to_s }.to_not raise_error
         end
 
       end