ICU-23202 MF2 to LDML 48: update tests and :number, :integer, :offset, :percent functions

Author: mihnita

icu4j/main/core/src/main/java/com/ibm/icu/message2/DateTimeFunctionFactory.java

@@ -399,8 +399,9 @@ public String formatToString(Object toFormat, Map<String, Object> variableOption
             "^(([0-9]{4})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])){1}(T([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])(\\.[0-9]{1,3})?(Z|[+-]((0[0-9]|1[0-3]):[0-5][0-9]|14:00))?)?$");
 
     private static Integer safeParse(String str) {
-        if (str == null || str.isEmpty())
+        if (str == null || str.isEmpty()) {
             return null;
+        }
         return Integer.parseInt(str);
     }
 

icu4j/main/core/src/main/java/com/ibm/icu/message2/MFDataModelFormatter.java

@@ -88,7 +88,8 @@ class MFDataModelFormatter {
                         .setFunction("number", new NumberFunctionFactory("number"))
                         .setFunction("integer", new NumberFunctionFactory("integer"))
                         .setFunction("currency", new NumberFunctionFactory("currency"))
-                        .setFunction("math", new NumberFunctionFactory("math"))
+                        .setFunction("percent", new NumberFunctionFactory("percent"))
+                        .setFunction("offset", new NumberFunctionFactory("offset"))
                         .setDefaultFunctionNameForType(Integer.class, "number")
                         .setDefaultFunctionNameForType(Double.class, "number")
                         .setDefaultFunctionNameForType(Number.class, "number")
@@ -188,7 +189,16 @@ private Pattern findBestMatchingPattern(
         // spec: For each _selector_ `sel`, in source order,
         for (Expression sel : selectors) {
             // spec: Let `rv` be the resolved value of `sel`.
-            FormattedPlaceholder fph = formatExpression(sel, variables, arguments);
+            FormattedPlaceholder fph = null;
+            if (sel instanceof MFDataModel.VariableExpression) {
+                // If it is a `VariableExpression` then it is already resolved and in `variables`
+                String key = ((MFDataModel.VariableExpression) sel).arg.name;
+                fph = (FormattedPlaceholder) variables.get(key);
+            }
+            // Was not a `VariableExpression` or in `variables`
+            if (fph == null) {
+                fph = formatExpression(sel, variables, arguments);
+            }
             String functionName = null;
             Object argument = null;
             MapWithNfcKeys options = new MapWithNfcKeys();

icu4j/main/core/src/main/java/com/ibm/icu/message2/NumberFunctionFactory.java

@@ -5,6 +5,7 @@
 
 import java.util.Locale;
 import java.util.Map;
+import java.util.Objects;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
@@ -85,7 +86,7 @@ static String getString(Map<String, Object> options, String key) {
 
     static boolean reportErrors(Map<String, Object> options) {
         String reportErrors = getString(options, "icu:impl:errorPolicy");
-        return "STRICT".equals(reportErrors);
+        return Objects.equals(reportErrors, "STRICT");
     }
 
     static boolean reportErrors(Map<String, Object> fixedOptions, Map<String, Object> variableOptions) {

icu4j/main/core/src/main/java/com/ibm/icu/message2/OptUtils.java

@@ -14,6 +14,7 @@
 @SuppressWarnings({"static-method", "javadoc"})
 @RunWith(JUnit4.class)
 public class CoreTest extends CoreTestFmwk {
+    private static final boolean DEBUG = false;
 
     private static final String[] JSON_FILES = {
             "alias-selector-annotations.json",
@@ -39,8 +40,9 @@ public class CoreTest extends CoreTestFmwk {
             "spec/functions/date.json",
             "spec/functions/datetime.json",
             "spec/functions/integer.json",
-            "spec/functions/math.json", // FAILS 2 / 16, chaining to select
+            "spec/functions/offset.json",
             "spec/functions/number.json",
+            "spec/functions/percent.json",
             "spec/functions/string.json",
             "spec/functions/time.json",
             "spec/pattern-selection.json",
@@ -59,8 +61,14 @@ public class CoreTest extends CoreTestFmwk {
     public void test() throws Exception {
         for (String jsonFile : JSON_FILES) {
             try (Reader reader = TestUtils.jsonReader(jsonFile)) {
+                if (DEBUG) {
+                    System.out.println("==== " + jsonFile);
+                }
                 MF2Test tests = TestUtils.GSON.fromJson(reader, MF2Test.class);
                 for (Unit unit : tests.tests) {
+                    if (DEBUG) {
+                        System.out.println("    " + unit);
+                    }
                     TestUtils.runTestCase(tests.defaultTestProperties, unit);
                 }
             }

icu4j/main/core/src/test/java/com/ibm/icu/dev/test/message2/CoreTest.java

@@ -53,7 +53,7 @@ static class PersonNameFunctionImpl implements Function {
             final String length;
 
             public PersonNameFunctionImpl(Object level, Object length) {
-                this.useFormal = "formal".equals(level);
+                this.useFormal = Objects.equals(level, "formal");
                 this.length = Objects.toString(length);
             }
 

icu4j/main/core/src/test/java/com/ibm/icu/dev/test/message2/CustomFunctionPersonTest.java

@@ -334,41 +334,13 @@ public void testFormatterIsCreatedOnce() {
     @Test
     public void testPluralWithOffset() {
         String message = ""
-                + ".input {$count :number icu:offset=2}\n"
-                + ".match $count\n"
-                + " 1   {{Anna}}\n"
-                + " 2   {{Anna and Bob}}\n"
-                + " one {{Anna, Bob, and {$count :number icu:offset=2} other guest}}\n"
-                + " *   {{Anna, Bob, and {$count :number icu:offset=2} other guests}}";
-        MessageFormatter mf2 = MessageFormatter.builder()
-                .setPattern(message)
-                .build();
-        assertEquals("plural with offset",
-                "Anna",
-                mf2.formatToString(Args.of("count", 1)));
-        assertEquals("plural with offset",
-                "Anna and Bob",
-                mf2.formatToString(Args.of("count", 2)));
-        assertEquals("plural with offset",
-                "Anna, Bob, and 1 other guest",
-                mf2.formatToString(Args.of("count", 3)));
-        assertEquals("plural with offset",
-                "Anna, Bob, and 2 other guests",
-                mf2.formatToString(Args.of("count", 4)));
-        assertEquals("plural with offset",
-                "Anna, Bob, and 10 other guests",
-                mf2.formatToString(Args.of("count", 12)));
-    }
-
-    @Test
-    public void testPluralWithOffsetAndLocalVar() {
-        String message = ""
-                + ".local $foo = {$count :number icu:offset=2}"
-                + ".match $foo\n" // should "inherit" the offset
-                + " 1   {{Anna}}\n"
-                + " 2   {{Anna and Bob}}\n"
-                + " one {{Anna, Bob, and {$foo} other guest}}\n"
-                + " *   {{Anna, Bob, and {$foo} other guests}}";
+                + ".input {$count :number}\n"
+                + ".local $offsetCount = {$count :offset subtract=2}\n"
+                + ".match $count $offsetCount\n"
+                + " 1 *  {{Anna}}\n"
+                + " 2 *  {{Anna and Bob}}\n"
+                + " * one {{Anna, Bob, and {$offsetCount} other guest}}\n"
+                + " * *   {{Anna, Bob, and {$offsetCount} other guests}}";
         MessageFormatter mf2 = MessageFormatter.builder()
                 .setPattern(message)
                 .build();
@@ -450,12 +422,13 @@ public void testLoopOnLocalVars() {
     @Test
     public void testVariableOptionsInSelector() {
         String messageVar = ""
-                + ".input {$count :number icu:offset=$delta}\n"
-                + ".match $count\n"
-                + " 1   {{A}}\n"
-                + " 2   {{A and B}}\n"
-                + " one {{A, B, and {$count :number icu:offset=$delta} more character}}\n"
-                + " *   {{A, B, and {$count :number icu:offset=$delta} more characters}}";
+                + ".input {$count :number}\n"
+                + ".local $offsetCount = {$count :offset subtract=$delta}\n"
+                + ".match $count $offsetCount\n"
+                + " 1 *  {{A}}\n"
+                + " 2 *  {{A and B}}\n"
+                + " * one {{A, B, and {$offsetCount} more character}}\n"
+                + " * *   {{A, B, and {$offsetCount} more characters}}";
         MessageFormatter mfVar = MessageFormatter.builder()
                 .setPattern(messageVar)
                 .build();
@@ -469,11 +442,12 @@ public void testVariableOptionsInSelector() {
                 mfVar.formatToString(Args.of("count", 7, "delta", 2)));
 
         String messageVar2 = ""
-                + ".input {$count :number icu:offset=$delta}\n"
-                + ".match $count\n"
-                + " 1 {{Exactly 1}}\n"
-                + " 2 {{Exactly 2}}\n"
-                + " * {{Count = {$count :number icu:offset=$delta} and delta={$delta}.}}";
+                + ".input {$count :number}\n"
+                + ".local $offsetCount = {$count :offset subtract=$delta}\n"
+                + ".match $count $offsetCount\n"
+                + " 1 * {{Exactly 1}}\n"
+                + " 2 * {{Exactly 2}}\n"
+                + " * * {{Count = {$count :number icu:offset=$delta} and delta={$delta}.}}";
         MessageFormatter mfVar2 = MessageFormatter.builder()
                 .setPattern(messageVar2)
                 .build();
@@ -509,12 +483,13 @@ public void testVariableOptionsInSelector() {
     @Test
     public void testVariableOptionsInSelectorWithLocalVar() {
         String messageFix = ""
-                + ".local $offCount = {$count :number icu:offset=2}"
-                + ".match $offCount\n"
-                + " 1   {{A}}\n"
-                + " 2   {{A and B}}\n"
-                + " one {{A, B, and {$offCount} more character}}\n"
-                + " *   {{A, B, and {$offCount} more characters}}";
+                + ".input {$count :integer}"
+                + ".local $offCount = {$count :offset subtract=2}"
+                + ".match $count $offCount\n"
+                + " 1 *  {{A}}\n"
+                + " 2 *  {{A and B}}\n"
+                + " * one {{A, B, and {$offCount} more character}}\n"
+                + " * *   {{A, B, and {$offCount} more characters}}";
         MessageFormatter mfFix = MessageFormatter.builder()
                 .setPattern(messageFix)
                 .build();
@@ -524,12 +499,13 @@ public void testVariableOptionsInSelectorWithLocalVar() {
         assertEquals("test local vars loop", "A, B, and 5 more characters", mfFix.formatToString(Args.of("count", 7)));
 
         String messageVar = ""
-                + ".local $offCount = {$count :number icu:offset=$delta}"
-                + ".match $offCount\n"
-                + " 1   {{A}}\n"
-                + " 2   {{A and B}}\n"
-                + " one {{A, B, and {$offCount} more character}}\n"
-                + " *   {{A, B, and {$offCount} more characters}}";
+                + ".input {$count :number}"
+                + ".local $offCount = {$count :offset subtract=$delta}"
+                + ".match $count $offCount\n"
+                + " 1 *  {{A}}\n"
+                + " 2 *  {{A and B}}\n"
+                + " * one {{A, B, and {$offCount} more character}}\n"
+                + " * *   {{A, B, and {$offCount} more characters}}";
         MessageFormatter mfVar = MessageFormatter.builder()
                 .setPattern(messageVar)
                 .build();
@@ -543,11 +519,12 @@ public void testVariableOptionsInSelectorWithLocalVar() {
                 mfVar.formatToString(Args.of("count", 7, "delta", 2)));
 
         String messageVar2 = ""
-                + ".local $offCount = {$count :number icu:offset=$delta}"
-                + ".match $offCount\n"
-                + " 1 {{Exactly 1}}\n"
-                + " 2 {{Exactly 2}}\n"
-                + " * {{Count = {$count}, OffCount = {$offCount}, and delta={$delta}.}}";
+                + ".input {$count :number}"
+                + ".local $offCount = {$count :offset subtract=$delta}"
+                + ".match $count $offCount\n"
+                + " 1 * {{Exactly 1}}\n"
+                + " 2 * {{Exactly 2}}\n"
+                + " * * {{Count = {$count}, OffCount = {$offCount}, and delta={$delta}.}}";
         MessageFormatter mfVar2 = MessageFormatter.builder()
                 .setPattern(messageVar2)
                 .build();

icu4j/main/core/src/test/java/com/ibm/icu/dev/test/message2/MessageFormat2Test.java

@@ -8,6 +8,7 @@
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
+import java.util.Objects;
 
 import com.ibm.icu.message2.FormattedPlaceholder;
 import com.ibm.icu.message2.Function;
@@ -45,7 +46,7 @@ public TestFunctionImpl(String kind, Map<String, Object> fixedOptions) {
 
         @Override
         public String formatToString(Object toFormat, Map<String, Object> variableOptions) {
-            if (!"select".equals(kind) && parsedOptions.failsFormat) {
+            if (!Objects.equals(kind, "select") && parsedOptions.failsFormat) {
                 throw new InvalidParameterException("ALWAYS FAIL");
             }
             return format(toFormat, variableOptions).toString();
@@ -59,7 +60,7 @@ public FormattedPlaceholder format(Object toFormat, Map<String, Object> variable
         @Override
         public List<String> matches(Object value, List<String> keys, Map<String, Object> variableOptions) {
 //            ParsedOptions parsedOptions = ParsedOptions.of(variableOptions);
-            if (kind.equals("format")) {
+            if (Objects.equals(kind, "format")) {
                 // Can't do selection on the `format` only function
                 return null;
             }
@@ -93,10 +94,10 @@ private static int testComparator(String o1, String o2) {
                 return -1;
             }
             // * sorts last
-            if ("*".equals(o1)) {
+            if (Objects.equals(o1, "*")) {
                 return 1;
             }
-            if ("*".equals(o2)) {
+            if (Objects.equals(o2, "*")) {
                 return -1;
             }
             // At this point they are both strings
@@ -129,7 +130,7 @@ static ParsedOptions of(Map<String, Object> options) {
             }
 
             String option = getStringOption(options, "icu:impl:errorPolicy", null);
-            reportErrors= "STRICT".equals(option);
+            reportErrors = Objects.equals(option, "STRICT");
 
             option = getStringOption(options, "fails", "never");
             switch (option) {

icu4j/main/core/src/test/java/com/ibm/icu/dev/test/message2/TestFunctionFactory.java

@@ -118,7 +118,7 @@ static void rewriteDecimals(Param[] params) {
                 @SuppressWarnings("unchecked")
                 Map<String, Object> innerMap = (Map<String, Object>) pair.value;
                 if (innerMap.size() == 1 && innerMap.containsKey("decimal")
-                    && innerMap.get("decimal") instanceof String) {
+                        && innerMap.get("decimal") instanceof String) {
                     String decimalValue = (String) innerMap.get("decimal");
                     params[i] = new Param(pair.name, new com.ibm.icu.math.BigDecimal(decimalValue));
                 }

icu4j/main/core/src/test/java/com/ibm/icu/dev/test/message2/TestUtils.java

@@ -33,13 +33,13 @@
       "src": "{|2006-01-02T15:04:06| :date}"
     },
     {
-      "src": "{|2006-01-02| :date style=long}"
+      "src": "{|2006-01-02| :date length=long}"
     },
     {
-      "src": ".local $d = {|2006-01-02| :date style=long} {{{$d}}}"
+      "src": ".local $d = {|2006-01-02| :date length=long} {{{$d}}}"
     },
     {
-      "src": ".local $d = {|2006-01-02| :datetime dateStyle=long timeStyle=long} {{{$d :date}}}"
+      "src": ".local $d = {|2006-01-02| :datetime dateLength=long timePrecision=second} {{{$d :date}}}"
     }
   ]
 }