github.com/getgauge/gauge@v1.6.9/parser/specparser_test.go

/*----------------------------------------------------------------
 *  Copyright (c) ThoughtWorks, Inc.
 *  Licensed under the Apache License, Version 2.0
 *  See LICENSE in the project root for license information.
 *----------------------------------------------------------------*/

package parser

import (
	"path/filepath"
	"strings"
	"testing"

	"github.com/getgauge/gauge/env"
	"github.com/getgauge/gauge/gauge"

	. "gopkg.in/check.v1"
)

// Hook up gocheck into the "go test" runner.
func Test(t *testing.T) { TestingT(t) }

type MySuite struct{}

var _ = Suite(&MySuite{})

func (s *MySuite) TestToCheckTagsInSpecLevel(c *C) {
	tokens := []*Token{
		{Kind: gauge.SpecKind, Value: "Spec Heading", LineNo: 1},
		{Kind: gauge.TagKind, Args: []string{"tag1", "tag2"}, LineNo: 2},
		{Kind: gauge.ScenarioKind, Value: "Scenario Heading", LineNo: 3},
		{Kind: gauge.StepKind, Value: "my step"},
	}

	spec, result, err := new(SpecParser).CreateSpecification(tokens, gauge.NewConceptDictionary(), "")
	c.Assert(err, IsNil)
	c.Assert(result.Ok, Equals, true)

	c.Assert(len(spec.Tags.Values()), Equals, 2)
	c.Assert(spec.Tags.Values()[0], Equals, "tag1")
	c.Assert(spec.Tags.Values()[1], Equals, "tag2")
}

func (s *MySuite) TestToCheckTagsInScenarioLevel(c *C) {
	tokens := []*Token{
		{Kind: gauge.SpecKind, Value: "Spec Heading", LineNo: 1},
		{Kind: gauge.ScenarioKind, Value: "Scenario Heading", LineNo: 2},
		{Kind: gauge.TagKind, Args: []string{"tag1", "tag2"}, LineNo: 3},
		{Kind: gauge.StepKind, Value: "my step"},
	}

	spec, result, err := new(SpecParser).CreateSpecification(tokens, gauge.NewConceptDictionary(), "")
	c.Assert(err, IsNil)
	c.Assert(result.Ok, Equals, true)

	c.Assert(len(spec.Scenarios[0].Tags.Values()), Equals, 2)
	c.Assert(spec.Scenarios[0].Tags.Values()[0], Equals, "tag1")
	c.Assert(spec.Scenarios[0].Tags.Values()[1], Equals, "tag2")
}

func (s *MySuite) TestParsingConceptInSpec(c *C) {
	parser := new(SpecParser)
	specText := newSpecBuilder().specHeading("A spec heading").
		scenarioHeading("First flow").
		step("test concept step 1").
		step("another step").String()
	conceptDictionary := gauge.NewConceptDictionary()
	path, _ := filepath.Abs(filepath.Join("testdata", "concept.cpt"))
	_, _, err := AddConcepts([]string{path}, conceptDictionary)
	c.Assert(err, IsNil)
	tokens, errs := parser.GenerateTokens(specText, "")
	c.Assert(errs, IsNil)
	spec, parseResult, e := parser.CreateSpecification(tokens, conceptDictionary, "")
	c.Assert(e, IsNil)
	c.Assert(parseResult.Ok, Equals, true)
	firstStepInSpec := spec.Scenarios[0].Steps[0]
	secondStepInSpec := spec.Scenarios[0].Steps[1]
	c.Assert(firstStepInSpec.ConceptSteps[0].Parent, Equals, firstStepInSpec)
	c.Assert(firstStepInSpec.Parent, IsNil)
	c.Assert(secondStepInSpec.Parent, IsNil)
}

func (s *MySuite) TestTableInputFromInvalidFileAndDataTableNotInitialized(c *C) {
	parser := new(SpecParser)
	specText := newSpecBuilder().specHeading("Spec heading").text("table: inputinvalid.csv").text("comment").scenarioHeading("Sce heading").step("my step").String()

	_, parseRes, err := parser.Parse(specText, gauge.NewConceptDictionary(), "")
	c.Assert(err, IsNil)
	c.Assert(parseRes.ParseErrors[0].Message, Equals, "Could not resolve table. File inputinvalid.csv doesn't exist.")
	c.Assert(parseRes.Ok, Equals, false)
}

func (s *MySuite) TestTableInputFromFile(c *C) {
	parser := new(SpecParser)
	specText := newSpecBuilder().specHeading("Spec heading").text("Table: inputinvalid.csv").text("comment").scenarioHeading("Sce heading").step("my step").String()

	_, parseRes, err := parser.Parse(specText, gauge.NewConceptDictionary(), "")
	c.Assert(err, IsNil)
	c.Assert(parseRes.ParseErrors[0].Message, Equals, "Could not resolve table. File inputinvalid.csv doesn't exist.")
	c.Assert(parseRes.Ok, Equals, false)
}

func (s *MySuite) TestTableInputFromFileIfPathNotSpecified(c *C) {
	parser := new(SpecParser)
	specText := newSpecBuilder().specHeading("Spec heading").text("Table: ").scenarioHeading("Sce heading").step("my step").String()

	_, parseRes, err := parser.Parse(specText, gauge.NewConceptDictionary(), "")
	c.Assert(err, IsNil)
	c.Assert(parseRes.ParseErrors[0].Message, Equals, "Table location not specified")
	c.Assert(parseRes.Ok, Equals, false)
}

func (s *MySuite) TestToSplitTagNames(c *C) {
	allTags := splitAndTrimTags("tag1 , tag2,   tag3")
	c.Assert(allTags[0], Equals, "tag1")
	c.Assert(allTags[1], Equals, "tag2")
	c.Assert(allTags[2], Equals, "tag3")
}

func (s *MySuite) TestThrowsErrorForMultipleSpecHeading(c *C) {
	tokens := []*Token{
		{Kind: gauge.SpecKind, Value: "Spec Heading", LineNo: 1},
		{Kind: gauge.ScenarioKind, Value: "Scenario Heading", LineNo: 2},
		{Kind: gauge.StepKind, Value: "Example step", LineNo: 3},
		{Kind: gauge.SpecKind, Value: "Another Heading", LineNo: 4},
	}

	_, result, err := new(SpecParser).CreateSpecification(tokens, gauge.NewConceptDictionary(), "")
	c.Assert(err, IsNil)
	c.Assert(result.Ok, Equals, false)

	c.Assert(result.ParseErrors[0].Message, Equals, "Multiple spec headings found in same file")
	c.Assert(result.ParseErrors[0].LineNo, Equals, 4)
}

func (s *MySuite) TestThrowsErrorForScenarioWithoutSpecHeading(c *C) {
	tokens := []*Token{
		{Kind: gauge.ScenarioKind, Value: "Scenario Heading", LineNo: 1},
		{Kind: gauge.StepKind, Value: "Example step", LineNo: 2},
		{Kind: gauge.CommentKind, Value: "Comment", LineNo: 3},
	}

	_, result, err := new(SpecParser).CreateSpecification(tokens, gauge.NewConceptDictionary(), "")
	c.Assert(err, IsNil)
	c.Assert(result.Ok, Equals, false)
	c.Assert(len(result.ParseErrors), Equals, 2)

	c.Assert(result.ParseErrors[0].Message, Equals, "Spec heading not found")
	c.Assert(result.ParseErrors[0].LineNo, Equals, 1)
	c.Assert(result.ParseErrors[1].Message, Equals, "Scenario should be defined after the spec heading")
	c.Assert(result.ParseErrors[1].LineNo, Equals, 1)

}

func (s *MySuite) TestThrowsErrorForDuplicateScenariosWithinTheSameSpec(c *C) {
	tokens := []*Token{
		{Kind: gauge.SpecKind, Value: "Spec Heading", LineNo: 1},
		{Kind: gauge.ScenarioKind, Value: "Scenario Heading", LineNo: 2},
		{Kind: gauge.StepKind, Value: "Example step", LineNo: 3},
		{Kind: gauge.ScenarioKind, Value: "Scenario Heading", LineNo: 4},
	}

	_, result, err := new(SpecParser).CreateSpecification(tokens, gauge.NewConceptDictionary(), "")
	c.Assert(err, IsNil)
	c.Assert(result.Ok, Equals, false)

	c.Assert(result.ParseErrors[0].Message, Equals, "Duplicate scenario definition 'Scenario Heading' found in the same specification")
	c.Assert(result.ParseErrors[0].LineNo, Equals, 4)
}

