Skip to content

Commit

Permalink
Merge pull request #246 from TIBCOSoftware/issue-245
Browse files Browse the repository at this point in the history 
Fixed #245, convert int to float once there is int comparing with float.
  • Loading branch information
@lixingwang
lixingwang authored Oct 23, 2018
2 parents c1d22d5 + 28991b6 commit 9a30626
Show file tree
Hide file tree
Showing 2 changed files with 247 additions and 69 deletions.
273 changes: 204 additions & 69 deletions core/mapper/exprmapper/expression/expr/expr.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -348,6 +348,7 @@ func (f *Expression) run(left interface{}, op OPERATIOR, right interface{}) (int
case MULTIPLICATION:
return multiplication(left, right)
case DIVISION:
//TODO
return div(left, right)
case INT_DIVISTION:
//TODO....
Expand Down Expand Up @@ -398,17 +399,34 @@ func ConvertToSameType(left interface{}, right interface{}) (interface{}, interf
var err error
switch t := left.(type) {
case int:
rightValue, err = data.CoerceToInteger(right)
if err != nil {
err = fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
if isDoubleType(right) {
leftValue, err = data.CoerceToDouble(left)
if err != nil {
err = fmt.Errorf("Convert left expression to type float64 failed, due to %s", err.Error())
}
rightValue = right
} else {
rightValue, err = data.CoerceToInteger(right)
if err != nil {
err = fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
}
leftValue = t
}
leftValue = t

case int64:
rightValue, err = data.CoerceToInteger(right)
if err != nil {
err = fmt.Errorf("Convert right expression to type int64 failed, due to %s", err.Error())
if isDoubleType(right) {
leftValue, err = data.CoerceToDouble(left)
if err != nil {
err = fmt.Errorf("Convert left expression to type float64 failed, due to %s", err.Error())
}
rightValue = right
} else {
rightValue, err = data.CoerceToInteger(right)
if err != nil {
err = fmt.Errorf("Convert right expression to type int64 failed, due to %s", err.Error())
}
leftValue = t
}
leftValue = t
case float64:
rightValue, err = data.CoerceToNumber(right)
if err != nil {
Expand Down Expand Up @@ -483,28 +501,59 @@ func gt(left interface{}, right interface{}, includeEquals bool) (bool, error) {
rightType := getType(right)
switch le := left.(type) {
case int:
//We should conver to int first
rightValue, err := data.CoerceToInteger(right)
if err != nil {
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
}
if includeEquals {
return le >= rightValue, nil
//For int float compare, convert int to float to compare
if isDoubleType(right) {
leftValue, err := data.CoerceToDouble(left)
if err != nil {
err = fmt.Errorf("Convert left expression to type float64 failed, due to %s", err.Error())
}
rightValue := right.(float64)
if includeEquals {
return leftValue >= rightValue, nil

} else {
return leftValue > rightValue, nil
}

} else {
return le > rightValue, nil
//We should conver to int first
rightValue, err := data.CoerceToInteger(right)
if err != nil {
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
}
if includeEquals {
return le >= rightValue, nil

} else {
return le > rightValue, nil
}
}

case int64:
rightValue, err := data.CoerceToInteger(right)
if err != nil {
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
}
if includeEquals {
return int(le) >= rightValue, nil
if isDoubleType(right) {
leftValue, err := data.CoerceToDouble(left)
if err != nil {
err = fmt.Errorf("Convert left expression to type float64 failed, due to %s", err.Error())
}
rightValue := right.(float64)
if includeEquals {
return leftValue >= rightValue, nil

} else {
return leftValue > rightValue, nil
}

} else {
return int(le) > rightValue, nil
rightValue, err := data.CoerceToInteger(right)
if err != nil {
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
}
if includeEquals {
return int(le) >= rightValue, nil

} else {
return int(le) > rightValue, nil
}
}
case float64:
rightValue, err := data.CoerceToNumber(right)
Expand Down Expand Up @@ -555,26 +604,54 @@ func lt(left interface{}, right interface{}, includeEquals bool) (bool, error) {

switch le := left.(type) {
case int:
rightValue, err := data.CoerceToInteger(right)
if err != nil {
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
}
if includeEquals {
return le <= rightValue, nil

if isDoubleType(right) {
leftValue, err := data.CoerceToDouble(left)
if err != nil {
err = fmt.Errorf("Convert left expression to type float64 failed, due to %s", err.Error())
}
rightValue := right.(float64)
if includeEquals {
return leftValue <= rightValue, nil

} else {
return leftValue < rightValue, nil
}
} else {
return le < rightValue, nil
rightValue, err := data.CoerceToInteger(right)
if err != nil {
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
}
if includeEquals {
return le <= rightValue, nil

} else {
return le < rightValue, nil
}
}
case int64:
rightValue, err := data.CoerceToInteger(right)
if err != nil {
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
}
if includeEquals {
return int(le) <= rightValue, nil

if isDoubleType(right) {
leftValue, err := data.CoerceToDouble(left)
if err != nil {
err = fmt.Errorf("Convert left expression to type float64 failed, due to %s", err.Error())
}
rightValue := right.(float64)
if includeEquals {
return leftValue <= rightValue, nil

} else {
return leftValue < rightValue, nil
}
} else {
return int(le) < rightValue, nil
rightValue, err := data.CoerceToInteger(right)
if err != nil {
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
}
if includeEquals {
return int(le) <= rightValue, nil

} else {
return int(le) < rightValue, nil
}
}
case float64:
rightValue, err := data.CoerceToNumber(right)
Expand Down Expand Up @@ -660,20 +737,37 @@ func additon(left interface{}, right interface{}) (interface{}, error) {

switch le := left.(type) {
case int:
rightValue, err := data.CoerceToInteger(right)
if err != nil {
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
}
if isDoubleType(right) {
leftValue, err := data.CoerceToDouble(left)
if err != nil {
err = fmt.Errorf("Convert left expression to type float64 failed, due to %s", err.Error())
}
rightValue := right.(float64)
return leftValue + rightValue, nil
} else {
rightValue, err := data.CoerceToInteger(right)
if err != nil {
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
}

return le + rightValue, nil
return le + rightValue, nil
}

case int64:
rightValue, err := data.CoerceToInteger(right)
if err != nil {
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
if isDoubleType(right) {
leftValue, err := data.CoerceToDouble(left)
if err != nil {
err = fmt.Errorf("Convert left expression to type float64 failed, due to %s", err.Error())
}
rightValue := right.(float64)
return leftValue + rightValue, nil
} else {
rightValue, err := data.CoerceToInteger(right)
if err != nil {
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
}
return int(le) + rightValue, nil
}

return int(le) + rightValue, nil
case float64:
rightValue, err := data.CoerceToNumber(right)
if err != nil {
Expand Down Expand Up @@ -712,19 +806,35 @@ func sub(left interface{}, right interface{}) (interface{}, error) {

switch le := left.(type) {
case int:
rightValue, err := data.CoerceToInteger(right)
if err != nil {
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
if isDoubleType(right) {
leftValue, err := data.CoerceToDouble(left)
if err != nil {
err = fmt.Errorf("Convert left expression to type float64 failed, due to %s", err.Error())
}
rightValue := right.(float64)
return leftValue - rightValue, nil
} else {
rightValue, err := data.CoerceToInteger(right)
if err != nil {
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
}
return le - rightValue, nil
}

return le - rightValue, nil
case int64:
rightValue, err := data.CoerceToInteger(right)
if err != nil {
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
if isDoubleType(right) {
leftValue, err := data.CoerceToDouble(left)
if err != nil {
err = fmt.Errorf("Convert left expression to type float64 failed, due to %s", err.Error())
}
rightValue := right.(float64)
return leftValue - rightValue, nil
} else {
rightValue, err := data.CoerceToInteger(right)
if err != nil {
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
}
return int(le) - rightValue, nil
}

return int(le) - rightValue, nil
case float64:
rightValue, err := data.CoerceToNumber(right)
if err != nil {
Expand Down Expand Up @@ -764,19 +874,36 @@ func multiplication(left interface{}, right interface{}) (interface{}, error) {

switch le := left.(type) {
case int:
rightValue, err := data.CoerceToInteger(right)
if err != nil {
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
if isDoubleType(right) {
leftValue, err := data.CoerceToDouble(left)
if err != nil {
err = fmt.Errorf("Convert left expression to type float64 failed, due to %s", err.Error())
}
rightValue := right.(float64)
return leftValue * rightValue, nil
} else {
rightValue, err := data.CoerceToInteger(right)
if err != nil {
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
}
return le * rightValue, nil
}

return le * rightValue, nil
case int64:
rightValue, err := data.CoerceToInteger(right)
if err != nil {
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
}
if isDoubleType(right) {
leftValue, err := data.CoerceToDouble(left)
if err != nil {
err = fmt.Errorf("Convert left expression to type float64 failed, due to %s", err.Error())
}
rightValue := right.(float64)
return leftValue * rightValue, nil
} else {
rightValue, err := data.CoerceToInteger(right)
if err != nil {
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
}

return int(le) * rightValue, nil
return int(le) * rightValue, nil
}
case float64:
rightValue, err := data.CoerceToNumber(right)
if err != nil {
Expand Down Expand Up @@ -855,3 +982,11 @@ func div(left interface{}, right interface{}) (interface{}, error) {
func getType(in interface{}) reflect.Type {
return reflect.TypeOf(in)
}

func isDoubleType(in interface{}) bool {
switch in.(type) {
case float64:
return true
}
return false
}
43 changes: 43 additions & 0 deletions core/mapper/exprmapper/expression/expression_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -804,6 +804,49 @@ func TestExpressionWithNegtiveNumber(t *testing.T) {
assert.Equal(t, true, v)
}

func TestFloatWithInt(t *testing.T) {
expr, _ := ParseExpression("1 == 1.23")
fmt.Println(fmt.Sprintf("%+v", expr))
i, err := expr.Eval()
if err != nil {
t.Fatalf("error %s\n", err)
}
res := i.(bool)
if res {
t.Errorf("Expected false, got : %t\n ", res)
}

expr, _ = ParseExpression("1 < 1.23")
i, err = expr.Eval()
if err != nil {
t.Fatalf("error %s\n", err)
}
res = i.(bool)
if !res {
t.Errorf("Expected true, got : %t\n ", res)
}

expr, _ = ParseExpression("1.23 == 1")
i, err = expr.Eval()
if err != nil {
t.Fatalf("error %s\n", err)
}
res = i.(bool)
if res {
t.Errorf("Expected false, got : %t\n ", res)
}

expr, _ = ParseExpression("1.23 > 1")
i, err = expr.Eval()
if err != nil {
t.Fatalf("error %s\n", err)
}
res = i.(bool)
if !res {
t.Errorf("Expected true, got : %t\n ", res)
}
}

func GetSimpleScope(name, value string) data.Scope {
a, _ := data.NewAttribute(name, data.TypeObject, value)
maps := make(map[string]*data.Attribute)
Expand Down

0 comments on commit 9a30626

Please sign in to comment.