github.com/TIBCOSoftware/flogo-lib@v0.5.9/core/mapper/exprmapper/expression/expression_test.go (about)

     1  package expression
     2  
     3  import (
     4  	"encoding/json"
     5  	"fmt"
     6  	"testing"
     7  
     8  	"os"
     9  
    10  	"github.com/TIBCOSoftware/flogo-lib/core/data"
    11  	"github.com/stretchr/testify/assert"
    12  )
    13  
    14  func TestExpressionTernary(t *testing.T) {
    15  	v, err := ParseExpression(`1>2?string.concat("sss","ddddd"):"fff"`)
    16  	if err != nil {
    17  		t.Fatal(err)
    18  		t.Failed()
    19  	}
    20  	s, _ := json.Marshal(v)
    21  	fmt.Println("-------------------", string(s))
    22  	result, err := v.EvalWithScope(nil, nil)
    23  	if err != nil {
    24  		t.Fatal(err)
    25  		t.Failed()
    26  	}
    27  	assert.Equal(t, "fff", result)
    28  
    29  	fmt.Println("Result:", result)
    30  }
    31  
    32  func TestExpressionTernaryString(t *testing.T) {
    33  	v, err := ParseExpression(`1<2?"lixingwang":"fff"`)
    34  	if err != nil {
    35  		t.Fatal(err)
    36  		t.Failed()
    37  	}
    38  	result, err := v.EvalWithScope(nil, nil)
    39  	if err != nil {
    40  		t.Fatal(err)
    41  		t.Failed()
    42  	}
    43  	assert.Equal(t, "lixingwang", result)
    44  	fmt.Println("Result:", result)
    45  }
    46  
    47  func TestExpressionTernaryString3(t *testing.T) {
    48  	v, err := ParseExpression(`200>100?true:false`)
    49  	if err != nil {
    50  		t.Fatal(err)
    51  		t.Failed()
    52  	}
    53  	result, err := v.EvalWithScope(nil, nil)
    54  	if err != nil {
    55  		t.Fatal(err)
    56  		t.Failed()
    57  	}
    58  	assert.Equal(t, true, result)
    59  	fmt.Println("Result:", result)
    60  }
    61  
    62  func TestExpressionString(t *testing.T) {
    63  	v, err := ParseExpression(`$activity[C].result==3`)
    64  	if err != nil {
    65  		t.Fatal(err)
    66  		t.Failed()
    67  	}
    68  	r, err := v.EvalWithScope(nil, nil)
    69  	assert.Nil(t, err)
    70  	assert.Equal(t, false, r)
    71  }
    72  
    73  func TestExpressionWithOldWay(t *testing.T) {
    74  	v, err := ParseExpression(`1 + 2 * 3 + 2 * 6`)
    75  	if err != nil {
    76  		t.Fatal(err)
    77  		t.Failed()
    78  	}
    79  	s, _ := json.Marshal(v)
    80  	fmt.Println(string(s))
    81  	vv, err := v.EvalWithScope(nil, nil)
    82  	assert.Nil(t, err)
    83  	assert.Equal(t, 19, vv)
    84  }
    85  
    86  func TestTernaryExpressionWithNagtive(t *testing.T) {
    87  	v, err := ParseExpression(`$.content.ParamNb3 != nil ? $.content.ParamNb3 : -1`)
    88  	if err != nil {
    89  		t.Fatal(err)
    90  		t.Failed()
    91  	}
    92  	r, err := v.EvalWithScope(nil, nil)
    93  	assert.Nil(t, err)
    94  	assert.Equal(t, "$.content.ParamNb3", r)
    95  
    96  }
    97  
    98  func TestExpressionTernaryFunction(t *testing.T) {
    99  	v, err := ParseExpression(`string.length($TriggerData.queryParams.id) == 0 ? "Query Id cannot be null" : string.length($TriggerData.queryParams.id)`)
   100  	if err != nil {
   101  		t.Fatal(err)
   102  		t.Failed()
   103  	}
   104  	//a, _ := data.NewAttribute("queryParams", data.TypeComplexObject, &data.ComplexObject{Metadata: "", Value: `{"id":"lixingwang"}`})
   105  	//metadata := make(map[string]*data.Attribute)
   106  	//metadata["queryParams"] = a
   107  
   108  	//scope.SetAttrValue("queryParams", &data.ComplexObject{Metadata: "", Value: `{"id":"lixingwang"}`})
   109  	result, err := v.EvalWithScope(nil, nil)
   110  	if err != nil {
   111  		t.Fatal(err)
   112  		t.Failed()
   113  	}
   114  	vv, _ := json.Marshal(result)
   115  	//assert.Equal(t, "lixingwang", result)
   116  	fmt.Println("Result:", string(vv))
   117  }
   118  
   119  func TestExpressionTernaryRef(t *testing.T) {
   120  	os.Setenv("name", "flogo")
   121  	os.Setenv("address", "tibco")
   122  
   123  	v, err := ParseExpression(`string.length("lixingwang")>11?$env.name:$env.address`)
   124  	if err != nil {
   125  		t.Fatal(err)
   126  		t.Failed()
   127  	}
   128  
   129  	result, err := v.EvalWithScope(data.NewFixedScope(nil), data.GetBasicResolver())
   130  	if err != nil {
   131  		t.Fatal(err)
   132  		t.Failed()
   133  	}
   134  
   135  	assert.Equal(t, "tibco", result)
   136  
   137  	fmt.Println("Result:", result)
   138  }
   139  
   140  func TestExpressionTernaryRef2(t *testing.T) {
   141  	v, err := ParseExpression(`string.length("lixingwang")>11?"lixingwang":"fff"`)
   142  	if err != nil {
   143  		t.Fatal(err)
   144  		t.Failed()
   145  	}
   146  	s, _ := json.Marshal(v)
   147  	fmt.Println("-------------------", string(s))
   148  	result, err := v.EvalWithScope(nil, nil)
   149  	if err != nil {
   150  		t.Fatal(err)
   151  		t.Failed()
   152  	}
   153  	assert.Equal(t, "fff", result)
   154  
   155  	fmt.Println("Result:", result)
   156  }
   157  
   158  func TestWeExpr_LinkMapping(t *testing.T) {
   159  	expr, err := ParseExpression(`$T.parameters.path_params[0].value==2`)
   160  	if err != nil {
   161  		t.Fatal(err)
   162  		t.Failed()
   163  	}
   164  	fmt.Println("Result:", expr)
   165  }
   166  
   167  func TestWeExpr_LinkMapping2(t *testing.T) {
   168  	v, err := ParseExpression(`$T.parameters==2`)
   169  	if err != nil {
   170  		t.Fatal(err)
   171  		t.Failed()
   172  	}
   173  	fmt.Println("Result:", v)
   174  }
   175  
   176  func TestExpressionInt(t *testing.T) {
   177  	expr, err := ParseExpression(`123==456`)
   178  	if err != nil {
   179  		t.Fatal(err)
   180  		t.Failed()
   181  	}
   182  	v, err := expr.Eval()
   183  	if err != nil {
   184  		t.Fatal(err)
   185  		t.Failed()
   186  	}
   187  	assert.Equal(t, false, v)
   188  
   189  	fmt.Println("Result:", v)
   190  }
   191  
   192  func TestExpressionEQ(t *testing.T) {
   193  	expr, err := ParseExpression(`123==123`)
   194  	if err != nil {
   195  		t.Fatal(err)
   196  		t.Failed()
   197  	}
   198  	v, err := expr.Eval()
   199  	if err != nil {
   200  		t.Fatal(err)
   201  		t.Failed()
   202  	}
   203  	assert.Equal(t, true, v)
   204  
   205  	fmt.Println("Result:", v)
   206  }
   207  
   208  func TestExpressionEQFunction(t *testing.T) {
   209  	expr, err := ParseExpression(`string.concat("123","456")=="123456"`)
   210  	if err != nil {
   211  		t.Fatal(err)
   212  		t.Failed()
   213  	}
   214  	v, err := expr.Eval()
   215  	if err != nil {
   216  		t.Fatal(err)
   217  		t.Failed()
   218  	}
   219  	assert.Equal(t, true, v)
   220  	fmt.Println("Result:", v)
   221  }
   222  
   223  func TestExpressionEQFunction2Side(t *testing.T) {
   224  	e, err := ParseExpression(`string.concat("123","456") == string.concat("12","3456")`)
   225  	if err != nil {
   226  		t.Fatal(err)
   227  		t.Failed()
   228  	}
   229  	v, err := e.Eval()
   230  	if err != nil {
   231  		t.Fatal(err)
   232  		t.Failed()
   233  	}
   234  	assert.Equal(t, true, v)
   235  	fmt.Println("Result:", v)
   236  }
   237  
   238  func TestExpressionRef(t *testing.T) {
   239  	_, err := ParseExpression(`$A4.query.name=="name"`)
   240  	assert.Nil(t, err)
   241  }
   242  
   243  func TestExpressionFunction(t *testing.T) {
   244  	e, err := ParseExpression(`string.concat("tibco","software")=="tibcosoftware"`)
   245  	if err != nil {
   246  		t.Fatal(err)
   247  		t.Failed()
   248  	}
   249  	v, err := e.Eval()
   250  	if err != nil {
   251  		t.Fatal(err)
   252  		t.Failed()
   253  	}
   254  	assert.Equal(t, true, v)
   255  
   256  	fmt.Println("Result:", v)
   257  }
   258  
   259  func TestExpressionAnd(t *testing.T) {
   260  	e, err := ParseExpression(`("dddddd" == "dddd3dd") && ("133" == "123")`)
   261  	if err != nil {
   262  		t.Fatal(err)
   263  		t.Failed()
   264  	}
   265  	v, err := e.Eval()
   266  	if err != nil {
   267  		t.Fatal(err)
   268  		t.Failed()
   269  	}
   270  	assert.Equal(t, false, v)
   271  	fmt.Println("Result:", v)
   272  }
   273  
   274  func TestExpressionOr(t *testing.T) {
   275  	e, err := ParseExpression(`("dddddd" == "dddddd") && ("123" == "123")`)
   276  	if err != nil {
   277  		t.Fatal(err)
   278  		t.Failed()
   279  	}
   280  	v, err := e.Eval()
   281  	if err != nil {
   282  		t.Fatal(err)
   283  		t.Failed()
   284  	}
   285  	assert.Equal(t, true, v)
   286  	fmt.Println("Result:", v)
   287  }
   288  
   289  func TestFunc(t *testing.T) {
   290  	e, err := ParseExpression(`string.length("lixingwang") == 10`)
   291  	if err != nil {
   292  		t.Fatal(err)
   293  		t.Failed()
   294  	}
   295  	v, err := e.Eval()
   296  	if err != nil {
   297  		t.Fatal(err)
   298  		t.Failed()
   299  	}
   300  	fmt.Println("Result:", v)
   301  	assert.Equal(t, v, true)
   302  }
   303  
   304  func TestExpressionGT(t *testing.T) {
   305  	e, err := ParseExpression(`string.length("lixingwang") > 10`)
   306  	if err != nil {
   307  		t.Fatal(err)
   308  		t.Failed()
   309  	}
   310  	v, err := e.Eval()
   311  	if err != nil {
   312  		t.Fatal(err)
   313  		t.Failed()
   314  	}
   315  	fmt.Println("Result:", v)
   316  	assert.Equal(t, v, false)
   317  
   318  	e, err = ParseExpression(`string.length("lixingwang") >= 10`)
   319  	if err != nil {
   320  		t.Fatal(err)
   321  		t.Failed()
   322  	}
   323  	v, err = e.Eval()
   324  	if err != nil {
   325  		t.Fatal(err)
   326  		t.Failed()
   327  	}
   328  	fmt.Println("Result:", v)
   329  	assert.Equal(t, v, true)
   330  
   331  	e, err = ParseExpression(`string.length("lixingwang") < 10`)
   332  	if err != nil {
   333  		t.Fatal(err)
   334  		t.Failed()
   335  	}
   336  	v, err = e.Eval()
   337  	if err != nil {
   338  		t.Fatal(err)
   339  		t.Failed()
   340  	}
   341  	fmt.Println("Result:", v)
   342  	assert.Equal(t, v, false)
   343  
   344  	e, err = ParseExpression(`string.length("lixingwang") <= 10`)
   345  	if err != nil {
   346  		t.Fatal(err)
   347  		t.Failed()
   348  	}
   349  	v, err = e.Eval()
   350  	if err != nil {
   351  		t.Fatal(err)
   352  		t.Failed()
   353  	}
   354  	fmt.Println("Result:", v)
   355  	assert.Equal(t, v, true)
   356  
   357  }
   358  
   359  func TestIsExpression(t *testing.T) {
   360  	b := IsExpression(`string.length("lixingwang") <= 10`)
   361  	assert.True(t, b)
   362  
   363  	b = IsExpression(`1>2?string.concat("sss","ddddd"):"fff"`)
   364  	assert.True(t, b)
   365  
   366  	b = IsExpression(`string.length("lixingwang")>11?"lixingwang":"fff"`)
   367  	assert.True(t, b)
   368  
   369  	b = IsExpression(`string.length("lixingwang")`)
   370  	assert.True(t, b)
   371  
   372  	b = IsExpression(`$A3.name.fields`)
   373  	assert.True(t, b)
   374  
   375  }
   376  
   377  func TestIsTernayExpression(t *testing.T) {
   378  	b := IsExpression(`len("lixingwang") <= 10`)
   379  	assert.True(t, b)
   380  
   381  	b = IsExpression(`1>2?concat("sss","ddddd"):"fff"`)
   382  	assert.True(t, b)
   383  
   384  	b = IsExpression(`Len("lixingwang")>11?"lixingwang":"fff"`)
   385  	assert.True(t, b)
   386  
   387  	b = IsExpression(`len("lixingwang")`)
   388  	assert.True(t, b)
   389  
   390  	b = IsExpression(`$A3.name.fields`)
   391  	assert.True(t, b)
   392  
   393  }
   394  
   395  func TestIsFunction(t *testing.T) {
   396  	b := IsExpression(`len("lixingwang") <= 10`)
   397  	assert.True(t, b)
   398  
   399  	b = IsExpression(`1>2?concat("sss","ddddd"):"fff"`)
   400  	assert.True(t, b)
   401  
   402  	b = IsExpression(`Len("lixingwang")>11?"lixingwang":"fff"`)
   403  	assert.True(t, b)
   404  
   405  	b = IsExpression(`len("lixingwang")`)
   406  	assert.True(t, b)
   407  
   408  	b = IsExpression(`$A3.name.fields`)
   409  	assert.True(t, b)
   410  }
   411  
   412  func TestNewExpressionBoolean(t *testing.T) {
   413  	e, err := ParseExpression(`(string.length("sea") == 3) == true`)
   414  	if err != nil {
   415  		t.Fatal(err)
   416  		t.Failed()
   417  	}
   418  	v, err := e.Eval()
   419  	if err != nil {
   420  		t.Fatal(err)
   421  		t.Failed()
   422  	}
   423  	assert.Equal(t, true, v)
   424  	fmt.Println("Result:", v)
   425  }
   426  
   427  func TestExpressionWithNest(t *testing.T) {
   428  	//Invalid
   429  	e, err := ParseExpression(`(1&&1)==(1&&1)`)
   430  	if err != nil {
   431  		t.Fatal(err)
   432  		t.Failed()
   433  	}
   434  	v, err := e.Eval()
   435  	assert.NotNil(t, err)
   436  
   437  	//valid case
   438  	e, err = ParseExpression(`(true && true) == false`)
   439  	if err != nil {
   440  		t.Fatal(err)
   441  		t.Failed()
   442  	}
   443  	v, err = e.Eval()
   444  	if err != nil {
   445  		t.Fatal(err)
   446  		t.Failed()
   447  	}
   448  	assert.Equal(t, false, v)
   449  }
   450  
   451  func TestExpressionWithNILLiteral(t *testing.T) {
   452  	//valid case
   453  	e, err := ParseExpression(`(true && true) != nil`)
   454  	if err != nil {
   455  		t.Fatal(err)
   456  		t.Failed()
   457  	}
   458  	v, err := e.Eval()
   459  	if err != nil {
   460  		t.Fatal(err)
   461  		t.Failed()
   462  	}
   463  	assert.Equal(t, true, v)
   464  
   465  	e, err = ParseExpression(`123 != nil`)
   466  	if err != nil {
   467  		t.Fatal(err)
   468  		t.Failed()
   469  	}
   470  	v, err = e.Eval()
   471  	if err != nil {
   472  		t.Fatal(err)
   473  		t.Failed()
   474  	}
   475  	assert.Equal(t, true, v)
   476  
   477  	e, err = ParseExpression(`nil == nil`)
   478  	if err != nil {
   479  		t.Fatal(err)
   480  		t.Failed()
   481  	}
   482  	v, err = e.Eval()
   483  	if err != nil {
   484  		t.Fatal(err)
   485  		t.Failed()
   486  	}
   487  	assert.Equal(t, true, v)
   488  }
   489  func TestExpressionWithNIL(t *testing.T) {
   490  	os.Setenv("name", "test")
   491  	defer func() {
   492  		os.Unsetenv("name")
   493  	}()
   494  	scope := data.NewFixedScope(nil)
   495  	e, err := ParseExpression(`$env.name != nil`)
   496  	if err != nil {
   497  		t.Fatal(err)
   498  		t.Failed()
   499  	}
   500  	v, err := e.EvalWithScope(scope, data.GetBasicResolver())
   501  	if err != nil {
   502  		t.Fatal(err)
   503  		t.Failed()
   504  	}
   505  	assert.Equal(t, true, v)
   506  
   507  	e, err = ParseExpression(`$env.name == "test"`)
   508  	if err != nil {
   509  		t.Fatal(err)
   510  		t.Failed()
   511  	}
   512  	v, err = e.EvalWithScope(scope, data.GetBasicResolver())
   513  	if err != nil {
   514  		t.Fatal(err)
   515  		t.Failed()
   516  	}
   517  	assert.Equal(t, true, v)
   518  
   519  	e, err = ParseExpression(`$.name.test == nil`)
   520  	if err != nil {
   521  		t.Fatal(err)
   522  		t.Failed()
   523  	}
   524  
   525  	v, err = e.EvalWithScope(GetSimpleScope("name", "{}"), data.GetBasicResolver())
   526  	if err != nil {
   527  		t.Fatal(err)
   528  		t.Failed()
   529  	}
   530  	assert.Equal(t, true, v)
   531  
   532  	e, err = ParseExpression(`$.name.test != nil`)
   533  	if err != nil {
   534  		t.Fatal(err)
   535  		t.Failed()
   536  	}
   537  
   538  	v, err = e.EvalWithScope(GetSimpleScope("name", `{"test":"123"}`), data.GetBasicResolver())
   539  	if err != nil {
   540  		t.Fatal(err)
   541  		t.Failed()
   542  	}
   543  	assert.Equal(t, true, v)
   544  
   545  	e, err = ParseExpression(`$.name.test == "123"`)
   546  	if err != nil {
   547  		t.Fatal(err)
   548  		t.Failed()
   549  	}
   550  
   551  	v, err = e.EvalWithScope(GetSimpleScope("name", `{"test":"123"}`), data.GetBasicResolver())
   552  	if err != nil {
   553  		t.Fatal(err)
   554  		t.Failed()
   555  	}
   556  	assert.Equal(t, true, v)
   557  
   558  	d := `{"test":"test", "obj":{"id":123, "value":null}}`
   559  	testScope := GetSimpleScope("name", d)
   560  
   561  	e, err = ParseExpression(`$.name.test == "test"`)
   562  	if err != nil {
   563  		t.Fatal(err)
   564  		t.Failed()
   565  	}
   566  
   567  	v, err = e.EvalWithScope(testScope, data.GetBasicResolver())
   568  	if err != nil {
   569  		t.Fatal(err)
   570  		t.Failed()
   571  	}
   572  	assert.Equal(t, true, v)
   573  
   574  	e, err = ParseExpression(`$.name.obj.value == nil`)
   575  	if err != nil {
   576  		t.Fatal(err)
   577  		t.Failed()
   578  	}
   579  
   580  	v, err = e.EvalWithScope(testScope, data.GetBasicResolver())
   581  	if err != nil {
   582  		t.Fatal(err)
   583  		t.Failed()
   584  	}
   585  	assert.Equal(t, true, v)
   586  
   587  	e, err = ParseExpression(`$.name.obj.id == 123`)
   588  	if err != nil {
   589  		t.Fatal(err)
   590  		t.Failed()
   591  	}
   592  
   593  	v, err = e.EvalWithScope(testScope, data.GetBasicResolver())
   594  	if err != nil {
   595  		t.Fatal(err)
   596  		t.Failed()
   597  	}
   598  	assert.Equal(t, true, v)
   599  
   600  	e, err = ParseExpression(`$.name.obj.notexist == nil`)
   601  	if err != nil {
   602  		t.Fatal(err)
   603  		t.Failed()
   604  	}
   605  
   606  	v, err = e.EvalWithScope(testScope, data.GetBasicResolver())
   607  	if err != nil {
   608  		t.Fatal(err)
   609  		t.Failed()
   610  	}
   611  	assert.Equal(t, true, v)
   612  }
   613  
   614  func TestExpressionWithNULL(t *testing.T) {
   615  	os.Setenv("name", "test")
   616  	defer func() {
   617  		os.Unsetenv("name")
   618  	}()
   619  	scope := data.NewFixedScope(nil)
   620  	e, err := ParseExpression(`$env.name != null`)
   621  	if err != nil {
   622  		t.Fatal(err)
   623  		t.Failed()
   624  	}
   625  	v, err := e.EvalWithScope(scope, data.GetBasicResolver())
   626  	if err != nil {
   627  		t.Fatal(err)
   628  		t.Failed()
   629  	}
   630  	assert.Equal(t, true, v)
   631  
   632  	e, err = ParseExpression(`$env.name == "test"`)
   633  	if err != nil {
   634  		t.Fatal(err)
   635  		t.Failed()
   636  	}
   637  	v, err = e.EvalWithScope(scope, data.GetBasicResolver())
   638  	if err != nil {
   639  		t.Fatal(err)
   640  		t.Failed()
   641  	}
   642  	assert.Equal(t, true, v)
   643  
   644  	e, err = ParseExpression(`$.name.test == null`)
   645  	if err != nil {
   646  		t.Fatal(err)
   647  		t.Failed()
   648  	}
   649  
   650  	v, err = e.EvalWithScope(GetSimpleScope("name", "{}"), data.GetBasicResolver())
   651  	if err != nil {
   652  		t.Fatal(err)
   653  		t.Failed()
   654  	}
   655  	assert.Equal(t, true, v)
   656  
   657  	e, err = ParseExpression(`$.name.test != null`)
   658  	if err != nil {
   659  		t.Fatal(err)
   660  		t.Failed()
   661  	}
   662  
   663  	v, err = e.EvalWithScope(GetSimpleScope("name", `{"test":"123"}`), data.GetBasicResolver())
   664  	if err != nil {
   665  		t.Fatal(err)
   666  		t.Failed()
   667  	}
   668  	assert.Equal(t, true, v)
   669  
   670  	e, err = ParseExpression(`$.name.test == "123"`)
   671  	if err != nil {
   672  		t.Fatal(err)
   673  		t.Failed()
   674  	}
   675  
   676  	v, err = e.EvalWithScope(GetSimpleScope("name", `{"test":"123"}`), data.GetBasicResolver())
   677  	if err != nil {
   678  		t.Fatal(err)
   679  		t.Failed()
   680  	}
   681  	assert.Equal(t, true, v)
   682  
   683  	d := `{"test":"test", "obj":{"id":123, "value":null}}`
   684  	testScope := GetSimpleScope("name", d)
   685  
   686  	e, err = ParseExpression(`$.name.test == "test"`)
   687  	if err != nil {
   688  		t.Fatal(err)
   689  		t.Failed()
   690  	}
   691  
   692  	v, err = e.EvalWithScope(testScope, data.GetBasicResolver())
   693  	if err != nil {
   694  		t.Fatal(err)
   695  		t.Failed()
   696  	}
   697  	assert.Equal(t, true, v)
   698  
   699  	e, err = ParseExpression(`$.name.obj.value == null`)
   700  	if err != nil {
   701  		t.Fatal(err)
   702  		t.Failed()
   703  	}
   704  
   705  	v, err = e.EvalWithScope(testScope, data.GetBasicResolver())
   706  	if err != nil {
   707  		t.Fatal(err)
   708  		t.Failed()
   709  	}
   710  	assert.Equal(t, true, v)
   711  
   712  	e, err = ParseExpression(`$.name.obj.id == 123`)
   713  	if err != nil {
   714  		t.Fatal(err)
   715  		t.Failed()
   716  	}
   717  
   718  	v, err = e.EvalWithScope(testScope, data.GetBasicResolver())
   719  	if err != nil {
   720  		t.Fatal(err)
   721  		t.Failed()
   722  	}
   723  	assert.Equal(t, true, v)
   724  
   725  	e, err = ParseExpression(`$.name.obj.notexist == null`)
   726  	if err != nil {
   727  		t.Fatal(err)
   728  		t.Failed()
   729  	}
   730  
   731  	v, err = e.EvalWithScope(testScope, data.GetBasicResolver())
   732  	if err != nil {
   733  		t.Fatal(err)
   734  		t.Failed()
   735  	}
   736  	assert.Equal(t, true, v)
   737  }
   738  
   739  func TestExpressionWithNegtiveNumber(t *testing.T) {
   740  	e, err := ParseExpression(`-2 + 3`)
   741  	if err != nil {
   742  		t.Fatal(err)
   743  		t.Failed()
   744  	}
   745  	v, err := e.Eval()
   746  	assert.Nil(t, err)
   747  	assert.Equal(t, int(1), v)
   748  	//Negative float
   749  	e, err = ParseExpression(`-5.4 + -5.5`)
   750  	if err != nil {
   751  		t.Fatal(err)
   752  		t.Failed()
   753  	}
   754  	v, err = e.Eval()
   755  	assert.Nil(t, err)
   756  	assert.Equal(t, float64(-10.9), v)
   757  	//
   758  	e, err = ParseExpression(`(-2 + 3) + (-3344 + 4444)`)
   759  	if err != nil {
   760  		t.Fatal(err)
   761  		t.Failed()
   762  	}
   763  	v, err = e.Eval()
   764  	assert.Nil(t, err)
   765  	assert.Equal(t, int(1101), v)
   766  
   767  	e, err = ParseExpression(`3 > -2`)
   768  	if err != nil {
   769  		t.Fatal(err)
   770  		t.Failed()
   771  	}
   772  	v, err = e.Eval()
   773  	assert.Nil(t, err)
   774  	assert.Equal(t, true, v)
   775  
   776  	e, err = ParseExpression(`3 >= -2`)
   777  	if err != nil {
   778  		t.Fatal(err)
   779  		t.Failed()
   780  	}
   781  	v, err = e.Eval()
   782  	assert.Nil(t, err)
   783  	assert.Equal(t, true, v)
   784  
   785  	d := `{"test":"test", "obj":{"id":-123, "value":null}}`
   786  	testScope := GetSimpleScope("name", d)
   787  
   788  	e, err = ParseExpression(`$.name.obj.id >= -2`)
   789  	if err != nil {
   790  		t.Fatal(err)
   791  		t.Failed()
   792  	}
   793  	v, err = e.EvalWithScope(testScope, data.GetBasicResolver())
   794  	assert.Nil(t, err)
   795  	assert.Equal(t, false, v)
   796  
   797  	e, err = ParseExpression(`$.name.obj.id == -123`)
   798  	if err != nil {
   799  		t.Fatal(err)
   800  		t.Failed()
   801  	}
   802  	v, err = e.EvalWithScope(testScope, data.GetBasicResolver())
   803  	assert.Nil(t, err)
   804  	assert.Equal(t, true, v)
   805  }
   806  
   807  func TestFloatWithInt(t *testing.T) {
   808  	expr, _ := ParseExpression("1 == 1.23")
   809  	fmt.Println(fmt.Sprintf("%+v", expr))
   810  	i, err := expr.Eval()
   811  	if err != nil {
   812  		t.Fatalf("error %s\n", err)
   813  	}
   814  	res := i.(bool)
   815  	if res {
   816  		t.Errorf("Expected false, got : %t\n ", res)
   817  	}
   818  
   819  	expr, _ = ParseExpression("1 < 1.23")
   820  	i, err = expr.Eval()
   821  	if err != nil {
   822  		t.Fatalf("error %s\n", err)
   823  	}
   824  	res = i.(bool)
   825  	if !res {
   826  		t.Errorf("Expected true, got : %t\n ", res)
   827  	}
   828  
   829  	expr, _ = ParseExpression("1.23 == 1")
   830  	i, err = expr.Eval()
   831  	if err != nil {
   832  		t.Fatalf("error %s\n", err)
   833  	}
   834  	res = i.(bool)
   835  	if res {
   836  		t.Errorf("Expected false, got : %t\n ", res)
   837  	}
   838  
   839  	expr, _ = ParseExpression("1.23 > 1")
   840  	i, err = expr.Eval()
   841  	if err != nil {
   842  		t.Fatalf("error %s\n", err)
   843  	}
   844  	res = i.(bool)
   845  	if !res {
   846  		t.Errorf("Expected true, got : %t\n ", res)
   847  	}
   848  }
   849  
   850  func TestExpressionTernaryNest(t *testing.T) {
   851  	v, err := ParseExpression(`(string.length("1234") == 4 ? true : false) ? (2 >1 ? (3>2?"Yes":"nono"):"No") : "false"`)
   852  	if err != nil {
   853  
   854  		t.Fatal(err)
   855  		t.Failed()
   856  	}
   857  
   858  	result, err := v.EvalWithScope(nil, nil)
   859  	if err != nil {
   860  		t.Fatal(err)
   861  		t.Failed()
   862  	}
   863  	assert.Equal(t, "Yes", result)
   864  
   865  	v, err = ParseExpression(`(4 == 4 ? true : false) ? "yes" : "no"`)
   866  	if err != nil {
   867  
   868  		t.Fatal(err)
   869  		t.Failed()
   870  	}
   871  
   872  	result, err = v.EvalWithScope(nil, nil)
   873  	if err != nil {
   874  		t.Fatal(err)
   875  		t.Failed()
   876  	}
   877  	assert.Equal(t, "yes", result)
   878  
   879  	v, err = ParseExpression(`(4 == 4 ? true : false) ? 4 < 3 ? "good" :"false" : "no"`)
   880  	if err != nil {
   881  
   882  		t.Fatal(err)
   883  		t.Failed()
   884  	}
   885  
   886  	result, err = v.EvalWithScope(nil, nil)
   887  	if err != nil {
   888  		t.Fatal(err)
   889  		t.Failed()
   890  	}
   891  	assert.Equal(t, "false", result)
   892  
   893  	v, err = ParseExpression(`4 > 3 ? 6<4 ?  "good2" : "false2" : "false"`)
   894  	if err != nil {
   895  
   896  		t.Fatal(err)
   897  		t.Failed()
   898  	}
   899  
   900  	result, err = v.EvalWithScope(nil, nil)
   901  	if err != nil {
   902  		t.Fatal(err)
   903  		t.Failed()
   904  	}
   905  	assert.Equal(t, "false2", result)
   906  
   907  	v, err = ParseExpression(`4 > 5 ? 6<4 ?  "good2" : "false2" : 3>2?"ok":"notok"`)
   908  	if err != nil {
   909  
   910  		t.Fatal(err)
   911  		t.Failed()
   912  	}
   913  
   914  	result, err = v.EvalWithScope(nil, nil)
   915  	if err != nil {
   916  		t.Fatal(err)
   917  		t.Failed()
   918  	}
   919  	assert.Equal(t, "ok", result)
   920  
   921  }
   922  
   923  func GetSimpleScope(name, value string) data.Scope {
   924  	a, _ := data.NewAttribute(name, data.TypeObject, value)
   925  	maps := make(map[string]*data.Attribute)
   926  	maps[name] = a
   927  	scope := data.NewFixedScope(maps)
   928  	scope.SetAttrValue(name, value)
   929  	return scope
   930  }