func (s *MySuite) TestSpecWithHeadingAndSimpleSteps(c *C) {
	tokens := []*Token{
		{Kind: gauge.SpecKind, Value: "Spec Heading", LineNo: 1},
		{Kind: gauge.ScenarioKind, Value: "Scenario Heading", LineNo: 2},
		{Kind: gauge.StepKind, Value: "Example step", LineNo: 3},
	}

	spec, result, err := new(SpecParser).CreateSpecification(tokens, gauge.NewConceptDictionary(), "")
	c.Assert(err, IsNil)
	c.Assert(len(spec.Items), Equals, 1)
	c.Assert(spec.Items[0], Equals, spec.Scenarios[0])
	scenarioItems := (spec.Items[0]).(*gauge.Scenario).Items
	c.Assert(scenarioItems[0], Equals, spec.Scenarios[0].Steps[0])

	c.Assert(result.Ok, Equals, true)
	c.Assert(spec.Heading.LineNo, Equals, 1)
	c.Assert(spec.Heading.Value, Equals, "Spec Heading")

	c.Assert(len(spec.Scenarios), Equals, 1)
	c.Assert(spec.Scenarios[0].Heading.LineNo, Equals, 2)
	c.Assert(spec.Scenarios[0].Heading.Value, Equals, "Scenario Heading")
	c.Assert(len(spec.Scenarios[0].Steps), Equals, 1)
	c.Assert(spec.Scenarios[0].Steps[0].Value, Equals, "Example step")
}

func (s *MySuite) TestStepsAndComments(c *C) {
	tokens := []*Token{
		{Kind: gauge.SpecKind, Value: "Spec Heading", LineNo: 1},
		{Kind: gauge.CommentKind, Value: "A comment with some text and **bold** characters", LineNo: 2},
		{Kind: gauge.ScenarioKind, Value: "Scenario Heading", LineNo: 3},
		{Kind: gauge.CommentKind, Value: "Another comment", LineNo: 4},
		{Kind: gauge.StepKind, Value: "Example step", LineNo: 5},
		{Kind: gauge.CommentKind, Value: "Third comment", LineNo: 6},
	}

	spec, result, err := new(SpecParser).CreateSpecification(tokens, gauge.NewConceptDictionary(), "")
	c.Assert(err, IsNil)
	c.Assert(len(spec.Items), Equals, 2)
	c.Assert(spec.Items[0], Equals, spec.Comments[0])
	c.Assert(spec.Items[1], Equals, spec.Scenarios[0])

	scenarioItems := (spec.Items[1]).(*gauge.Scenario).Items
	c.Assert(3, Equals, len(scenarioItems))
	c.Assert(scenarioItems[0], Equals, spec.Scenarios[0].Comments[0])
	c.Assert(scenarioItems[1], Equals, spec.Scenarios[0].Steps[0])
	c.Assert(scenarioItems[2], Equals, spec.Scenarios[0].Comments[1])

	c.Assert(result.Ok, Equals, true)
	c.Assert(spec.Heading.Value, Equals, "Spec Heading")

	c.Assert(len(spec.Comments), Equals, 1)
	c.Assert(spec.Comments[0].LineNo, Equals, 2)
	c.Assert(spec.Comments[0].Value, Equals, "A comment with some text and **bold** characters")

	c.Assert(len(spec.Scenarios), Equals, 1)
	scenario := spec.Scenarios[0]

	c.Assert(2, Equals, len(scenario.Comments))
	c.Assert(scenario.Comments[0].LineNo, Equals, 4)
	c.Assert(scenario.Comments[0].Value, Equals, "Another comment")

	c.Assert(scenario.Comments[1].LineNo, Equals, 6)
	c.Assert(scenario.Comments[1].Value, Equals, "Third comment")

	c.Assert(scenario.Heading.Value, Equals, "Scenario Heading")
	c.Assert(len(scenario.Steps), Equals, 1)
}

func (s *MySuite) TestTableFromInvalidFile(c *C) {
	parser := new(SpecParser)
	specText := newSpecBuilder().specHeading("Spec heading").text("table: inputinvalid.csv").text("comment").scenarioHeading("Sce heading").step("my step").String()

	tokens, _ := parser.GenerateTokens(specText, "")
	_, res, err := parser.CreateSpecification(tokens, gauge.NewConceptDictionary(), "")
	c.Assert(err, IsNil)
	c.Assert(len(res.ParseErrors) > 0, Equals, true)
	c.Assert(res.ParseErrors[0].Message, Equals, "Could not resolve table. File inputinvalid.csv doesn't exist.")
}

func (s *MySuite) TestStepsWithParam(c *C) {
	tokens := []*Token{
		{Kind: gauge.SpecKind, Value: "Spec Heading", LineNo: 1},
		{Kind: gauge.TableHeader, Args: []string{"id"}, LineNo: 2},
		{Kind: gauge.TableRow, Args: []string{"1"}, LineNo: 3},
		{Kind: gauge.ScenarioKind, Value: "Scenario Heading", LineNo: 4},
		{Kind: gauge.StepKind, Value: "enter {static} with {dynamic}", LineNo: 5, Args: []string{"user \\n foo", "id"}},
		{Kind: gauge.StepKind, Value: "sample \\{static\\}", LineNo: 6},
	}

	spec, result, err := new(SpecParser).CreateSpecification(tokens, gauge.NewConceptDictionary(), "")
	c.Assert(err, IsNil)
	c.Assert(result.Ok, Equals, true)
	step := spec.Scenarios[0].Steps[0]
	c.Assert(step.Value, Equals, "enter {} with {}")
	c.Assert(step.LineNo, Equals, 5)
	c.Assert(len(step.Args), Equals, 2)
	c.Assert(step.Args[0].Value, Equals, "user \\n foo")
	c.Assert(step.Args[0].ArgType, Equals, gauge.Static)
	c.Assert(step.Args[1].Value, Equals, "id")
	c.Assert(step.Args[1].ArgType, Equals, gauge.Dynamic)
	c.Assert(step.Args[1].Name, Equals, "id")

	escapedStep := spec.Scenarios[0].Steps[1]
	c.Assert(escapedStep.Value, Equals, "sample \\{static\\}")
	c.Assert(len(escapedStep.Args), Equals, 0)
}

func (s *MySuite) TestStepsWithKeywords(c *C) {
	tokens := []*Token{
		{Kind: gauge.SpecKind, Value: "Spec Heading", LineNo: 1},
		{Kind: gauge.ScenarioKind, Value: "Scenario Heading", LineNo: 2},
		{Kind: gauge.StepKind, Value: "sample {static} and {dynamic}", LineNo: 3, Args: []string{"name"}},
	}

	_, result, err := new(SpecParser).CreateSpecification(tokens, gauge.NewConceptDictionary(), "")
	c.Assert(err, IsNil)
	c.Assert(result, NotNil)
	c.Assert(result.Ok, Equals, false)
	c.Assert(result.ParseErrors[0].Message, Equals, "Scenario should have atleast one step")
	c.Assert(result.ParseErrors[0].LineNo, Equals, 2)
	c.Assert(result.ParseErrors[1].Message, Equals, "Step text should not have '{static}' or '{dynamic}' or '{special}'")
	c.Assert(result.ParseErrors[1].LineNo, Equals, 3)
}

func (s *MySuite) TestContextWithKeywords(c *C) {
	tokens := []*Token{
		{Kind: gauge.SpecKind, Value: "Spec Heading", LineNo: 1},
		{Kind: gauge.StepKind, Value: "sample {static} and {dynamic}", LineNo: 3, Args: []string{"name"}},
		{Kind: gauge.ScenarioKind, Value: "Scenario Heading", LineNo: 2},
		{Kind: gauge.StepKind, Value: "Step"},
	}

	_, result, err := new(SpecParser).CreateSpecification(tokens, gauge.NewConceptDictionary(), "")
	c.Assert(err, IsNil)
	c.Assert(result, NotNil)
	c.Assert(result.Ok, Equals, false)
	c.Assert(result.ParseErrors[0].Message, Equals, "Step text should not have '{static}' or '{dynamic}' or '{special}'")
	c.Assert(result.ParseErrors[0].LineNo, Equals, 3)
}

func (s *MySuite) TestSpecWithDataTable(c *C) {
	tokens := []*Token{
		{Kind: gauge.SpecKind, Value: "Spec Heading"},
		{Kind: gauge.CommentKind, Value: "Comment before data table"},
		{Kind: gauge.TableHeader, Args: []string{"id", "name"}},
		{Kind: gauge.TableRow, Args: []string{"1", "foo"}},
		{Kind: gauge.TableRow, Args: []string{"2", "bar"}},
		{Kind: gauge.CommentKind, Value: "Comment before data table"},
		{Kind: gauge.ScenarioKind, Value: "Scenario heading"},
		{Kind: gauge.StepKind, Value: "my step"},
	}

	spec, result, err := new(SpecParser).CreateSpecification(tokens, gauge.NewConceptDictionary(), "")
	c.Assert(err, IsNil)
	c.Assert(len(spec.Items), Equals, 4)
	c.Assert(spec.Items[0], Equals, spec.Comments[0])
	c.Assert(spec.Items[1], DeepEquals, &spec.DataTable)
	c.Assert(spec.Items[2], Equals, spec.Comments[1])

	c.Assert(result.Ok, Equals, true)
	c.Assert(spec.DataTable, NotNil)
	idCells, _ := spec.DataTable.Table.Get("id")
	nameCells, _ := spec.DataTable.Table.Get("name")
	c.Assert(len(idCells), Equals, 2)
	c.Assert(len(nameCells), Equals, 2)
	c.Assert(idCells[0].Value, Equals, "1")
	c.Assert(idCells[0].CellType, Equals, gauge.Static)
	c.Assert(idCells[1].Value, Equals, "2")
	c.Assert(idCells[1].CellType, Equals, gauge.Static)
	c.Assert(nameCells[0].Value, Equals, "foo")
	c.Assert(nameCells[0].CellType, Equals, gauge.Static)
	c.Assert(nameCells[1].Value, Equals, "bar")
	c.Assert(nameCells[1].CellType, Equals, gauge.Static)
}

