[ 
https://issues.apache.org/jira/browse/CAMEL-21109?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
 ]

Harish Annamalai reopened CAMEL-21109:
--------------------------------------

We humbly request you to provide a this same patch to camel-3.x series of 
branches as Camel 3.22 is supported up to Dec 2024.

> Choice evaluation behaves inconsistently when source is String and Value is 
> Float.
> ----------------------------------------------------------------------------------
>
>                 Key: CAMEL-21109
>                 URL: https://issues.apache.org/jira/browse/CAMEL-21109
>             Project: Camel
>          Issue Type: Bug
>          Components: camel-core
>    Affects Versions: 3.x
>            Reporter: Harish Annamalai
>            Assignee: Claus Ibsen
>            Priority: Minor
>             Fix For: 4.8.0
>
>
> Choice evaluation works inconsistently if the condition contains Predicates 
> with String, but the value is float.
> Consider the choice expression:
> *${exchangeProperty.left} >= ${exchangeProperty.right}*
> If the both the properties are 'left' and 'right', but value contained in 
> them is float like '4.0' '7.5' etc, the expression is compared as Strings and 
> returns false. However, if the value contained in them is "Pure" Integer, 
> then they are compared as "Numbers" and Comparision returns true.
> Please see the Examples:
> *Example 1:*
> {{        from("timer:getter?period=1000&repeatCount=1")}}
> {{                .setProperty("left", simple("40"))}}
> {{                .setProperty("right", simple("7.5"))}}
> {{                .choice()}}
> {{                .when(simple("${exchangeProperty.left} >= 
> ${exchangeProperty.right}"))}}
> {{                .to("log://match")}}
> {{                .otherwise()}}
> {{                .to("log://otherwise")}}
> {{                .end();}}
> {{                }}
> {{The Predicate in Example 1, evaluation returns false for the case above as 
> it compares 40 and 7.5 as Strings.}}
> {{*Example 2:*                }}
> {{        from("timer:getter?period=1000&repeatCount=1")}}
> {{                .setProperty("left", simple("40"))}}
> {{                .setProperty("right", simple("7"))}}
> {{                .choice()}}
> {{                .when(simple("${exchangeProperty.left} >= 
> ${exchangeProperty.right}"))}}
> {{                .to("log://match")}}
> {{                .otherwise()}}
> {{                .to("log://otherwise")}}
> {{                .end();}}
> {{                }}
> {{The Predicate in Example 2, evaluation returns true for the case above as 
> it compares 40 and 7 as Numbers.}}
>  
> We debugged the Camel Code, and compared the behavior against Camel 2x, we 
> can see that the predicate evaluation takes "Double" also into consideration.
> *Camel 2x Code:*
> [ObjectHelper.java|https://github.com/apache/camel/blob/8e512e50a49f309ae2f9641f59dbfe561e7c0a13/camel-core/src/main/java/org/apache/camel/util/ObjectHelper.java#L147C1-L161C10]
> public static int typeCoerceCompare(TypeConverter converter, Object 
> leftValue, Object rightValue) {
>         // if both values is numeric then compare using numeric
>         Long leftNum = converter.tryConvertTo(Long.class, leftValue);
>         Long rightNum = converter.tryConvertTo(Long.class, rightValue);
>         if (leftNum != null && rightNum != null) {
>             return leftNum.compareTo(rightNum);
>         }
>         // also try with floating point numbers
>         Double leftDouble = converter.tryConvertTo(Double.class, leftValue);
>         Double rightDouble = converter.tryConvertTo(Double.class, rightValue);
>         if (leftDouble != null && rightDouble != null) {
>             return leftDouble.compareTo(rightDouble);
>         }   
> *Camel 3x Code:*
> [ObjectHelper.java|https://github.com/apache/camel/blob/bb339e9eb26fa38b448d74bbb058c70d0a057f33/core/camel-support/src/main/java/org/apache/camel/support/ObjectHelper.java#L261]
> public static int typeCoerceCompare(TypeConverter converter, Object 
> leftValue, Object rightValue) {
>         // optimize for common combinations of comparing numbers
>         if (leftValue instanceof String && rightValue instanceof String) {
>             String leftNum = (String) leftValue;
>             String rightNum = (String) rightValue;
>             if (isNumber(leftNum) && isNumber(rightNum)) {
>                 // favour to use numeric comparison
>                 Long num1 = Long.parseLong(leftNum);
>                 Long num2 = Long.parseLong(rightNum);
>                 return num1.compareTo(num2);
>             }
>             return leftNum.compareTo(rightNum);
>         } else if (leftValue instanceof Integer && rightValue instanceof 
> Integer) {



--
This message was sent by Atlassian Jira
(v8.20.10#820010)

Reply via email to