github.com/getgauge/gauge@v1.6.9/parser/helper_test.go (about)

     1  /*----------------------------------------------------------------
     2   *  Copyright (c) ThoughtWorks, Inc.
     3   *  Licensed under the Apache License, Version 2.0
     4   *  See LICENSE in the project root for license information.
     5   *----------------------------------------------------------------*/
     6  
     7  package parser
     8  
     9  import (
    10  	"fmt"
    11  
    12  	. "gopkg.in/check.v1"
    13  )
    14  
    15  type specBuilder struct {
    16  	lines []string
    17  }
    18  
    19  func newSpecBuilder() *specBuilder {
    20  	return &specBuilder{lines: make([]string, 0)}
    21  }
    22  
    23  func (specBuilder *specBuilder) addPrefix(prefix string, line string) string {
    24  	return fmt.Sprintf("%s%s\n", prefix, line)
    25  }
    26  
    27  func (specBuilder *specBuilder) String() string {
    28  	var result string
    29  	for _, line := range specBuilder.lines {
    30  		result = fmt.Sprintf("%s%s", result, line)
    31  	}
    32  	return result
    33  }
    34  
    35  func (specBuilder *specBuilder) specHeading(heading string) *specBuilder {
    36  	line := specBuilder.addPrefix("#", heading)
    37  	specBuilder.lines = append(specBuilder.lines, line)
    38  	return specBuilder
    39  }
    40  
    41  func (specBuilder *specBuilder) scenarioHeading(heading string) *specBuilder {
    42  	line := specBuilder.addPrefix("##", heading)
    43  	specBuilder.lines = append(specBuilder.lines, line)
    44  	return specBuilder
    45  }
    46  
    47  func (specBuilder *specBuilder) step(stepText string) *specBuilder {
    48  	line := specBuilder.addPrefix("* ", stepText)
    49  	specBuilder.lines = append(specBuilder.lines, line)
    50  	return specBuilder
    51  }
    52  
    53  func (specBuilder *specBuilder) tags(tags ...string) *specBuilder {
    54  	tagText := ""
    55  	for i, tag := range tags {
    56  		tagText = fmt.Sprintf("%s%s", tagText, tag)
    57  		if i != len(tags)-1 {
    58  			tagText = fmt.Sprintf("%s,", tagText)
    59  		}
    60  	}
    61  	line := specBuilder.addPrefix("tags: ", tagText)
    62  	specBuilder.lines = append(specBuilder.lines, line)
    63  	return specBuilder
    64  }
    65  
    66  func (specBuilder *specBuilder) tableHeader(cells ...string) *specBuilder {
    67  	return specBuilder.tableRow(cells...)
    68  }
    69  func (specBuilder *specBuilder) tableRow(cells ...string) *specBuilder {
    70  	rowInMarkdown := "|"
    71  	for _, cell := range cells {
    72  		rowInMarkdown = fmt.Sprintf("%s%s|", rowInMarkdown, cell)
    73  	}
    74  	specBuilder.lines = append(specBuilder.lines, fmt.Sprintf("%s\n", rowInMarkdown))
    75  	return specBuilder
    76  }
    77  
    78  func (specBuilder *specBuilder) text(comment string) *specBuilder {
    79  	specBuilder.lines = append(specBuilder.lines, fmt.Sprintf("%s\n", comment))
    80  	return specBuilder
    81  }
    82  
    83  func (s *MySuite) TestIsInState(c *C) {
    84  	c.Assert(isInState(1, 1), Equals, true)
    85  	c.Assert(isInState(1, 3, 2), Equals, true)
    86  	c.Assert(isInState(4, 1, 2), Equals, false)
    87  	c.Assert(isInState(4), Equals, false)
    88  }
    89  
    90  func (s *MySuite) TestIsInAnyState(c *C) {
    91  	c.Assert(isInAnyState(4, 4), Equals, true)
    92  	c.Assert(isInAnyState(4, 1, 4), Equals, true)
    93  	c.Assert(isInAnyState(8, 1, 3), Equals, false)
    94  	c.Assert(isInAnyState(8), Equals, false)
    95  }
    96  
    97  func (s *MySuite) TestRetainStates(c *C) {
    98  	oldState := 5
    99  	retainStates(&oldState, 1)
   100  	c.Assert(oldState, Equals, 1)
   101  
   102  	oldState = 5
   103  	retainStates(&oldState, 4, 1)
   104  	c.Assert(oldState, Equals, 5)
   105  
   106  	oldState = 8
   107  	retainStates(&oldState, 4, 6)
   108  	c.Assert(oldState, Equals, 0)
   109  }
   110  
   111  func (s *MySuite) TestAddStates(c *C) {
   112  	oldState := 4
   113  	addStates(&oldState, 1)
   114  	c.Assert(oldState, Equals, 5)
   115  
   116  	oldState = 8
   117  	addStates(&oldState, 1, 2)
   118  	c.Assert(oldState, Equals, 11)
   119  
   120  	oldState = 8
   121  	addStates(&oldState)
   122  	c.Assert(oldState, Equals, 8)
   123  }
   124  
   125  func (s *MySuite) TestAreUnderlinedForEmptyArray(c *C) {
   126  	var emptyAray []string
   127  	c.Assert(false, Equals, areUnderlined(emptyAray))
   128  }
   129  
   130  func (s *MySuite) TestSpecBuilderSpecHeading(c *C) {
   131  	heading := newSpecBuilder().specHeading("spec heading").String()
   132  	c.Assert(heading, Equals, "#spec heading\n")
   133  }
   134  
   135  func (s *MySuite) TestSpecBuilderScenarioHeading(c *C) {
   136  	heading := newSpecBuilder().scenarioHeading("scenario heading").String()
   137  	c.Assert(heading, Equals, "##scenario heading\n")
   138  }
   139  
   140  func (s *MySuite) TestSpecBuilderStep(c *C) {
   141  	step := newSpecBuilder().step("sample step").String()
   142  	c.Assert(step, Equals, "* sample step\n")
   143  }
   144  
   145  func (s *MySuite) TestSpecBuilderTags(c *C) {
   146  	tags := newSpecBuilder().tags("tag1", "tag2").String()
   147  	c.Assert(tags, Equals, "tags: tag1,tag2\n")
   148  }
   149  
   150  func (s *MySuite) TestSpecBuilderWithFreeText(c *C) {
   151  	freeText := newSpecBuilder().text("some free text").String()
   152  	c.Assert(freeText, Equals, "some free text\n")
   153  }
   154  
   155  func (s *MySuite) TestSpecBuilderWithSampleSpec(c *C) {
   156  	spec := newSpecBuilder().specHeading("spec heading").tags("tag1", "tag2").step("context here").scenarioHeading("scenario heading").text("comment").step("sample step").scenarioHeading("scenario 2").step("step 2")
   157  	c.Assert(spec.String(), Equals, "#spec heading\ntags: tag1,tag2\n* context here\n##scenario heading\ncomment\n* sample step\n##scenario 2\n* step 2\n")
   158  }
   159  
   160  func (s *MySuite) TestUnescapedString(c *C) {
   161  	unEscapedString := GetUnescapedString("hello \n world")
   162  	c.Assert(unEscapedString, Equals, `hello \n world`)
   163  
   164  	unEscapedString = GetUnescapedString("hello \n \"world")
   165  	c.Assert(unEscapedString, Equals, `hello \n \"world`)
   166  
   167  	unEscapedString = GetUnescapedString("\"hello \n \"world\"\"")
   168  	c.Assert(unEscapedString, Equals, `\"hello \n \"world\"\"`)
   169  
   170  	unEscapedString = GetUnescapedString("\"\"")
   171  	c.Assert(unEscapedString, Equals, `\"\"`)
   172  
   173  	unEscapedString = GetUnescapedString("")
   174  	c.Assert(unEscapedString, Equals, "")
   175  
   176  }