github.com/informationsea/shellflow@v0.1.3/flowscript/flowscript_parser_test.go (about)

     1  package flowscript
     2  
     3  import (
     4  	"reflect"
     5  	"strings"
     6  	"testing"
     7  )
     8  
     9  func createInitializedTokenizer(text string) *LookAheadScanner {
    10  	scanner := NewTokenizerFromText(text)
    11  	if !scanner.Scan() {
    12  		panic("failed to scan")
    13  	}
    14  	return scanner
    15  }
    16  
    17  func checkNumberLevel(t *testing.T, p parser) {
    18  	if v, e := p(createInitializedTokenizer("123")); e != nil || v != (ValueEvaluable{IntValue{123}}) {
    19  		t.Fatalf("Bad result: %s / error: %s", v, e)
    20  	}
    21  
    22  	{
    23  		tokenier := createInitializedTokenizer("123 456")
    24  		if v, e := p(tokenier); e != nil || v != (ValueEvaluable{IntValue{123}}) {
    25  			t.Fatalf("Bad result: %s / error: %s", v, e)
    26  		}
    27  		if v, e := p(tokenier); e != nil || v != (ValueEvaluable{IntValue{456}}) {
    28  			t.Fatalf("Bad result: %s / error: %s", v, e)
    29  		}
    30  	}
    31  
    32  	if v, e := p(createInitializedTokenizer("2147483647")); e != nil || v != (ValueEvaluable{IntValue{2147483647}}) {
    33  		t.Fatalf("Bad result: %s / error: %s", v, e)
    34  	}
    35  
    36  	// out of range
    37  	if v, e := p(createInitializedTokenizer("2147483648")); e == nil || v != nil {
    38  		t.Fatalf("Bad result: %s / error: %s", v, e)
    39  	}
    40  }
    41  
    42  func TestParseAsNumber(t *testing.T) {
    43  	checkNumberLevel(t, ParseAsNumber)
    44  
    45  	// unmatched
    46  	if v, e := ParseAsNumber(createInitializedTokenizer("hoge")); e != errUnmatched || v != nil {
    47  		t.Fatalf("Bad result: %s / error: %s", v, e)
    48  	}
    49  }
    50  
    51  func checkStringLevel(t *testing.T, p parser) {
    52  	if v, e := p(createInitializedTokenizer("\"hoge\"")); e != nil || v != (ValueEvaluable{StringValue{"hoge"}}) {
    53  		t.Fatalf("Bad result: %s / error: %s", v, e)
    54  	}
    55  
    56  	if v, e := p(createInitializedTokenizer("\"foo\\r\\n\\thoge\"")); e != nil || v != (ValueEvaluable{StringValue{"foo\r\n\thoge"}}) {
    57  		t.Fatalf("Bad result: %s / error: %s", v, e)
    58  	}
    59  
    60  	// bad escape
    61  	if v, e := p(createInitializedTokenizer("\"ho\\xge\"")); e == nil || v != nil {
    62  		t.Fatalf("Bad result: %s / error: %s", v, e)
    63  	}
    64  }
    65  
    66  func TestParseAsString(t *testing.T) {
    67  	checkStringLevel(t, ParseAsString)
    68  
    69  	// unmatched
    70  	if v, e := ParseAsString(createInitializedTokenizer("foo")); e != errUnmatched || v != nil {
    71  		t.Fatalf("Bad result: %s / error: %s", v, e)
    72  	}
    73  }
    74  
    75  func TestParseAsVariable(t *testing.T) {
    76  	if v, e := ParseAsVariable(createInitializedTokenizer("hoge")); e != nil {
    77  		v1, ok := v.(*Variable)
    78  		if !ok || v1.Name != "hoge" {
    79  			t.Fatalf("Bad result: %s / error: %s", v, e)
    80  		}
    81  	}
    82  
    83  	if v, e := ParseAsVariable(createInitializedTokenizer("12foo")); e == nil || v != nil || e != errUnmatched {
    84  		t.Fatalf("Bad result: %s / error: %s", v, e)
    85  	}
    86  
    87  	if v, e := ParseAsVariable(createInitializedTokenizer("[")); e == nil || v != nil || e != errUnmatched {
    88  		t.Fatalf("Bad result: %s / error: %s", v, e)
    89  	}
    90  }
    91  
    92  func checkFactor3Level(t *testing.T, p parser) {
    93  	checkNumberLevel(t, p)
    94  	checkStringLevel(t, p)
    95  	checkArrayAccessLevel(t, p)
    96  	checkFunctionCallParseLevel(t, p)
    97  	ge := createTestGlobalEnvironment()
    98  	{
    99  		v, e := p(createInitializedTokenizer("hoge"))
   100  		if e != nil {
   101  			t.Fatalf("Bad result: %s / error: %s", v, e)
   102  		}
   103  
   104  		v1, ok := v.(*Variable)
   105  		if !ok || v1.Name != "hoge" {
   106  			t.Fatalf("Bad result: %s / error: %s", v, e)
   107  		}
   108  
   109  		if ev, ee := v.Evaluate(ge); ee != nil || ev != (StringValue{"hoge"}) {
   110  			t.Fatalf("Bad evaluated result: %s", ev)
   111  		}
   112  	}
   113  
   114  	{
   115  		v, e := p(createInitializedTokenizer("\"hoge\""))
   116  		if e != nil || v != (ValueEvaluable{StringValue{"hoge"}}) {
   117  			t.Fatalf("Bad result: %s / error: %s", v, e)
   118  		}
   119  
   120  		if ev, ee := v.Evaluate(ge); ee != nil || ev != (StringValue{"hoge"}) {
   121  			t.Fatalf("Bad evaluated result: %s", ev)
   122  		}
   123  	}
   124  
   125  	{
   126  		v, e := p(createInitializedTokenizer("123"))
   127  		if e != nil || v != (ValueEvaluable{IntValue{123}}) {
   128  			t.Fatalf("Bad result: %s / error: %s", v, e)
   129  		}
   130  
   131  		if ev, ee := v.Evaluate(ge); ee != nil || ev != (IntValue{123}) {
   132  			t.Fatalf("Bad evaluated result: %s", ev)
   133  		}
   134  	}
   135  }
   136  
   137  func TestParseAsFactor3(t *testing.T) {
   138  	checkFactor3Level(t, ParseAsFactor3)
   139  
   140  	if v, e := ParseAsFactor3(createInitializedTokenizer("<")); e == nil || v != nil || e != errUnmatched {
   141  		t.Fatalf("Bad result: %s / error: %s", v, e)
   142  	}
   143  }
   144  
   145  func checkFactor2Level(t *testing.T, p parser) {
   146  	checkFactor3Level(t, p)
   147  	ge := createTestGlobalEnvironment()
   148  
   149  	{
   150  		v, e := p(createInitializedTokenizer("4 * 2"))
   151  		if e != nil {
   152  			t.Fatalf("Bad result: %s / error: %s", v, e)
   153  		}
   154  		v1, ok := v.(*NumericOperationExpression)
   155  		if !ok || v1.exp1 != (ValueEvaluable{IntValue{4}}) || v1.exp2 != (ValueEvaluable{IntValue{2}}) || v1.operator != "*" {
   156  			t.Fatalf("Bad result: %s / error: %s", v, e)
   157  		}
   158  
   159  		ev, ee := v.Evaluate(ge)
   160  		if ee != nil || ev != (IntValue{8}) {
   161  			t.Fatalf("Bad evaluate result %d / error: %s", ev, ee)
   162  		}
   163  	}
   164  
   165  	{
   166  		v, e := p(createInitializedTokenizer("4 / 2"))
   167  		if e != nil {
   168  			t.Fatalf("Bad result: %s / error: %s", v, e)
   169  		}
   170  		v1, ok := v.(*NumericOperationExpression)
   171  		if !ok || v1.exp1 != (ValueEvaluable{IntValue{4}}) || v1.exp2 != (ValueEvaluable{IntValue{2}}) || v1.operator != "/" {
   172  			t.Fatalf("Bad result: %s / error: %s", v, e)
   173  		}
   174  
   175  		ev, ee := v.Evaluate(ge)
   176  		if ee != nil || ev != (IntValue{2}) {
   177  			t.Fatalf("Bad evaluate result %d / error: %s", ev, ee)
   178  		}
   179  	}
   180  
   181  	if v, e := p(createInitializedTokenizer("4 / !")); e == nil || e.Error() != "parse error: 4 / !" {
   182  		t.Fatalf("Bad result: %s / error: %s", v, e)
   183  	}
   184  }
   185  
   186  func TestParseAsFactor2(t *testing.T) {
   187  	checkFactor2Level(t, ParseAsFactor2)
   188  
   189  	if v, e := ParseAsFactor2(createInitializedTokenizer("<")); e == nil || v != nil || e != errUnmatched {
   190  		t.Fatalf("Bad result: %s / error: %s", v, e)
   191  	}
   192  }
   193  
   194  func checkFactor1Level(t *testing.T, p parser) {
   195  	checkFactor2Level(t, p)
   196  	ge := createTestGlobalEnvironment()
   197  
   198  	{
   199  		v, e := p(createInitializedTokenizer("4 - 2"))
   200  		if e != nil {
   201  			t.Fatalf("Bad result: %s / error: %s", v, e)
   202  		}
   203  		v1, ok := v.(*NumericOperationExpression)
   204  		if !ok || v1.exp1 != (ValueEvaluable{IntValue{4}}) || v1.exp2 != (ValueEvaluable{IntValue{2}}) || v1.operator != "-" {
   205  			t.Fatalf("Bad result: %s / error: %s", v, e)
   206  		}
   207  
   208  		ev, ee := v.Evaluate(ge)
   209  		if ee != nil || ev != (IntValue{2}) {
   210  			t.Fatalf("Bad evaluate result %d / error: %s", ev, ee)
   211  		}
   212  	}
   213  
   214  	{
   215  		v, e := p(createInitializedTokenizer("4 + 2"))
   216  		if e != nil {
   217  			t.Fatalf("Bad result: %s / error: %s", v, e)
   218  		}
   219  		v1, ok := v.(*PlusExpression)
   220  		if !ok || v1.exp1 != (ValueEvaluable{IntValue{4}}) || v1.exp2 != (ValueEvaluable{IntValue{2}}) {
   221  			t.Fatalf("Bad result: %s / error: %s", v, e)
   222  		}
   223  
   224  		ev, ee := v.Evaluate(ge)
   225  		if ee != nil || ev != (IntValue{6}) {
   226  			t.Fatalf("Bad evaluate result %d / error: %s", ev, ee)
   227  		}
   228  	}
   229  
   230  	{
   231  		v, e := p(createInitializedTokenizer("4 + \"hoge\""))
   232  		if e != nil {
   233  			t.Fatalf("Bad result: %s / error: %s", v, e)
   234  		}
   235  		v1, ok := v.(*PlusExpression)
   236  		if !ok || v1.exp1 != (ValueEvaluable{IntValue{4}}) || v1.exp2 != (ValueEvaluable{StringValue{"hoge"}}) {
   237  			t.Fatalf("Bad result: %s / error: %s", v, e)
   238  		}
   239  
   240  		ev, ee := v.Evaluate(ge)
   241  		if ee != nil || ev != (StringValue{"4hoge"}) {
   242  			t.Fatalf("Bad evaluate result %d / error: %s", ev, ee)
   243  		}
   244  	}
   245  
   246  	{
   247  		v, e := p(createInitializedTokenizer("\"hoge\" + 2"))
   248  		if e != nil {
   249  			t.Fatalf("Bad result: %s / error: %s", v, e)
   250  		}
   251  		v1, ok := v.(*PlusExpression)
   252  		if !ok || v1.exp1 != (ValueEvaluable{StringValue{"hoge"}}) || v1.exp2 != (ValueEvaluable{IntValue{2}}) {
   253  			t.Fatalf("Bad result: %s / error: %s", v, e)
   254  		}
   255  
   256  		ev, ee := v.Evaluate(ge)
   257  		if ee != nil || ev != (StringValue{"hoge2"}) {
   258  			t.Fatalf("Bad evaluate result %d / error: %s", ev, ee)
   259  		}
   260  	}
   261  }
   262  
   263  func TestParseAsFactor1(t *testing.T) {
   264  	checkFactor1Level(t, ParseAsFactor1)
   265  	if v, e := ParseAsFactor1(createInitializedTokenizer("<")); e == nil || v != nil || e != errUnmatched {
   266  		t.Fatalf("Bad result: %s / error: %s", v, e)
   267  	}
   268  }
   269  
   270  func checkFactor0Level(t *testing.T, p parser) {
   271  	checkFactor1Level(t, p)
   272  
   273  	ge := createTestGlobalEnvironment()
   274  
   275  	{
   276  		if gv, gerr := ge.Value("hoge"); gerr != nil || gv != (StringValue{"hoge"}) {
   277  			t.Fatalf("Bad assigned value %s / error: %s", gv, gerr)
   278  		}
   279  
   280  		v, e := p(createInitializedTokenizer("hoge = 2"))
   281  		if e != nil {
   282  			t.Fatalf("Bad result: %s / error: %s", v, e)
   283  		}
   284  
   285  		v1, ok := v.(*AssignExpression)
   286  		if !ok {
   287  			t.Fatalf("Bad result: %s / error: %s", v, e)
   288  		}
   289  
   290  		left, ok := v1.variable.(*Variable)
   291  		if !ok {
   292  			t.Fatalf("Bad result: %s / error: %s", v, e)
   293  		}
   294  		if left.Name != "hoge" || v1.exp != (ValueEvaluable{IntValue{2}}) {
   295  			t.Fatalf("Bad result: %s / error: %s", v, e)
   296  		}
   297  
   298  		if ev, ee := v.Evaluate(ge); ev != (IntValue{2}) {
   299  			t.Fatalf("Bad result: %s / error: %s", ev, ee)
   300  		}
   301  
   302  		if gv, gerr := ge.Value("hoge"); gerr != nil || gv != (IntValue{2}) {
   303  			t.Fatalf("Bad assigned value %s / error: %s", gv, gerr)
   304  		}
   305  	}
   306  }
   307  
   308  func TestParseAsFactor0(t *testing.T) {
   309  	checkFactor0Level(t, ParseAsFactor0)
   310  }
   311  
   312  func checkExpLevel(t *testing.T, p parser) {
   313  	checkFactor0Level(t, p)
   314  
   315  	ge := createTestGlobalEnvironment()
   316  
   317  	{
   318  		v, e := p(createInitializedTokenizer("1; 3"))
   319  		if e != nil {
   320  			t.Fatalf("Failed to parse: %s / error: %s", v, e)
   321  		}
   322  
   323  		vj, ok := v.(*JoinedExpression)
   324  		if !ok || vj.exp1 != (ValueEvaluable{IntValue{1}}) || vj.exp2 != (ValueEvaluable{IntValue{3}}) {
   325  			t.Fatalf("Failed to parse: %s / error: %s", v, e)
   326  		}
   327  
   328  		if ev, ee := v.Evaluate(ge); ee != nil || ev != (IntValue{3}) {
   329  			t.Fatalf("Bad evaluated value: %s / error: %s", ev, ee)
   330  		}
   331  	}
   332  
   333  	{
   334  		v, e := p(createInitializedTokenizer("1; 3; 4"))
   335  		if e != nil {
   336  			t.Fatalf("Failed to parse: %s / error: %s", v, e)
   337  		}
   338  
   339  		vj, ok := v.(*JoinedExpression)
   340  		if !ok || vj.exp1 != (ValueEvaluable{IntValue{1}}) {
   341  			t.Fatalf("Failed to parse: %s / error: %s", v, e)
   342  		}
   343  		vj2, ok2 := vj.exp2.(*JoinedExpression)
   344  		if !ok2 || vj2.exp1 != (ValueEvaluable{IntValue{3}}) || vj2.exp2 != (ValueEvaluable{IntValue{4}}) {
   345  			t.Fatalf("Failed to parse: %s / error: %s", v, e)
   346  		}
   347  
   348  		if ev, ee := v.Evaluate(ge); ee != nil || ev != (IntValue{4}) {
   349  			t.Fatalf("Bad evaluated value: %s / error: %s", ev, ee)
   350  		}
   351  	}
   352  }
   353  
   354  func TestParseAsExp(t *testing.T) {
   355  	checkExpLevel(t, ParseAsExp)
   356  
   357  	ge := createTestGlobalEnvironment()
   358  
   359  	{
   360  		v, e := ParseAsExp(createInitializedTokenizer("1 + 3 * 2"))
   361  		if e != nil {
   362  			t.Fatalf("Failed to parse: %s / error: %s", v, e)
   363  		}
   364  
   365  		vj1, ok := v.(*PlusExpression)
   366  		if !ok || vj1.exp1 != (ValueEvaluable{IntValue{1}}) {
   367  			t.Fatalf("Failed to parse: %s / error: %s", v, e)
   368  		}
   369  
   370  		vj2, ok := vj1.exp2.(*NumericOperationExpression)
   371  		if !ok || vj2.exp1 != (ValueEvaluable{IntValue{3}}) || vj2.exp2 != (ValueEvaluable{IntValue{2}}) || vj2.operator != "*" {
   372  			t.Fatalf("Failed to parse: %s / error: %s", v, e)
   373  		}
   374  
   375  		if ev, ee := v.Evaluate(ge); ee != nil || ev != (IntValue{7}) {
   376  			t.Fatalf("Bad evaluated value: %s / error: %s", ev, ee)
   377  		}
   378  
   379  	}
   380  
   381  	{
   382  		v, e := ParseAsExp(createInitializedTokenizer("1 + (3 * 2)"))
   383  		if e != nil {
   384  			t.Fatalf("Failed to parse: %s / error: %s", v, e)
   385  		}
   386  
   387  		vj1, ok := v.(*PlusExpression)
   388  		if !ok || vj1.exp1 != (ValueEvaluable{IntValue{1}}) {
   389  			t.Fatalf("Failed to parse: %s / error: %s", v, e)
   390  		}
   391  
   392  		vj2, ok := vj1.exp2.(*NumericOperationExpression)
   393  		if !ok || vj2.exp1 != (ValueEvaluable{IntValue{3}}) || vj2.exp2 != (ValueEvaluable{IntValue{2}}) || vj2.operator != "*" {
   394  			t.Fatalf("Failed to parse: %s / error: %s", v, e)
   395  		}
   396  
   397  		if ev, ee := v.Evaluate(ge); ee != nil || ev != (IntValue{7}) {
   398  			t.Fatalf("Bad evaluated value: %s / error: %s", ev, ee)
   399  		}
   400  
   401  	}
   402  
   403  	{
   404  		v, e := ParseAsExp(createInitializedTokenizer("(1 + 3) * 2"))
   405  		if e != nil {
   406  			t.Fatalf("Failed to parse: %s / error: %s", v, e)
   407  		}
   408  
   409  		vj1, ok := v.(*NumericOperationExpression)
   410  
   411  		if !ok || vj1.exp2 != (ValueEvaluable{IntValue{2}}) {
   412  			t.Fatalf("Failed to parse: %s / error: %s", v, e)
   413  		}
   414  
   415  		vj2, ok := vj1.exp1.(*PlusExpression)
   416  		if !ok || vj2.exp1 != (ValueEvaluable{IntValue{1}}) || vj2.exp2 != (ValueEvaluable{IntValue{3}}) {
   417  			t.Fatalf("Failed to parse: %s / error: %s", v, e)
   418  		}
   419  
   420  		if ev, ee := v.Evaluate(ge); ee != nil || ev != (IntValue{8}) {
   421  			t.Fatalf("Bad evaluated value: %s / error: %s", ev, ee)
   422  		}
   423  
   424  	}
   425  
   426  	{
   427  		v, e := ParseAsExp(createInitializedTokenizer("1 + 3 + 2"))
   428  		if e != nil {
   429  			t.Fatalf("Failed to parse: %s / error: %s", v, e)
   430  		}
   431  
   432  		vj1, ok := v.(*PlusExpression)
   433  
   434  		if !ok || vj1.exp1 != (ValueEvaluable{IntValue{1}}) {
   435  			t.Fatalf("Failed to parse: %s / error: %s", v, e)
   436  		}
   437  
   438  		vj2, ok := vj1.exp2.(*PlusExpression)
   439  		if !ok || vj2.exp1 != (ValueEvaluable{IntValue{3}}) || vj2.exp2 != (ValueEvaluable{IntValue{2}}) {
   440  			t.Fatalf("Failed to parse: %s / error: %s", v, e)
   441  		}
   442  
   443  		if ev, ee := v.Evaluate(ge); ee != nil || ev != (IntValue{6}) {
   444  			t.Fatalf("Bad evaluated value: %s / error: %s", ev, ee)
   445  		}
   446  
   447  	}
   448  
   449  	{
   450  		v, e := ParseAsExp(createInitializedTokenizer("4 * 8 / 2"))
   451  		if e != nil {
   452  			t.Fatalf("Failed to parse: %s / error: %s", v, e)
   453  		}
   454  
   455  		vj1, ok := v.(*NumericOperationExpression)
   456  
   457  		if !ok || vj1.exp1 != (ValueEvaluable{IntValue{4}}) || vj1.operator != "*" {
   458  			t.Fatalf("Failed to parse: %s / error: %s", v, e)
   459  		}
   460  
   461  		vj2, ok := vj1.exp2.(*NumericOperationExpression)
   462  		if !ok || vj2.exp1 != (ValueEvaluable{IntValue{8}}) || vj2.exp2 != (ValueEvaluable{IntValue{2}}) || vj2.operator != "/" {
   463  			t.Fatalf("Failed to parse: %s / error: %s", v, e)
   464  		}
   465  
   466  		if ev, ee := v.Evaluate(ge); ee != nil || ev != (IntValue{16}) {
   467  			t.Fatalf("Bad evaluated value: %s / error: %s", ev, ee)
   468  		}
   469  
   470  	}
   471  
   472  	{
   473  		v, e := ParseAsExp(createInitializedTokenizer("(1"))
   474  		if e == nil || v != nil || !strings.HasPrefix(e.Error(), "syntax error: ) is not found") {
   475  			t.Fatalf("Failed to parse: %s / error: %s", v, e)
   476  		}
   477  	}
   478  }
   479  
   480  func checkArrayAccessLevel(t *testing.T, p parser) {
   481  	checkArrayLevel(t, p)
   482  
   483  	ge := createTestGlobalEnvironment()
   484  	{
   485  		tokenizer := createInitializedTokenizer("foo[hoge];")
   486  		v, e := p(tokenizer)
   487  		if e != nil {
   488  			t.Fatalf("Failed to parse %s / error: %s", v, e)
   489  		}
   490  		if tokenizer.Text() != ";" {
   491  			t.Fatalf("bad tokenizer position: %s", tokenizer.Text())
   492  		}
   493  
   494  		arrayAccess, ok := v.(*ArrayAccess)
   495  		if !ok {
   496  			t.Fatalf("Bad parse result: %s", v)
   497  		}
   498  
   499  		if array, ok := arrayAccess.Array.(*Variable); !ok || array.Name != "foo" {
   500  			t.Fatalf("Bad parse result: %s", v)
   501  		}
   502  
   503  		if arrayIndex, ok := arrayAccess.ArrayIndex.(*Variable); !ok || arrayIndex.Name != "hoge" {
   504  			t.Fatalf("Bad parse result: %s", v)
   505  		}
   506  	}
   507  
   508  	{
   509  		v, e := p(createInitializedTokenizer("[1,2,3,4][2]"))
   510  		if e != nil {
   511  			t.Fatalf("Failed to parse %s / error: %s", v, e)
   512  		}
   513  		arrayAccess, ok := v.(*ArrayAccess)
   514  		if !ok {
   515  			t.Fatalf("Bad parse result: %s", v)
   516  		}
   517  
   518  		// TODO: fix here
   519  		expected := [...]Value{IntValue{1}, IntValue{2}, IntValue{3}, IntValue{4}}
   520  
   521  		if array, ok := arrayAccess.Array.(*ArrayExpression); !ok || reflect.DeepEqual(array.values, expected) {
   522  			t.Fatalf("Bad parse result: %s", v)
   523  		}
   524  
   525  		arrayIndexEvauable, ok := arrayAccess.ArrayIndex.(ValueEvaluable)
   526  		if !ok {
   527  			t.Fatalf("Bad parse result: %s", v)
   528  		}
   529  
   530  		if arrayIndex, ok := arrayIndexEvauable.value.(IntValue); !ok || arrayIndex != (IntValue{2}) {
   531  			t.Fatalf("Bad parse result: %s", v)
   532  		}
   533  
   534  		if ev, ee := v.Evaluate(ge); ee != nil || ev != (IntValue{3}) {
   535  			t.Fatalf("Bad evaluation result: %s / error: %s", ev, ee)
   536  		}
   537  	}
   538  
   539  	{
   540  		v, e := p(createInitializedTokenizer("foo[10][20]"))
   541  		if e != nil {
   542  			t.Fatalf("Failed to parse %s / error: %s", v, e)
   543  		}
   544  		arrayAccess1, ok := v.(*ArrayAccess)
   545  		if !ok {
   546  			t.Fatalf("Bad parse result: %s", v)
   547  		}
   548  
   549  		arrayAccess2, ok := arrayAccess1.Array.(*ArrayAccess)
   550  		if !ok {
   551  			t.Fatalf("Bad parse result: %s", v)
   552  		}
   553  
   554  		if array, ok := arrayAccess2.Array.(*Variable); !ok || array.Name != "foo" {
   555  			t.Fatalf("Bad parse result: %s", v)
   556  		}
   557  
   558  		if arrayIndex, ok := arrayAccess2.ArrayIndex.(ValueEvaluable); !ok || arrayIndex.value != (IntValue{10}) {
   559  			t.Fatalf("Bad parse result: %s", v)
   560  		}
   561  
   562  		if arrayIndex, ok := arrayAccess1.ArrayIndex.(ValueEvaluable); !ok || arrayIndex.value != (IntValue{20}) {
   563  			t.Fatalf("Bad parse result: %s", v)
   564  		}
   565  	}
   566  
   567  	{
   568  		v, e := p(createInitializedTokenizer("[]"))
   569  		if e != nil {
   570  			t.Fatalf("Failed to parse %s / error: %s", v, e)
   571  		}
   572  		arrayAccess1, ok := v.(*ArrayExpression)
   573  		if !ok {
   574  			t.Fatalf("Bad parse result: %s", v)
   575  		}
   576  		if len(arrayAccess1.values) != 0 {
   577  			t.Fatalf("Bad parse result: %s", v)
   578  		}
   579  	}
   580  
   581  	{
   582  		v, e := p(createInitializedTokenizer("[ 1 ,   2 ,3  ] "))
   583  		if e != nil {
   584  			t.Fatalf("Failed to parse %s / error: %s", v, e)
   585  		}
   586  		arrayAccess1, ok := v.(*ArrayExpression)
   587  		if !ok {
   588  			t.Fatalf("Bad parse result: %s", v)
   589  		}
   590  		if len(arrayAccess1.values) != 3 {
   591  			t.Fatalf("Bad parse result: %s", v)
   592  		}
   593  		if av, ok := arrayAccess1.values[0].(ValueEvaluable); !ok || av.value != (IntValue{1}) {
   594  			t.Fatalf("Bad parse result: %s", v)
   595  		}
   596  		if av, ok := arrayAccess1.values[1].(ValueEvaluable); !ok || av.value != (IntValue{2}) {
   597  			t.Fatalf("Bad parse result: %s", v)
   598  		}
   599  		if av, ok := arrayAccess1.values[2].(ValueEvaluable); !ok || av.value != (IntValue{3}) {
   600  			t.Fatalf("Bad parse result: %s", v)
   601  		}
   602  	}
   603  
   604  	{
   605  		v, e := p(createInitializedTokenizer("foo[hoge)"))
   606  		if e == nil || !strings.HasPrefix(e.Error(), "syntax error") {
   607  			t.Fatalf("Failed to parse %s / error: %s", v, e)
   608  		}
   609  	}
   610  
   611  	{
   612  		v, e := p(createInitializedTokenizer("foo[(1])"))
   613  		if e == nil || !strings.HasPrefix(e.Error(), "syntax error") {
   614  			t.Fatalf("Failed to parse %s / error: %s", v, e)
   615  		}
   616  	}
   617  
   618  	{
   619  		v, e := p(createInitializedTokenizer("foo[!)"))
   620  		if e == nil || !strings.HasPrefix(e.Error(), "syntax error") {
   621  			t.Fatalf("Failed to parse %s / error: %s", v, e)
   622  		}
   623  	}
   624  }
   625  
   626  func TestParseAsArrayAccess(t *testing.T) {
   627  	checkArrayAccessLevel(t, ParseAsArrayAccessOrArray)
   628  
   629  	{
   630  		v, e := ParseAsArrayAccessOrArray(createInitializedTokenizer("10"))
   631  		if e != errUnmatched {
   632  			t.Fatalf("Failed to parse %s / error: %s", v, e)
   633  		}
   634  	}
   635  
   636  	{
   637  		v, e := ParseAsArrayAccessOrArray(createInitializedTokenizer("hoge + 10"))
   638  		if e != errUnmatched {
   639  			t.Fatalf("Failed to parse %s / error: %s", v, e)
   640  		}
   641  	}
   642  }
   643  
   644  func checkArrayLevel(t *testing.T, p parser) {
   645  	{
   646  		v, e := p(createInitializedTokenizer("[1,hoge,3]"))
   647  		if e != nil {
   648  			t.Fatalf("Failed to parse %s / error: %s", v, e)
   649  		}
   650  		arrayAccess, ok := v.(*ArrayExpression)
   651  		if !ok {
   652  			t.Fatalf("Bad parse result: %s", v)
   653  		}
   654  
   655  		if len(arrayAccess.values) != 3 {
   656  			t.Fatalf("Bad parse result: %s", v)
   657  		}
   658  
   659  		if arrayAccess.values[0] != (ValueEvaluable{IntValue{1}}) {
   660  			t.Fatalf("Bad parse result: %s", v)
   661  		}
   662  
   663  		if v, ok := arrayAccess.values[1].(*Variable); !ok || v.Name != "hoge" {
   664  			t.Fatalf("Bad parse result: %s", v)
   665  		}
   666  
   667  		if arrayAccess.values[2] != (ValueEvaluable{IntValue{3}}) {
   668  			t.Fatalf("Bad parse result: %s", v)
   669  		}
   670  	}
   671  
   672  	{
   673  		v, e := p(createInitializedTokenizer("[1]"))
   674  		if e != nil {
   675  			t.Fatalf("Failed to parse %s / error: %s", v, e)
   676  		}
   677  		arrayAccess, ok := v.(*ArrayExpression)
   678  		if !ok {
   679  			t.Fatalf("Bad parse result: %s", v)
   680  		}
   681  
   682  		if len(arrayAccess.values) != 1 {
   683  			t.Fatalf("Bad parse result: %s", v)
   684  		}
   685  
   686  		if arrayAccess.values[0] != (ValueEvaluable{IntValue{1}}) {
   687  			t.Fatalf("Bad parse result: %s", v)
   688  		}
   689  	}
   690  
   691  	{
   692  		v, e := p(createInitializedTokenizer("[]"))
   693  		if e != nil {
   694  			t.Fatalf("Failed to parse %s / error: %s", v, e)
   695  		}
   696  		arrayAccess, ok := v.(*ArrayExpression)
   697  		if !ok {
   698  			t.Fatalf("Bad parse result: %s", v)
   699  		}
   700  
   701  		if len(arrayAccess.values) != 0 {
   702  			t.Fatalf("Bad parse result: %s", v)
   703  		}
   704  	}
   705  
   706  	{
   707  		v, e := p(createInitializedTokenizer("[1)"))
   708  		if e == nil || !strings.HasPrefix(e.Error(), "syntax error") {
   709  			t.Fatalf("Failed to parse %s / error: %s", v, e)
   710  		}
   711  	}
   712  
   713  	{
   714  		v, e := p(createInitializedTokenizer("["))
   715  		if e == nil || !strings.HasPrefix(e.Error(), "syntax error") {
   716  			t.Fatalf("Failed to parse %s / error: %s", v, e)
   717  		}
   718  	}
   719  
   720  	{
   721  		v, e := p(createInitializedTokenizer("[(1])"))
   722  		if e == nil || !strings.HasPrefix(e.Error(), "syntax error") {
   723  			t.Fatalf("Failed to parse %s / error: %s", v, e)
   724  		}
   725  	}
   726  
   727  	{
   728  		v, e := p(createInitializedTokenizer("[#]"))
   729  		if e == nil || !strings.HasPrefix(e.Error(), "syntax error: no expression is found:") {
   730  			t.Fatalf("Failed to parse %s / error: %s", v, e)
   731  		}
   732  	}
   733  }
   734  
   735  func TestParseAsArray(t *testing.T) {
   736  	checkArrayLevel(t, ParseAsArray)
   737  }
   738  
   739  func checkFunctionCallParseLevel(t *testing.T, p parser) {
   740  	ge := createTestGlobalEnvironment()
   741  	{
   742  		tokenizer := createInitializedTokenizer("basename(\"hoge/foo\");")
   743  		v, e := p(tokenizer)
   744  		if e != nil {
   745  			t.Fatalf("Failed to parse %s / error: %s", v, e)
   746  		}
   747  		if tokenizer.Text() != ";" {
   748  			t.Fatalf("Wrong tokenizer position: %s", tokenizer.Text())
   749  		}
   750  		fv, ok := v.(*FunctionCall)
   751  		if !ok {
   752  			t.Fatalf("Failed to parse %s", v)
   753  		}
   754  
   755  		vv, ok := fv.function.(*Variable)
   756  		if !ok || vv.Name != "basename" {
   757  			t.Fatalf("Failed to parse %s", fv)
   758  		}
   759  
   760  		if len(fv.args) != 1 || fv.args[0] != (ValueEvaluable{StringValue{"hoge/foo"}}) {
   761  			t.Fatalf("Failed to parse %s", fv.args[0])
   762  		}
   763  
   764  		if ev, ee := v.Evaluate(ge); ee != nil || ev != (StringValue{"foo"}) {
   765  			t.Fatalf("Bad evaluate result: %s / error: %s", ev, ee)
   766  		}
   767  	}
   768  
   769  	{
   770  		tokenizer := createInitializedTokenizer("basename();")
   771  		v, e := p(tokenizer)
   772  		if e != nil {
   773  			t.Fatalf("Failed to parse %s / error: %s", v, e)
   774  		}
   775  		if tokenizer.Text() != ";" {
   776  			t.Fatalf("Wrong tokenizer position: %s", tokenizer.Text())
   777  		}
   778  		fv, ok := v.(*FunctionCall)
   779  		if !ok {
   780  			t.Fatalf("Failed to parse %s", v)
   781  		}
   782  
   783  		vv, ok := fv.function.(*Variable)
   784  		if !ok || vv.Name != "basename" {
   785  			t.Fatalf("Failed to parse %s", fv)
   786  		}
   787  
   788  		if len(fv.args) != 0 {
   789  			t.Fatalf("Failed to parse %s", fv)
   790  		}
   791  	}
   792  
   793  	{
   794  		tokenizer := createInitializedTokenizer("basename(\"hoge/foo.c\", \".c\");")
   795  		v, e := p(tokenizer)
   796  		if e != nil {
   797  			t.Fatalf("Failed to parse %s / error: %s", v, e)
   798  		}
   799  		if tokenizer.Text() != ";" {
   800  			t.Fatalf("Wrong tokenizer position: %s", tokenizer.Text())
   801  		}
   802  		fv, ok := v.(*FunctionCall)
   803  		if !ok {
   804  			t.Fatalf("Failed to parse %s", v)
   805  		}
   806  
   807  		vv, ok := fv.function.(*Variable)
   808  		if !ok || vv.Name != "basename" {
   809  			t.Fatalf("Failed to parse %s", fv)
   810  		}
   811  
   812  		if len(fv.args) != 2 || fv.args[0] != (ValueEvaluable{StringValue{"hoge/foo.c"}}) || fv.args[1] != (ValueEvaluable{StringValue{".c"}}) {
   813  			t.Fatalf("Failed to parse %s", fv)
   814  		}
   815  
   816  		if ev, ee := v.Evaluate(ge); ee != nil || ev != (StringValue{"foo"}) {
   817  			t.Fatalf("Bad evaluate result: %s / error: %s", ev, ee)
   818  		}
   819  	}
   820  
   821  	{
   822  		tokenizer := createInitializedTokenizer("basename(\"hoge/foo.c\", \".c\"]")
   823  		v, e := p(tokenizer)
   824  		if e == nil || !strings.HasPrefix(e.Error(), "syntax error") {
   825  			t.Fatalf("Failed to parse %s / error: %s", v, e)
   826  		}
   827  	}
   828  
   829  	{
   830  		tokenizer := createInitializedTokenizer("basename(]")
   831  		v, e := p(tokenizer)
   832  		if e == nil || !strings.HasPrefix(e.Error(), "syntax error") {
   833  			t.Fatalf("Failed to parse %s / error: %s", v, e)
   834  		}
   835  	}
   836  
   837  	{
   838  		tokenizer := createInitializedTokenizer("basename((12])")
   839  		v, e := p(tokenizer)
   840  		if e == nil || !strings.HasPrefix(e.Error(), "syntax error") {
   841  			t.Fatalf("Failed to parse %s / error: %s", v, e)
   842  		}
   843  	}
   844  }
   845  
   846  func TestFunctionCallParse(t *testing.T) {
   847  	checkFunctionCallParseLevel(t, ParseAsFunctionCall)
   848  
   849  	{
   850  		tokenizer := createInitializedTokenizer("123(\"hoge/foo.c\", \".c\");")
   851  		v, e := ParseAsFunctionCall(tokenizer)
   852  		if e != errUnmatched {
   853  			t.Fatalf("Failed to parse %s / error: %s", v, e)
   854  		}
   855  		if tokenizer.Text() != "123" {
   856  			t.Fatalf("Wrong tokenizer position: %s", tokenizer.Text())
   857  		}
   858  	}
   859  }