github.com/arvindram03/terraform@v0.3.7-0.20150212015210-408f838db36d/config/lang/lex_test.go (about)

     1  package lang
     2  
     3  import (
     4  	"reflect"
     5  	"testing"
     6  )
     7  
     8  func TestLex(t *testing.T) {
     9  	cases := []struct {
    10  		Input  string
    11  		Output []int
    12  	}{
    13  		{
    14  			"foo",
    15  			[]int{STRING, lexEOF},
    16  		},
    17  
    18  		{
    19  			"foo$bar",
    20  			[]int{STRING, lexEOF},
    21  		},
    22  
    23  		{
    24  			"foo ${bar}",
    25  			[]int{STRING, PROGRAM_BRACKET_LEFT, IDENTIFIER, PROGRAM_BRACKET_RIGHT, lexEOF},
    26  		},
    27  
    28  		{
    29  			"foo $${bar}",
    30  			[]int{STRING, lexEOF},
    31  		},
    32  
    33  		{
    34  			"foo $$$${bar}",
    35  			[]int{STRING, lexEOF},
    36  		},
    37  
    38  		{
    39  			"foo ${\"bar\"}",
    40  			[]int{STRING, PROGRAM_BRACKET_LEFT, STRING, PROGRAM_BRACKET_RIGHT, lexEOF},
    41  		},
    42  
    43  		{
    44  			"${bar(baz)}",
    45  			[]int{PROGRAM_BRACKET_LEFT,
    46  				IDENTIFIER, PAREN_LEFT, IDENTIFIER, PAREN_RIGHT,
    47  				PROGRAM_BRACKET_RIGHT, lexEOF},
    48  		},
    49  
    50  		{
    51  			"${bar(baz, foo)}",
    52  			[]int{PROGRAM_BRACKET_LEFT,
    53  				IDENTIFIER, PAREN_LEFT,
    54  				IDENTIFIER, COMMA, IDENTIFIER,
    55  				PAREN_RIGHT,
    56  				PROGRAM_BRACKET_RIGHT, lexEOF},
    57  		},
    58  
    59  		{
    60  			"${bar(42)}",
    61  			[]int{PROGRAM_BRACKET_LEFT,
    62  				IDENTIFIER, PAREN_LEFT, INTEGER, PAREN_RIGHT,
    63  				PROGRAM_BRACKET_RIGHT, lexEOF},
    64  		},
    65  
    66  		{
    67  			"${bar(3.14159)}",
    68  			[]int{PROGRAM_BRACKET_LEFT,
    69  				IDENTIFIER, PAREN_LEFT, FLOAT, PAREN_RIGHT,
    70  				PROGRAM_BRACKET_RIGHT, lexEOF},
    71  		},
    72  
    73  		{
    74  			"${bar(inner(baz))}",
    75  			[]int{PROGRAM_BRACKET_LEFT,
    76  				IDENTIFIER, PAREN_LEFT,
    77  				IDENTIFIER, PAREN_LEFT,
    78  				IDENTIFIER,
    79  				PAREN_RIGHT, PAREN_RIGHT,
    80  				PROGRAM_BRACKET_RIGHT, lexEOF},
    81  		},
    82  
    83  		{
    84  			"foo ${foo.bar.baz}",
    85  			[]int{STRING, PROGRAM_BRACKET_LEFT, IDENTIFIER, PROGRAM_BRACKET_RIGHT, lexEOF},
    86  		},
    87  
    88  		{
    89  			"foo ${foo.bar.*.baz}",
    90  			[]int{STRING, PROGRAM_BRACKET_LEFT, IDENTIFIER, PROGRAM_BRACKET_RIGHT, lexEOF},
    91  		},
    92  
    93  		{
    94  			"foo ${foo(\"baz\")}",
    95  			[]int{STRING, PROGRAM_BRACKET_LEFT,
    96  				IDENTIFIER, PAREN_LEFT, STRING, PAREN_RIGHT,
    97  				PROGRAM_BRACKET_RIGHT, lexEOF},
    98  		},
    99  
   100  		{
   101  			`foo ${"${var.foo}"}`,
   102  			[]int{STRING, PROGRAM_BRACKET_LEFT,
   103  				PROGRAM_BRACKET_LEFT, IDENTIFIER, PROGRAM_BRACKET_RIGHT,
   104  				PROGRAM_BRACKET_RIGHT, lexEOF},
   105  		},
   106  	}
   107  
   108  	for _, tc := range cases {
   109  		l := &parserLex{Input: tc.Input}
   110  		var actual []int
   111  		for {
   112  			token := l.Lex(new(parserSymType))
   113  			actual = append(actual, token)
   114  
   115  			if token == lexEOF {
   116  				break
   117  			}
   118  
   119  			// Be careful against what are probably infinite loops
   120  			if len(actual) > 100 {
   121  				t.Fatalf("Input:%s\n\nExausted.", tc.Input)
   122  			}
   123  		}
   124  
   125  		if !reflect.DeepEqual(actual, tc.Output) {
   126  			t.Fatalf(
   127  				"Input: %s\n\nBad: %#v\n\nExpected: %#v",
   128  				tc.Input, actual, tc.Output)
   129  		}
   130  	}
   131  }