func TestScenarioWithDataTable(t *testing.T) {
	var subject = func() *gauge.Scenario {
		tokens := []*Token{
			{Kind: gauge.SpecKind, Value: "Spec Heading"},
			{Kind: gauge.CommentKind, Value: "Comment before data table"},
			{Kind: gauge.ScenarioKind, Value: "Scenario heading"},
			{Kind: gauge.CommentKind, Value: "Comment before data table"},
			{Kind: gauge.TableHeader, Args: []string{"id", "name"}},
			{Kind: gauge.TableRow, Args: []string{"1", "foo"}},
			{Kind: gauge.TableRow, Args: []string{"2", "bar"}},
			{Kind: gauge.StepKind, Value: "my step"},
		}
		spec, result, err := new(SpecParser).CreateSpecification(tokens, gauge.NewConceptDictionary(), "")
		if err != nil {
			t.Error(err)
		}
		v := len(spec.Items)
		if v != 2 {
			t.Errorf("expected spec to have 2 items. got %d", v)
		}
		if !result.Ok {
			t.Errorf("parse failed, err %s", strings.Join(result.Errors(), ","))
		}

		return spec.Scenarios[0]
	}

	t.Run("Scenario with datatable when AllowScenarioDatatable=True", func(t *testing.T) {
		env.AllowScenarioDatatable = func() bool { return true }
		s := subject()
		if s.DataTable.Table == nil {
			t.Error("expected scenario datatable to be not nil")
		}
		v := len(s.Items)
		if v != 3 {
			t.Errorf("expected scenario to have 3 items, got %d", v)
		}

		idCells, _ := s.DataTable.Table.Get("id")
		nameCells, _ := s.DataTable.Table.Get("name")

		var assertEqual = func(e, a interface{}) {
			if e != a {
				t.Errorf("expected %v got %v", e, a)
			}
		}
		assertEqual(len(idCells), 2)
		assertEqual(len(nameCells), 2)
		assertEqual(idCells[0].Value, "1")
		assertEqual(idCells[0].CellType, gauge.Static)
		assertEqual(idCells[1].Value, "2")
		assertEqual(idCells[1].CellType, gauge.Static)
		assertEqual(nameCells[0].Value, "foo")
		assertEqual(nameCells[0].CellType, gauge.Static)
		assertEqual(nameCells[1].Value, "bar")
		assertEqual(nameCells[1].CellType, gauge.Static)
	})
	t.Run("Parse Scenario with datatable when AllowScenarioDatatable=False", func(t *testing.T) {
		env.AllowScenarioDatatable = func() bool { return false }
		s := subject()
		if s.DataTable.Table.IsInitialized() {
			t.Error("expected scenario to have no datatable, got one")
		}
	})

}

func (s *MySuite) TestSpecWithDataTableHavingEmptyRowAndNoSeparator(c *C) {
	tokens := []*Token{
		{Kind: gauge.SpecKind, Value: "Spec Heading"},
		{Kind: gauge.CommentKind, Value: "Comment before data table"},
		{Kind: gauge.TableHeader, Args: []string{"id", "name"}},
		{Kind: gauge.TableRow, Args: []string{"1", "foo"}},
		{Kind: gauge.TableRow, Args: []string{"", ""}},
		{Kind: gauge.TableRow, Args: []string{"2", "bar"}},
		{Kind: gauge.CommentKind, Value: "Comment before data table"},
		{Kind: gauge.ScenarioKind, Value: "Scenario heading"},
		{Kind: gauge.StepKind, Value: "my step"},
	}

	spec, result, err := new(SpecParser).CreateSpecification(tokens, gauge.NewConceptDictionary(), "")
	c.Assert(err, IsNil)
	c.Assert(len(spec.Items), Equals, 4)
	c.Assert(spec.Items[0], Equals, spec.Comments[0])
	c.Assert(spec.Items[1], DeepEquals, &spec.DataTable)
	c.Assert(spec.Items[2], Equals, spec.Comments[1])

	c.Assert(result.Ok, Equals, true)
	c.Assert(spec.DataTable, NotNil)
	c.Assert(spec.DataTable.Table.GetRowCount(), Equals, 3)
	idCells, _ := spec.DataTable.Table.Get("id")
	nameCells, _ := spec.DataTable.Table.Get("name")
	c.Assert(len(idCells), Equals, 3)
	c.Assert(len(nameCells), Equals, 3)
	c.Assert(idCells[0].Value, Equals, "1")
	c.Assert(idCells[0].CellType, Equals, gauge.Static)
	c.Assert(idCells[1].Value, Equals, "")
	c.Assert(idCells[1].CellType, Equals, gauge.Static)
	c.Assert(idCells[2].Value, Equals, "2")
	c.Assert(idCells[2].CellType, Equals, gauge.Static)
	c.Assert(nameCells[0].Value, Equals, "foo")
	c.Assert(nameCells[0].CellType, Equals, gauge.Static)
	c.Assert(nameCells[1].Value, Equals, "")
	c.Assert(nameCells[1].CellType, Equals, gauge.Static)
	c.Assert(nameCells[2].Value, Equals, "bar")
	c.Assert(nameCells[2].CellType, Equals, gauge.Static)
}

func (s *MySuite) TestSpecWithStepUsingInlineTableWhichUsagesDynamicParamFromScenarioDataTable(c *C) {
	env.AllowScenarioDatatable = func() bool { return true }
	specText := `# Specification heading

## Scenario Heading

	|name   |
	|-------|
	|someone|

* step with
	|id    |
	|------|
	|<name>|
`
	_, _, err := new(SpecParser).Parse(specText, gauge.NewConceptDictionary(), "foo.spec")
	c.Assert(err, IsNil)
}

func (s *MySuite) TestStepWithInlineTable(c *C) {
	tokens := []*Token{
		{Kind: gauge.SpecKind, Value: "Spec Heading", LineNo: 1},
		{Kind: gauge.ScenarioKind, Value: "Scenario Heading", LineNo: 2},
		{Kind: gauge.StepKind, Value: "Step with inline table", LineNo: 3},
		{Kind: gauge.TableHeader, Args: []string{"id", "name"}},
		{Kind: gauge.TableRow, Args: []string{"1", "foo"}},
		{Kind: gauge.TableRow, Args: []string{"2", "bar"}},
	}

	spec, result, err := new(SpecParser).CreateSpecification(tokens, gauge.NewConceptDictionary(), "")
	c.Assert(err, IsNil)
	c.Assert(result.Ok, Equals, true)
	step := spec.Scenarios[0].Steps[0]

	c.Assert(step.Args[0].ArgType, Equals, gauge.TableArg)
	inlineTable := step.Args[0].Table
	c.Assert(inlineTable, NotNil)

	c.Assert(step.Value, Equals, "Step with inline table {}")
	c.Assert(step.HasInlineTable, Equals, true)
	idCells, _ := inlineTable.Get("id")
	nameCells, _ := inlineTable.Get("name")
	c.Assert(len(idCells), Equals, 2)
	c.Assert(len(nameCells), Equals, 2)
	c.Assert(idCells[0].Value, Equals, "1")
	c.Assert(idCells[0].CellType, Equals, gauge.Static)
	c.Assert(idCells[1].Value, Equals, "2")
	c.Assert(idCells[1].CellType, Equals, gauge.Static)
	c.Assert(nameCells[0].Value, Equals, "foo")
	c.Assert(nameCells[0].CellType, Equals, gauge.Static)
	c.Assert(nameCells[1].Value, Equals, "bar")
	c.Assert(nameCells[1].CellType, Equals, gauge.Static)
}

