github.com/gwilym/terraform@v0.3.8-0.20151231151641-c7573de75b19/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(-42)}",
    68  			[]int{PROGRAM_BRACKET_LEFT,
    69  				IDENTIFIER, PAREN_LEFT, ARITH_OP, INTEGER, PAREN_RIGHT,
    70  				PROGRAM_BRACKET_RIGHT, lexEOF},
    71  		},
    72  
    73  		{
    74  			"${bar(-42.0)}",
    75  			[]int{PROGRAM_BRACKET_LEFT,
    76  				IDENTIFIER, PAREN_LEFT, ARITH_OP, FLOAT, PAREN_RIGHT,
    77  				PROGRAM_BRACKET_RIGHT, lexEOF},
    78  		},
    79  
    80  		{
    81  			"${bar(42+1)}",
    82  			[]int{PROGRAM_BRACKET_LEFT,
    83  				IDENTIFIER, PAREN_LEFT,
    84  				INTEGER, ARITH_OP, INTEGER,
    85  				PAREN_RIGHT,
    86  				PROGRAM_BRACKET_RIGHT, lexEOF},
    87  		},
    88  
    89  		{
    90  			"${bar(42+-1)}",
    91  			[]int{PROGRAM_BRACKET_LEFT,
    92  				IDENTIFIER, PAREN_LEFT,
    93  				INTEGER, ARITH_OP, ARITH_OP, INTEGER,
    94  				PAREN_RIGHT,
    95  				PROGRAM_BRACKET_RIGHT, lexEOF},
    96  		},
    97  
    98  		{
    99  			"${bar(3.14159)}",
   100  			[]int{PROGRAM_BRACKET_LEFT,
   101  				IDENTIFIER, PAREN_LEFT, FLOAT, PAREN_RIGHT,
   102  				PROGRAM_BRACKET_RIGHT, lexEOF},
   103  		},
   104  
   105  		{
   106  			"${bar(inner(baz))}",
   107  			[]int{PROGRAM_BRACKET_LEFT,
   108  				IDENTIFIER, PAREN_LEFT,
   109  				IDENTIFIER, PAREN_LEFT,
   110  				IDENTIFIER,
   111  				PAREN_RIGHT, PAREN_RIGHT,
   112  				PROGRAM_BRACKET_RIGHT, lexEOF},
   113  		},
   114  
   115  		{
   116  			"foo ${foo.bar.baz}",
   117  			[]int{STRING, PROGRAM_BRACKET_LEFT, IDENTIFIER, PROGRAM_BRACKET_RIGHT, lexEOF},
   118  		},
   119  
   120  		{
   121  			"foo ${foo.bar.*.baz}",
   122  			[]int{STRING, PROGRAM_BRACKET_LEFT, IDENTIFIER, PROGRAM_BRACKET_RIGHT, lexEOF},
   123  		},
   124  
   125  		{
   126  			"foo ${foo(\"baz\")}",
   127  			[]int{STRING, PROGRAM_BRACKET_LEFT,
   128  				IDENTIFIER, PAREN_LEFT, STRING, PAREN_RIGHT,
   129  				PROGRAM_BRACKET_RIGHT, lexEOF},
   130  		},
   131  
   132  		{
   133  			`foo ${"${var.foo}"}`,
   134  			[]int{STRING, PROGRAM_BRACKET_LEFT,
   135  				PROGRAM_BRACKET_LEFT, IDENTIFIER, PROGRAM_BRACKET_RIGHT,
   136  				PROGRAM_BRACKET_RIGHT, lexEOF},
   137  		},
   138  	}
   139  
   140  	for _, tc := range cases {
   141  		l := &parserLex{Input: tc.Input}
   142  		var actual []int
   143  		for {
   144  			token := l.Lex(new(parserSymType))
   145  			actual = append(actual, token)
   146  
   147  			if token == lexEOF {
   148  				break
   149  			}
   150  
   151  			// Be careful against what are probably infinite loops
   152  			if len(actual) > 100 {
   153  				t.Fatalf("Input:%s\n\nExausted.", tc.Input)
   154  			}
   155  		}
   156  
   157  		if !reflect.DeepEqual(actual, tc.Output) {
   158  			t.Fatalf(
   159  				"Input: %s\n\nBad: %#v\n\nExpected: %#v",
   160  				tc.Input, actual, tc.Output)
   161  		}
   162  	}
   163  }