func (s *MySuite) TestStepWithInlineTableWithDynamicParam(c *C) {
	tokens := []*Token{
		{Kind: gauge.SpecKind, Value: "Spec Heading", LineNo: 1},
		{Kind: gauge.TableHeader, Args: []string{"type1", "type2"}},
		{Kind: gauge.TableRow, Args: []string{"1", "2"}},
		{Kind: gauge.ScenarioKind, Value: "Scenario Heading", LineNo: 2},
		{Kind: gauge.StepKind, Value: "Step with inline table", LineNo: 3},
		{Kind: gauge.TableHeader, Args: []string{"id", "name"}},
		{Kind: gauge.TableRow, Args: []string{"1", "<type1>"}},
		{Kind: gauge.TableRow, Args: []string{"2", "<type2>"}},
		{Kind: gauge.TableRow, Args: []string{"<2>", "<type3>"}},
	}

	spec, result, err := new(SpecParser).CreateSpecification(tokens, gauge.NewConceptDictionary(), "")
	c.Assert(err, IsNil)

	c.Assert(result.Ok, Equals, true)
	step := spec.Scenarios[0].Steps[0]

	c.Assert(step.Args[0].ArgType, Equals, gauge.TableArg)
	inlineTable := step.Args[0].Table
	c.Assert(inlineTable, NotNil)

	c.Assert(step.Value, Equals, "Step with inline table {}")
	idCells, _ := inlineTable.Get("id")
	nameCells, _ := inlineTable.Get("name")
	c.Assert(len(idCells), Equals, 3)
	c.Assert(len(nameCells), Equals, 3)
	c.Assert(idCells[0].Value, Equals, "1")
	c.Assert(idCells[0].CellType, Equals, gauge.Static)
	c.Assert(idCells[1].Value, Equals, "2")
	c.Assert(idCells[1].CellType, Equals, gauge.Static)
	c.Assert(idCells[2].Value, Equals, "<2>")
	c.Assert(idCells[2].CellType, Equals, gauge.Static)

	c.Assert(nameCells[0].Value, Equals, "type1")
	c.Assert(nameCells[0].CellType, Equals, gauge.Dynamic)
	c.Assert(nameCells[1].Value, Equals, "type2")
	c.Assert(nameCells[1].CellType, Equals, gauge.Dynamic)
	c.Assert(nameCells[2].Value, Equals, "<type3>")
	c.Assert(nameCells[2].CellType, Equals, gauge.Static)
}

func (s *MySuite) TestStepWithInlineTableWithUnResolvableDynamicParam(c *C) {
	tokens := []*Token{
		{Kind: gauge.SpecKind, Value: "Spec Heading", LineNo: 1},
		{Kind: gauge.TableHeader, Args: []string{"type1", "type2"}},
		{Kind: gauge.TableRow, Args: []string{"1", "2"}},
		{Kind: gauge.ScenarioKind, Value: "Scenario Heading", LineNo: 2},
		{Kind: gauge.StepKind, Value: "Step with inline table", LineNo: 3},
		{Kind: gauge.TableHeader, Args: []string{"id", "name"}},
		{Kind: gauge.TableRow, Args: []string{"1", "<invalid>"}},
		{Kind: gauge.TableRow, Args: []string{"2", "<type2>"}},
	}

	spec, result, err := new(SpecParser).CreateSpecification(tokens, gauge.NewConceptDictionary(), "")
	c.Assert(err, IsNil)
	c.Assert(result.Ok, Equals, true)
	idCells, _ := spec.Scenarios[0].Steps[0].Args[0].Table.Get("id")
	c.Assert(idCells[0].Value, Equals, "1")
	nameCells, _ := spec.Scenarios[0].Steps[0].Args[0].Table.Get("name")
	c.Assert(nameCells[0].Value, Equals, "<invalid>")
	c.Assert(result.Warnings[0].Message, Equals, "Dynamic param <invalid> could not be resolved, Treating it as static param")
}

func (s *MySuite) TestContextWithInlineTable(c *C) {
	tokens := []*Token{
		{Kind: gauge.SpecKind, Value: "Spec Heading"},
		{Kind: gauge.StepKind, Value: "Context with inline table"},
		{Kind: gauge.TableHeader, Args: []string{"id", "name"}},
		{Kind: gauge.TableRow, Args: []string{"1", "foo"}},
		{Kind: gauge.TableRow, Args: []string{"2", "bar"}},
		{Kind: gauge.TableRow, Args: []string{"3", "not a <dynamic>"}},
		{Kind: gauge.ScenarioKind, Value: "Scenario Heading"},
		{Kind: gauge.StepKind, Value: "Step"},
	}

	spec, result, err := new(SpecParser).CreateSpecification(tokens, gauge.NewConceptDictionary(), "")
	c.Assert(err, IsNil)
	c.Assert(len(spec.Items), Equals, 2)
	c.Assert(spec.Items[0], DeepEquals, spec.Contexts[0])
	c.Assert(spec.Items[1], Equals, spec.Scenarios[0])

	c.Assert(result.Ok, Equals, true)
	context := spec.Contexts[0]

	c.Assert(context.Args[0].ArgType, Equals, gauge.TableArg)
	inlineTable := context.Args[0].Table

	c.Assert(inlineTable, NotNil)
	c.Assert(context.Value, Equals, "Context with inline table {}")
	idCells, _ := inlineTable.Get("id")
	nameCells, _ := inlineTable.Get("name")
	c.Assert(len(idCells), Equals, 3)
	c.Assert(len(nameCells), Equals, 3)
	c.Assert(idCells[0].Value, Equals, "1")
	c.Assert(idCells[0].CellType, Equals, gauge.Static)
	c.Assert(idCells[1].Value, Equals, "2")
	c.Assert(idCells[1].CellType, Equals, gauge.Static)
	c.Assert(idCells[2].Value, Equals, "3")
	c.Assert(idCells[2].CellType, Equals, gauge.Static)
	c.Assert(nameCells[0].Value, Equals, "foo")
	c.Assert(nameCells[0].CellType, Equals, gauge.Static)
	c.Assert(nameCells[1].Value, Equals, "bar")
	c.Assert(nameCells[1].CellType, Equals, gauge.Static)
	c.Assert(nameCells[2].Value, Equals, "not a <dynamic>")
	c.Assert(nameCells[2].CellType, Equals, gauge.Static)
}

func (s *MySuite) TestErrorWhenDataTableHasOnlyHeader(c *C) {
	tokens := []*Token{
		{Kind: gauge.SpecKind, Value: "Spec Heading"},
		{Kind: gauge.TableHeader, Args: []string{"id", "name"}, LineNo: 3},
		{Kind: gauge.ScenarioKind, Value: "Scenario Heading"},
	}

	_, result, err := new(SpecParser).CreateSpecification(tokens, gauge.NewConceptDictionary(), "")
	c.Assert(err, IsNil)
	c.Assert(result.Ok, Equals, false)
	c.Assert(result.ParseErrors[0].Message, Equals, "Data table should have at least 1 data row")
	c.Assert(result.ParseErrors[0].LineNo, Equals, 3)
}

func (s *MySuite) TestWarningWhenParsingMultipleDataTable(c *C) {
	tokens := []*Token{
		{Kind: gauge.SpecKind, Value: "Spec Heading"},
		{Kind: gauge.CommentKind, Value: "Comment before data table"},
		{Kind: gauge.TableHeader, Args: []string{"id", "name"}},
		{Kind: gauge.TableRow, Args: []string{"1", "foo"}},
		{Kind: gauge.TableRow, Args: []string{"2", "bar"}},
		{Kind: gauge.CommentKind, Value: "Comment before data table"},
		{Kind: gauge.TableHeader, Args: []string{"phone"}, LineNo: 7},
		{Kind: gauge.TableRow, Args: []string{"1"}},
		{Kind: gauge.TableRow, Args: []string{"2"}},
		{Kind: gauge.ScenarioKind, Value: "Scenario heading"},
		{Kind: gauge.StepKind, Value: "my step"},
	}

	_, result, err := new(SpecParser).CreateSpecification(tokens, gauge.NewConceptDictionary(), "foo.spec")
	c.Assert(err, IsNil)
	c.Assert(result.Ok, Equals, true)
	c.Assert(len(result.Warnings), Equals, 1)
	c.Assert(result.Warnings[0].String(), Equals, "foo.spec:7 Multiple data table present, ignoring table")

}

func (s *MySuite) TestParseErrorWhenCouldNotResolveExternalDataTable(c *C) {
	tokens := []*Token{
		{Kind: gauge.SpecKind, Value: "Spec Heading", LineNo: 1},
		{Kind: gauge.CommentKind, Value: "Comment before data table", LineNo: 2},
		{Kind: gauge.DataTableKind, Value: "table: foo", LineNo: 3, Lines: []string{"table: foo"}},
		{Kind: gauge.ScenarioKind, Value: "Scenario Heading", LineNo: 4},
		{Kind: gauge.StepKind, Value: "Step", LineNo: 5},
	}

	_, result, err := new(SpecParser).CreateSpecification(tokens, gauge.NewConceptDictionary(), "foo.spec")
	c.Assert(err, IsNil)
	c.Assert(result.Ok, Equals, false)
	c.Assert(len(result.Warnings), Equals, 0)
	c.Assert(result.Errors()[0], Equals, "[ParseError] foo.spec:3 Could not resolve table. File foo doesn't exist. => 'table: foo'")

}

func (s *MySuite) TestAddSpecTags(c *C) {
	tokens := []*Token{
		{Kind: gauge.SpecKind, Value: "Spec Heading", LineNo: 1},
		{Kind: gauge.TagKind, Args: []string{"tag1", "tag2"}, LineNo: 2},
		{Kind: gauge.ScenarioKind, Value: "Scenario Heading", LineNo: 3},
		{Kind: gauge.StepKind, Value: "Step"},
	}

	spec, result, err := new(SpecParser).CreateSpecification(tokens, gauge.NewConceptDictionary(), "")
	c.Assert(err, IsNil)
	c.Assert(result.Ok, Equals, true)
	c.Assert(len(spec.Tags.Values()), Equals, 2)
	c.Assert(spec.Tags.Values()[0], Equals, "tag1")
	c.Assert(spec.Tags.Values()[1], Equals, "tag2")
}

func (s *MySuite) TestAddSpecTagsAndScenarioTags(c *C) {
	tokens := []*Token{
		{Kind: gauge.SpecKind, Value: "Spec Heading", LineNo: 1},
		{Kind: gauge.TagKind, Args: []string{"tag1", "tag2"}, LineNo: 2},
		{Kind: gauge.ScenarioKind, Value: "Scenario Heading", LineNo: 3},
		{Kind: gauge.TagKind, Args: []string{"tag3", "tag4"}, LineNo: 2},
		{Kind: gauge.StepKind, Value: "Step"},
	}

	spec, result, err := new(SpecParser).CreateSpecification(tokens, gauge.NewConceptDictionary(), "")
	c.Assert(err, IsNil)
	c.Assert(result.Ok, Equals, true)

	c.Assert(len(spec.Tags.Values()), Equals, 2)
	c.Assert(spec.Tags.Values()[0], Equals, "tag1")
	c.Assert(spec.Tags.Values()[1], Equals, "tag2")

	tags := spec.Scenarios[0].Tags
	c.Assert(len(tags.Values()), Equals, 2)
	c.Assert(tags.Values()[0], Equals, "tag3")
	c.Assert(tags.Values()[1], Equals, "tag4")
}

func (s *MySuite) TestErrorOnAddingDynamicParamterWithoutADataTable(c *C) {
	tokens := []*Token{
		{Kind: gauge.SpecKind, Value: "Spec Heading", LineNo: 1},
		{Kind: gauge.ScenarioKind, Value: "Scenario Heading", LineNo: 2},
		{Kind: gauge.StepKind, Value: "Step with a {dynamic}", Args: []string{"foo"}, LineNo: 3, Lines: []string{"*Step with a <foo>"}},
		{Kind: gauge.StepKind, Value: "Step"},
	}

	_, result, err := new(SpecParser).CreateSpecification(tokens, gauge.NewConceptDictionary(), "")
	c.Assert(err, IsNil)
	c.Assert(result.Ok, Equals, false)
	c.Assert(result.ParseErrors[0].Message, Equals, "Dynamic parameter <foo> could not be resolved")
	c.Assert(result.ParseErrors[0].LineNo, Equals, 3)
}

func (s *MySuite) TestErrorOnAddingDynamicParamterWithoutDataTableHeaderValue(c *C) {
	tokens := []*Token{
		{Kind: gauge.SpecKind, Value: "Spec Heading", LineNo: 1},
		{Kind: gauge.TableHeader, Args: []string{"id, name"}, LineNo: 2},
		{Kind: gauge.TableRow, Args: []string{"123, hello"}, LineNo: 3},
		{Kind: gauge.ScenarioKind, Value: "Scenario Heading", LineNo: 4},
		{Kind: gauge.StepKind, Value: "Step with a {dynamic}", Args: []string{"foo"}, LineNo: 5, Lines: []string{"*Step with a <foo>"}},
		{Kind: gauge.StepKind, Value: "Step"},
	}

	_, result, err := new(SpecParser).CreateSpecification(tokens, gauge.NewConceptDictionary(), "")
	c.Assert(err, IsNil)
	c.Assert(result.Ok, Equals, false)
	c.Assert(result.ParseErrors[0].Message, Equals, "Dynamic parameter <foo> could not be resolved")
	c.Assert(result.ParseErrors[0].LineNo, Equals, 5)
}

func (s *MySuite) TestResolveScenarioDataTableAsDynamicParams(c *C) {
	env.AllowScenarioDatatable = func() bool { return true }
	tokens := []*Token{
		{Kind: gauge.SpecKind, Value: "Spec Heading", LineNo: 1},
		{Kind: gauge.ScenarioKind, Value: "Scenario Heading", LineNo: 4},
		{Kind: gauge.TableHeader, Args: []string{"id", "name"}, LineNo: 2},
		{Kind: gauge.TableRow, Args: []string{"123", "hello"}, LineNo: 3},
		{Kind: gauge.StepKind, Value: "Step with a {dynamic}", Args: []string{"id"}, LineNo: 5, Lines: []string{"*Step with a <id>"}},
		{Kind: gauge.StepKind, Value: "Step"},
	}

	_, result, err := new(SpecParser).CreateSpecification(tokens, gauge.NewConceptDictionary(), "")
	c.Assert(err, IsNil)
	c.Assert(result.Ok, Equals, true)
}

func (s *MySuite) TestCreateStepFromSimpleConcept(c *C) {
	tokens := []*Token{
		{Kind: gauge.SpecKind, Value: "Spec Heading", LineNo: 1},
		{Kind: gauge.ScenarioKind, Value: "Scenario Heading", LineNo: 2},
		{Kind: gauge.StepKind, Value: "test concept step 1", LineNo: 3},
	}

	conceptDictionary := gauge.NewConceptDictionary()
	path, _ := filepath.Abs(filepath.Join("testdata", "concept.cpt"))
	_, _, err := AddConcepts([]string{path}, conceptDictionary)
	c.Assert(err, IsNil)
	spec, result, err := new(SpecParser).CreateSpecification(tokens, conceptDictionary, "")
	c.Assert(err, IsNil)
	c.Assert(result.Ok, Equals, true)

	c.Assert(len(spec.Scenarios[0].Steps), Equals, 1)
	specConceptStep := spec.Scenarios[0].Steps[0]
	c.Assert(specConceptStep.IsConcept, Equals, true)
	assertStepEqual(c, &gauge.Step{LineNo: 2, Value: "step 1", LineText: "step 1"}, specConceptStep.ConceptSteps[0])
}

func (s *MySuite) TestCreateStepFromConceptWithParameters(c *C) {
	tokens := []*Token{
		{Kind: gauge.SpecKind, Value: "Spec Heading", LineNo: 1},
		{Kind: gauge.ScenarioKind, Value: "Scenario Heading", LineNo: 2},
		{Kind: gauge.StepKind, Value: "assign id {static} and name {static}", Args: []string{"foo", "foo1"}, LineNo: 3},
		{Kind: gauge.StepKind, Value: "assign id {static} and name {static}", Args: []string{"bar", "bar1"}, LineNo: 4},
	}

	conceptDictionary := gauge.NewConceptDictionary()
	path, _ := filepath.Abs(filepath.Join("testdata", "dynamic_param_concept.cpt"))
	_, _, err := AddConcepts([]string{path}, conceptDictionary)
	c.Assert(err, IsNil)

	spec, result, err := new(SpecParser).CreateSpecification(tokens, conceptDictionary, "")
	c.Assert(err, IsNil)
	c.Assert(result.Ok, Equals, true)

	c.Assert(len(spec.Scenarios[0].Steps), Equals, 2)

	firstConceptStep := spec.Scenarios[0].Steps[0]
	c.Assert(firstConceptStep.IsConcept, Equals, true)
	c.Assert(firstConceptStep.ConceptSteps[0].Value, Equals, "add id {}")
	c.Assert(firstConceptStep.ConceptSteps[0].Args[0].Value, Equals, "userid")
	c.Assert(firstConceptStep.ConceptSteps[1].Value, Equals, "add name {}")
	c.Assert(firstConceptStep.ConceptSteps[1].Args[0].Value, Equals, "username")
	usernameArg, _ := firstConceptStep.GetArg("username")
	c.Assert(usernameArg.Value, Equals, "foo1")
	useridArg, _ := firstConceptStep.GetArg("userid")
	c.Assert(useridArg.Value, Equals, "foo")

	secondConceptStep := spec.Scenarios[0].Steps[1]
	c.Assert(secondConceptStep.IsConcept, Equals, true)
	c.Assert(secondConceptStep.ConceptSteps[0].Value, Equals, "add id {}")
	c.Assert(secondConceptStep.ConceptSteps[0].Args[0].Value, Equals, "userid")
	c.Assert(secondConceptStep.ConceptSteps[1].Value, Equals, "add name {}")
	c.Assert(secondConceptStep.ConceptSteps[1].Args[0].Value, Equals, "username")
	usernameArg2, _ := secondConceptStep.GetArg("username")
	c.Assert(usernameArg2.Value, Equals, "bar1")
	useridArg2, _ := secondConceptStep.GetArg("userid")
	c.Assert(useridArg2.Value, Equals, "bar")

}

func (s *MySuite) TestCreateStepFromConceptWithDynamicParameters(c *C) {
	tokens := []*Token{
		{Kind: gauge.SpecKind, Value: "Spec Heading", LineNo: 1},
		{Kind: gauge.TableHeader, Args: []string{"id", "description"}, LineNo: 2},
		{Kind: gauge.TableRow, Args: []string{"123", "Admin fellow"}, LineNo: 3},
		{Kind: gauge.ScenarioKind, Value: "Scenario Heading", LineNo: 4},
		{Kind: gauge.StepKind, Value: "assign id {dynamic} and name {dynamic}", Args: []string{"id", "description"}, LineNo: 5},
	}

	conceptDictionary := gauge.NewConceptDictionary()
	path, _ := filepath.Abs(filepath.Join("testdata", "dynamic_param_concept.cpt"))
	_, _, err := AddConcepts([]string{path}, conceptDictionary)
	c.Assert(err, IsNil)
	spec, result, err := new(SpecParser).CreateSpecification(tokens, conceptDictionary, "")
	c.Assert(err, IsNil)
	c.Assert(result.Ok, Equals, true)

	c.Assert(len(spec.Items), Equals, 2)
	c.Assert(spec.Items[0], DeepEquals, &spec.DataTable)
	c.Assert(spec.Items[1], Equals, spec.Scenarios[0])

	scenarioItems := (spec.Items[1]).(*gauge.Scenario).Items
	c.Assert(scenarioItems[0], Equals, spec.Scenarios[0].Steps[0])

	c.Assert(len(spec.Scenarios[0].Steps), Equals, 1)

	firstConcept := spec.Scenarios[0].Steps[0]
	c.Assert(firstConcept.IsConcept, Equals, true)
	c.Assert(firstConcept.ConceptSteps[0].Value, Equals, "add id {}")
	c.Assert(firstConcept.ConceptSteps[0].Args[0].ArgType, Equals, gauge.Dynamic)
	c.Assert(firstConcept.ConceptSteps[0].Args[0].Value, Equals, "userid")
	c.Assert(firstConcept.ConceptSteps[1].Value, Equals, "add name {}")
	c.Assert(firstConcept.ConceptSteps[1].Args[0].Value, Equals, "username")
	c.Assert(firstConcept.ConceptSteps[1].Args[0].ArgType, Equals, gauge.Dynamic)

	arg1, _ := firstConcept.Lookup.GetArg("userid")
	c.Assert(arg1.Value, Equals, "id")
	c.Assert(arg1.ArgType, Equals, gauge.Dynamic)

	arg2, _ := firstConcept.Lookup.GetArg("username")
	c.Assert(arg2.Value, Equals, "description")
	c.Assert(arg2.ArgType, Equals, gauge.Dynamic)
}

func (s *MySuite) TestCreateStepFromConceptWithInlineTable(c *C) {
	tokens := []*Token{
		{Kind: gauge.SpecKind, Value: "Spec Heading", LineNo: 1},
		{Kind: gauge.ScenarioKind, Value: "Scenario Heading", LineNo: 4},
		{Kind: gauge.StepKind, Value: "assign id {static} and name", Args: []string{"sdf"}, LineNo: 3},
		{Kind: gauge.TableHeader, Args: []string{"id", "description"}, LineNo: 4},
		{Kind: gauge.TableRow, Args: []string{"123", "Admin"}, LineNo: 5},
		{Kind: gauge.TableRow, Args: []string{"456", "normal fellow"}, LineNo: 6},
	}

	conceptDictionary := gauge.NewConceptDictionary()
	path, _ := filepath.Abs(filepath.Join("testdata", "dynamic_param_concept.cpt"))
	_, _, err := AddConcepts([]string{path}, conceptDictionary)
	c.Assert(err, IsNil)
	spec, result, err := new(SpecParser).CreateSpecification(tokens, conceptDictionary, "")
	c.Assert(err, IsNil)
	c.Assert(result.Ok, Equals, true)

	steps := spec.Scenarios[0].Steps
	c.Assert(len(steps), Equals, 1)
	c.Assert(steps[0].IsConcept, Equals, true)
	c.Assert(steps[0].Value, Equals, "assign id {} and name {}")
	c.Assert(len(steps[0].Args), Equals, 2)
	c.Assert(steps[0].Args[1].ArgType, Equals, gauge.TableArg)
	c.Assert(len(steps[0].ConceptSteps), Equals, 2)
}

func (s *MySuite) TestCreateStepFromConceptWithInlineTableHavingDynamicParam(c *C) {
	tokens := []*Token{
		{Kind: gauge.SpecKind, Value: "Spec Heading", LineNo: 1},
		{Kind: gauge.TableHeader, Args: []string{"id", "description"}, LineNo: 2},
		{Kind: gauge.TableRow, Args: []string{"123", "Admin"}, LineNo: 3},
		{Kind: gauge.TableRow, Args: []string{"456", "normal fellow"}, LineNo: 4},
		{Kind: gauge.ScenarioKind, Value: "Scenario Heading", LineNo: 5},
		{Kind: gauge.StepKind, Value: "assign id {static} and name", Args: []string{"sdf"}, LineNo: 6},
		{Kind: gauge.TableHeader, Args: []string{"user-id", "description", "name"}, LineNo: 7},
		{Kind: gauge.TableRow, Args: []string{"<id>", "<description>", "root"}, LineNo: 8},
	}

	conceptDictionary := gauge.NewConceptDictionary()
	path, _ := filepath.Abs(filepath.Join("testdata", "dynamic_param_concept.cpt"))
	_, _, err := AddConcepts([]string{path}, conceptDictionary)
	c.Assert(err, IsNil)
	spec, result, err := new(SpecParser).CreateSpecification(tokens, conceptDictionary, "")
	c.Assert(err, IsNil)
	c.Assert(result.Ok, Equals, true)

	steps := spec.Scenarios[0].Steps
	c.Assert(len(steps), Equals, 1)
	c.Assert(steps[0].IsConcept, Equals, true)
	c.Assert(steps[0].Value, Equals, "assign id {} and name {}")
	c.Assert(len(steps[0].Args), Equals, 2)
	c.Assert(steps[0].Args[1].ArgType, Equals, gauge.TableArg)
	table := steps[0].Args[1].Table
	userIDCells, _ := table.Get("user-id")
	descriptionCells, _ := table.Get("description")
	nameCells, _ := table.Get("name")
	c.Assert(userIDCells[0].Value, Equals, "id")
	c.Assert(userIDCells[0].CellType, Equals, gauge.Dynamic)
	c.Assert(descriptionCells[0].Value, Equals, "description")
	c.Assert(descriptionCells[0].CellType, Equals, gauge.Dynamic)
	c.Assert(nameCells[0].Value, Equals, "root")
	c.Assert(nameCells[0].CellType, Equals, gauge.Static)
	c.Assert(len(steps[0].ConceptSteps), Equals, 2)
}

func (s *MySuite) TestCreateInValidSpecialArgInStep(c *C) {
	tokens := []*Token{
		{Kind: gauge.SpecKind, Value: "Spec Heading", LineNo: 1},
		{Kind: gauge.TableHeader, Args: []string{"unknown:foo", "description"}, LineNo: 2},
		{Kind: gauge.TableRow, Args: []string{"123", "Admin"}, LineNo: 3},
		{Kind: gauge.ScenarioKind, Value: "Scenario Heading", LineNo: 2},
		{Kind: gauge.StepKind, Value: "Example {special} step", LineNo: 3, Args: []string{"unknown:foo"}},
	}
	spec, parseResults, err := new(SpecParser).CreateSpecification(tokens, gauge.NewConceptDictionary(), "")
	c.Assert(err, IsNil)
	c.Assert(spec.Scenarios[0].Steps[0].Args[0].ArgType, Equals, gauge.Dynamic)
	c.Assert(len(parseResults.Warnings), Equals, 1)
	c.Assert(parseResults.Warnings[0].Message, Equals, "Could not resolve special param type <unknown:foo>. Treating it as dynamic param.")
}

func (s *MySuite) TestTearDownSteps(c *C) {
	tokens := []*Token{
		{Kind: gauge.SpecKind, Value: "Spec Heading", LineNo: 1},
		{Kind: gauge.CommentKind, Value: "A comment with some text and **bold** characters", LineNo: 2},
		{Kind: gauge.ScenarioKind, Value: "Scenario Heading", LineNo: 3},
		{Kind: gauge.CommentKind, Value: "Another comment", LineNo: 4},
		{Kind: gauge.StepKind, Value: "Example step", LineNo: 5},
		{Kind: gauge.CommentKind, Value: "Third comment", LineNo: 6},
		{Kind: gauge.TearDownKind, Value: "____", LineNo: 7},
		{Kind: gauge.StepKind, Value: "Example step1", LineNo: 8},
		{Kind: gauge.CommentKind, Value: "Fourth comment", LineNo: 9},
		{Kind: gauge.StepKind, Value: "Example step2", LineNo: 10},
	}

	spec, _, err := new(SpecParser).CreateSpecification(tokens, gauge.NewConceptDictionary(), "")
	c.Assert(err, IsNil)
	c.Assert(len(spec.TearDownSteps), Equals, 2)
	c.Assert(spec.TearDownSteps[0].Value, Equals, "Example step1")
	c.Assert(spec.TearDownSteps[0].LineNo, Equals, 8)
	c.Assert(spec.TearDownSteps[1].Value, Equals, "Example step2")
	c.Assert(spec.TearDownSteps[1].LineNo, Equals, 10)
}

func (s *MySuite) TestParsingOfTableWithHyphens(c *C) {
	p := new(SpecParser)

	text := newSpecBuilder().specHeading("My Spec Heading").text("|id|").text("|--|").text("|1 |").text("|- |").String()
	tokens, _ := p.GenerateTokens(text, "")

	spec, _, err := p.CreateSpecification(tokens, gauge.NewConceptDictionary(), "")
	c.Assert(err, IsNil)
	idCells, _ := spec.DataTable.Table.Get("id")
	c.Assert((len(idCells)), Equals, 2)
	c.Assert(idCells[0].Value, Equals, "1")
	c.Assert(idCells[1].Value, Equals, "-")
}

func (s *MySuite) TestCreateStepWithNewlineBetweenTextAndTable(c *C) {
	tokens := []*Token{
		{Kind: gauge.SpecKind, Value: "Spec Heading", LineNo: 1},
		{Kind: gauge.ScenarioKind, Value: "Scenario Heading", LineNo: 2},
		{Kind: gauge.StepKind, Value: "some random step\n", LineNo: 3},
		{Kind: gauge.TableHeader, Args: []string{"id", "description"}, LineNo: 5},
		{Kind: gauge.TableRow, Args: []string{"123", "Admin"}, LineNo: 6},
		{Kind: gauge.TableRow, Args: []string{"456", "normal fellow"}, LineNo: 7},
	}

	conceptDictionary := gauge.NewConceptDictionary()
	spec, _, err := new(SpecParser).CreateSpecification(tokens, conceptDictionary, "")
	c.Assert(err, IsNil)
	c.Assert(spec.Scenarios[0].Steps[0].HasInlineTable, Equals, true)
}

func (s *MySuite) TestSpecParsingWhenSpecHeadingIsNotPresentAndDynamicParseError(c *C) {
	p := new(SpecParser)

	_, res, err := p.Parse(`#
Scenario Heading
----------------
* def <a>
`, gauge.NewConceptDictionary(), "foo.spec")
	c.Assert(err, IsNil)
	c.Assert(len(res.ParseErrors), Equals, 2)
	c.Assert(res.ParseErrors[0].Error(), Equals, "foo.spec:1 Spec heading should have at least one character => ''")
	c.Assert(res.ParseErrors[1].Error(), Equals, "foo.spec:4 Dynamic parameter <a> could not be resolved => 'def <a>'")
}

func (s *MySuite) TestSpecParsingWhenSpecHeadingIsNotPresent(c *C) {
	p := new(SpecParser)

	_, res, err := p.Parse(`#
Scenario Heading
----------------
* def "sad"
`, gauge.NewConceptDictionary(), "foo.spec")
	c.Assert(err, IsNil)
	c.Assert(len(res.ParseErrors), Equals, 1)
	c.Assert(res.ParseErrors[0].Error(), Equals, "foo.spec:1 Spec heading should have at least one character => ''")
}

func (s *MySuite) TestSpecParsingWhenUnderlinedSpecHeadingIsNotPresent(c *C) {
	p := new(SpecParser)

	_, res, err := p.Parse(`======
Scenario Heading
----------------
* def "sd"
`, gauge.NewConceptDictionary(), "foo.spec")
	c.Assert(err, IsNil)
	c.Assert(len(res.ParseErrors), Equals, 2)
	c.Assert(res.ParseErrors[0].Error(), Equals, "foo.spec:1 Spec heading not found => ''")
	c.Assert(res.ParseErrors[1].Error(), Equals, "foo.spec:2 Scenario should be defined after the spec heading => 'Scenario Heading'")
}

func (s *MySuite) TestProcessingTokensGivesErrorWhenSpecHeadingHasOnlySpaces(c *C) {
	p := new(SpecParser)

	_, res, err := p.Parse("#"+"           "+`
Scenario Heading
----------------
* def "sd"
`, gauge.NewConceptDictionary(), "foo.spec")
	c.Assert(err, IsNil)
	c.Assert(len(res.ParseErrors), Equals, 1)
	c.Assert(res.ParseErrors[0].Error(), Equals, "foo.spec:1 Spec heading should have at least one character => ''")
}

func (s *MySuite) TestProcessingTokensGivesErrorWhenScenarioHeadingIsEmpty(c *C) {
	p := new(SpecParser)

	_, res, err := p.Parse(`# dfgdfg
##
* def "sd"
`, gauge.NewConceptDictionary(), "foo.spec")
	c.Assert(err, IsNil)
	c.Assert(len(res.ParseErrors), Equals, 1)
	c.Assert(res.ParseErrors[0].Error(), Equals, "foo.spec:2 Scenario heading should have at least one character => ''")
}

func (s *MySuite) TestProcessingTokensGivesErrorWhenScenarioHeadingHasOnlySpaces(c *C) {
	p := new(SpecParser)

	_, res, err := p.Parse(`# dfgs
##`+"           "+`
* def "sd"
`, gauge.NewConceptDictionary(), "foo.spec")
	c.Assert(err, IsNil)
	c.Assert(len(res.ParseErrors), Equals, 1)
	c.Assert(res.ParseErrors[0].Error(), Equals, "foo.spec:2 Scenario heading should have at least one character => ''")
}

func (s *MySuite) TestScenarioProcessingToHaveScenarioSpan(c *C) {
	p := new(SpecParser)

	spec, _, err := p.Parse(`# Spec 1
## Scenario 1
* def "sd"
comment1
* def "sd"


## Scenario 2
* def "sd"
comment2
* def "sd"


## Scenario 3
* def "sd"
comment3
* def "sd"
`, gauge.NewConceptDictionary(), "")
	c.Assert(err, IsNil)
	c.Assert(len(spec.Scenarios), Equals, 3)
	c.Assert(spec.Scenarios[0].Span.Start, Equals, 2)
	c.Assert(spec.Scenarios[0].Span.End, Equals, 7)
	c.Assert(spec.Scenarios[1].Span.Start, Equals, 8)
	c.Assert(spec.Scenarios[1].Span.End, Equals, 13)
	c.Assert(spec.Scenarios[2].Span.Start, Equals, 14)
	c.Assert(spec.Scenarios[2].Span.End, Equals, 17)
}

func TestParseScenarioWithDataTable(t *testing.T) {
	p := new(SpecParser)
	var subject = func() *gauge.Scenario {
		spec, _, err := p.Parse(`Specification Heading
		=====================
		* Vowels in English language are "aeiou".
		
		Vowel counts in single word
		---------------------------
		
			|Word  |Vowel Count|
			|------|-----------|
			|Gauge |3          |
			|Mingle|2          |
			|Snap  |1          |
			|GoCD  |1          |
			|Rhythm|0          |
		
		* The word <Word> has <Vowel Count> vowels.
		
		`, gauge.NewConceptDictionary(), "")
		if err != nil {
			t.Error(err)
		}
		return spec.Scenarios[0]
	}

	t.Run("Parse Scenario with datatable when AllowScenarioDatatable=True", func(t *testing.T) {
		env.AllowScenarioDatatable = func() bool { return true }
		s := subject()
		v := len(s.DataTable.Table.Rows())
		if v != 5 {
			t.Errorf("expected scenario to have 5 rows, got %d", v)
		}
		v = len(s.DataTable.Table.Columns)
		if v != 2 {
			t.Errorf("expected scenario to have 2 columns, got %d", v)
		}
	})

	t.Run("Parse Scenario with datatable when AllowScenarioDatatable=False", func(t *testing.T) {
		env.AllowScenarioDatatable = func() bool { return false }
		s := subject()
		v := len(s.DataTable.Table.Rows())
		if v != 0 {
			t.Errorf("expected scenario to have no rows, got %d", v)
		}
	})
}

func TestParseScenarioWithExternalDataTable(t *testing.T) {
	p := new(SpecParser)
	var subject = func() *gauge.Scenario {
		spec, _, err := p.Parse(`Specification Heading
=====================
* Vowels in English language are "aeiou".

Vowel counts in single word
---------------------------
table:testdata/data.csv

* The word <Word> has <Vowel Count> vowels.

`, gauge.NewConceptDictionary(), "")
		if err != nil {
			t.Error(err)
		}
		return spec.Scenarios[0]
	}

	t.Run("Parse Scenario with external datatable when AllowScenarioDatatable=True", func(t *testing.T) {
		env.AllowScenarioDatatable = func() bool { return true }
		s := subject()
		v := len(s.DataTable.Table.Rows())
		if v != 5 {
			t.Errorf("expected scenario to have 5 rows, got %d", v)
		}
		v = len(s.DataTable.Table.Columns)
		if v != 2 {
			t.Errorf("expected scenario to have 2 columns, got %d", v)
		}
	})

	t.Run("Parse Scenario with datatable when AllowScenarioDatatable=False", func(t *testing.T) {
		env.AllowScenarioDatatable = func() bool { return false }
		s := subject()
		v := len(s.DataTable.Table.Rows())
		if v != 0 {
			t.Errorf("expected scenario to have no rows, got %d", v)
		}
	})
}

func (s *MySuite) TestParsingWhenTearDownHAsOnlyTable(c *C) {
	p := new(SpecParser)

	spec, _, err := p.Parse(`Specification Heading
=====================
* Vowels in English language are "aeiou".

Vowel counts in single word
---------------------------
* The word "gauge" has "3" vowels.
___
     |Word  |Vowel Count|
     |------|-----------|
     |Gauge |3          |
     |Mingle|2          |
     |Snap  |1          |
     |GoCD  |1          |
     |Rhythm|0          |

`, gauge.NewConceptDictionary(), "")
	c.Assert(err, IsNil)
	c.Assert(len(spec.TearDownSteps), Equals, 0)
	c.Assert(len(spec.Comments), Equals, 7)
}

func (s *MySuite) TestSpecWithRepeatedTagDefinitions(c *C) {
	p := new(SpecParser)
	spec, parseRes, err := p.Parse(`Spec Heading
==============
tags: foo, bar

* step
tags: blah

Scenario
--------
* step
	`, gauge.NewConceptDictionary(), "")
	c.Assert(err, IsNil)
	c.Assert(len(parseRes.ParseErrors), Equals, 1)
	c.Assert(parseRes.ParseErrors[0].Message, Equals, "Tags can be defined only once per specification")
	c.Assert(len(spec.Tags.Values()), Equals, 2)
	c.Assert(spec.Tags.Values()[0], Equals, "foo")
	c.Assert(spec.Tags.Values()[1], Equals, "bar")
}

func (s *MySuite) TestScenarioWithRepeatedTagDefinitions(c *C) {
	p := new(SpecParser)
	spec, parseRes, err := p.Parse(`Spec Heading
==============
tags: tag1

* step

Scenario
--------
tags: foo, bar
* step
tags: blah
	`, gauge.NewConceptDictionary(), "")
	c.Assert(err, IsNil)
	c.Assert(len(parseRes.ParseErrors), Equals, 1)
	c.Assert(parseRes.ParseErrors[0].Message, Equals, "Tags can be defined only once per scenario")
	c.Assert(len(spec.Scenarios[0].Tags.Values()), Equals, 2)
	c.Assert(spec.Scenarios[0].Tags.Values()[0], Equals, "foo")
	c.Assert(spec.Scenarios[0].Tags.Values()[1], Equals, "bar")
	c.Assert(len(spec.Tags.Values()), Equals, 1)
	c.Assert(spec.Tags.Values()[0], Equals, "tag1")
}

func (s *MySuite) TestDatatTableWithEmptyHeaders(c *C) {
	p := new(SpecParser)
	_, parseRes, err := p.Parse(`Something
=========

     ||a|||a|
     |-------|
     |dsf|dsf|dsf|dsf|dsf|

Scenario Heading
----------------
* Vowels in English language are "aeiou".
`, gauge.NewConceptDictionary(), "")
	c.Assert(err, IsNil)
	c.Assert(len(parseRes.ParseErrors), Equals, 4)
	c.Assert(parseRes.ParseErrors[0].Message, Equals, "Table header should not be blank")
	c.Assert(parseRes.ParseErrors[1].Message, Equals, "Table header should not be blank")
	c.Assert(parseRes.ParseErrors[2].Message, Equals, "Table header should not be blank")
	c.Assert(parseRes.ParseErrors[3].Message, Equals, "Table header cannot have repeated column values")
}

func (s *MySuite) TestExtractStepArgsFromToken(c *C) {
	token := &Token{Kind: gauge.StepKind, Lines: []string{`my step with "Static" and <Dynamic> params`}, Value: `my step with {static} and {dynamic} params`, Args: []string{"Static", "Dynamic"}}

	args, err := ExtractStepArgsFromToken(token)
	if err != nil {
		c.Fatalf("Error while extracting step args : %s", err.Error())
	}
	c.Assert(len(args), Equals, 2)
	c.Assert(args[0].Value, Equals, "Static")
	c.Assert(args[0].ArgType, Equals, gauge.Static)
	c.Assert(args[1].Value, Equals, "Dynamic")
	c.Assert(args[1].ArgType, Equals, gauge.Dynamic)
}

func (s *MySuite) TestParsingTableParameterWithSpecialString(c *C) {
	parser := new(SpecParser)
	specText := newSpecBuilder().specHeading("Spec Heading").scenarioHeading("First scenario").step("my step").text("|name|id|").text("|---|---|").text("|john|123|").text("|james|<file:testdata/foo.txt>|").String()

	spec, res := parser.ParseSpecText(specText, "")
	c.Assert(res.Ok, Equals, true)
	c.Assert(spec.Scenarios[0].Steps[0].Args[0].ArgType, Equals, gauge.TableArg)

	c.Assert(spec.Scenarios[0].Steps[0].Args[0].Table.Columns[0][0].Value, Equals, "john")
	c.Assert(spec.Scenarios[0].Steps[0].Args[0].Table.Columns[0][0].CellType, Equals, gauge.Static)

	c.Assert(spec.Scenarios[0].Steps[0].Args[0].Table.Columns[0][1].Value, Equals, "james")
	c.Assert(spec.Scenarios[0].Steps[0].Args[0].Table.Columns[0][1].CellType, Equals, gauge.Static)

	c.Assert(spec.Scenarios[0].Steps[0].Args[0].Table.Columns[1][0].Value, Equals, "123")
	c.Assert(spec.Scenarios[0].Steps[0].Args[0].Table.Columns[1][0].CellType, Equals, gauge.Static)

	c.Assert(spec.Scenarios[0].Steps[0].Args[0].Table.Columns[1][1].Value, Equals, "file:testdata/foo.txt")
	c.Assert(spec.Scenarios[0].Steps[0].Args[0].Table.Columns[1][1].CellType, Equals, gauge.SpecialString)
}

func (s *MySuite) TestParsingDataTableWithSpecialString(c *C) {
	parser := new(SpecParser)
	specText := newSpecBuilder().specHeading("Spec heading").text("|name|id|").text("|---|---|").text("|john|123|").text("|james|<file:testdata/foo.txt>|").String()

	specs, res := parser.ParseSpecText(specText, "")
	c.Assert(res.Ok, Equals, true)
	c.Assert(specs.DataTable.Table.Columns[0][0].Value, Equals, "john")
	c.Assert(specs.DataTable.Table.Columns[0][0].CellType, Equals, gauge.Static)

	c.Assert(specs.DataTable.Table.Columns[0][1].Value, Equals, "james")
	c.Assert(specs.DataTable.Table.Columns[0][1].CellType, Equals, gauge.Static)

	c.Assert(specs.DataTable.Table.Columns[1][0].Value, Equals, "123")
	c.Assert(specs.DataTable.Table.Columns[1][0].CellType, Equals, gauge.Static)

	c.Assert(specs.DataTable.Table.Columns[1][1].Value, Equals, "file:testdata/foo.txt")
	c.Assert(specs.DataTable.Table.Columns[1][1].CellType, Equals, gauge.SpecialString)
}

func (s *MySuite) TestTableForSpecialParameterWhenFileIsNotFound(c *C) {
	parser := new(SpecParser)
	specText := newSpecBuilder().specHeading("Spec Heading").scenarioHeading("First scenario").step("my step").text("|name|id|").text("|---|---|").text("|john|123|").text("|james|<file:notFound.txt>|").String()

	_, res := parser.ParseSpecText(specText, "")

	c.Assert(res.Ok, Equals, false)
	c.Assert(res.ParseErrors[0].Message, Equals, "Dynamic param <file:notFound.txt> could not be resolved, Missing file: notFound.txt")
	c.Assert(res.ParseErrors[0].LineText, Equals, "|james|<file:notFound.txt>|")
}

func (s *MySuite) TestDataTableForSpecialParameterWhenFileIsNotFound(c *C) {
	parser := new(SpecParser)
	specText := newSpecBuilder().specHeading("Spec heading").text("|name|id|").text("|---|---|").text("|john|123|").text("|james|<file:notFound.txt>|").String()

	_, res := parser.ParseSpecText(specText, "")

	c.Assert(res.Ok, Equals, false)
	c.Assert(res.ParseErrors[0].Message, Equals, "Dynamic param <file:notFound.txt> could not be resolved, Missing file: notFound.txt")
	c.Assert(res.ParseErrors[0].LineText, Equals, "|james|<file:notFound.txt>|")
}