Re-add ResourceManager test

Author: catamorphism

icu4c/source/test/intltest/messageformat2test.h

@@ -61,7 +61,7 @@ class TestMessageFormat2: public IntlTest {
     void testCustomFunctionsComplexMessage(IcuTestErrorCode&);
     void testGrammarCasesFormatter(IcuTestErrorCode&);
     void testListFormatter(IcuTestErrorCode&);
-   // void testMessageRefFormatter(IcuTestErrorCode&);
+    void testMessageRefFormatter(IcuTestErrorCode&);
     void testComplexOptions(IcuTestErrorCode&);
 
     // Feature tests
@@ -212,26 +212,31 @@ class AdjectiveValue : public FunctionValue {
                    UErrorCode&);
 }; // class AdjectiveValue
 
-/*
-class ResourceManagerFactory : public FormatterFactory {
-    public:
-    Formatter* createFormatter(const Locale&, UErrorCode&) override;
-};
 
-class ResourceManager : public Formatter {
+class ResourceManager : public Function {
     public:
-    FormattedPlaceholder format(FormattedPlaceholder&&, FunctionOptions&& opts, UErrorCode& errorCode) const override;
+    FunctionValue* call(const FunctionContext&, FunctionValue&, FunctionOptions&&, UErrorCode&) override;
     static MFFunctionRegistry customRegistry(UErrorCode&);
     static Hashtable* properties(UErrorCode&);
     static UnicodeString propertiesAsString(const Hashtable&);
     static Hashtable* parseProperties(const UnicodeString&, UErrorCode&);
+    ResourceManager() {}
+    virtual ~ResourceManager();
+};
 
+class ResourceManagerValue : public FunctionValue {
+    public:
+    UnicodeString formatToString(UErrorCode&) const override;
+    ResourceManagerValue();
+    virtual ~ResourceManagerValue();
     private:
-    friend class ResourceManagerFactory;
-    ResourceManager(const Locale& loc) : locale(loc) {}
-    const Locale& locale;
-};
-*/
+    friend class ResourceManager;
+
+    UnicodeString formattedString;
+    ResourceManagerValue(FunctionValue&,
+                         FunctionOptions&&,
+                         UErrorCode&);
+}; // class ResourceManagerValue
 
 class NounFunction : public Function {
     public:

icu4c/source/test/intltest/messageformat2test_custom.cpp

@@ -240,7 +240,7 @@ void TestMessageFormat2::testCustomFunctions() {
   testCustomFunctionsComplexMessage(errorCode);
   testGrammarCasesFormatter(errorCode);
   testListFormatter(errorCode);
-  // testMessageRefFormatter(errorCode);
+  testMessageRefFormatter(errorCode);
   testComplexOptions(errorCode);
 }
 
@@ -641,7 +641,6 @@ void TestMessageFormat2::testListFormatter(IcuTestErrorCode& errorCode) {
   See ICU4J: CustomFormatterMessageRefTest.java
 */
 
-#if false
 /* static */ Hashtable* message2::ResourceManager::properties(UErrorCode& errorCode) {
     NULL_ON_ERROR(errorCode);
 
@@ -675,47 +674,54 @@ void TestMessageFormat2::testListFormatter(IcuTestErrorCode& errorCode) {
     return nullptr;
 }
 
-Formatter* ResourceManagerFactory::createFormatter(const Locale& locale, UErrorCode& errorCode) {
-    if (U_FAILURE(errorCode)) {
-        return nullptr;
-    }
-
-    Formatter* result = new ResourceManager(locale);
-    if (result == nullptr) {
-        errorCode = U_MEMORY_ALLOCATION_ERROR;
-    }
-    return result;
-}
-
 using Arguments = MessageArguments;
 
-// TODO: The next test is commented out because we need to write code
-// to convert an options map to a MessageArguments (mapping FormattedPlaceholder
-// back to Formattable)
-
 static Arguments localToGlobal(const FunctionOptionsMap& opts, UErrorCode& status) {
     if (U_FAILURE(status)) {
         return {};
     }
     std::map<UnicodeString, message2::Formattable> result;
     for (auto iter = opts.cbegin(); iter != opts.cend(); ++iter) {
-        result[iter->first] = iter->second->getSource(status);
+        result[iter->first] = iter->second->getOperand();
     }
     return MessageArguments(result, status);
 }
 
-message2::FormattedPlaceholder ResourceManager::format(FormattedPlaceholder&& arg, FunctionOptions&& options, UErrorCode& errorCode) const {
+FunctionValue* ResourceManager::call(const FunctionContext&,
+                                     FunctionValue& arg,
+                                     FunctionOptions&& options,
+                                     UErrorCode& errorCode) {
+    NULL_ON_ERROR(errorCode);
+
+    LocalPointer<ResourceManagerValue>
+        result(new ResourceManagerValue(arg, std::move(options), errorCode));
+
+    if (U_SUCCESS(errorCode) && !result.isValid()) {
+        errorCode = U_MEMORY_ALLOCATION_ERROR;
+        return nullptr;
+    }
+    return result.orphan();
+}
+
+UnicodeString message2::ResourceManagerValue::formatToString(UErrorCode&) const {
+    return formattedString;
+}
+
+message2::ResourceManagerValue::ResourceManagerValue(FunctionValue& arg,
+                                                     FunctionOptions&& options,
+                                                     UErrorCode& errorCode) {
     if (U_FAILURE(errorCode)) {
-        return {};
+        return;
     }
 
-    message2::FormattedPlaceholder errorVal = message2::FormattedPlaceholder("msgref");
+    operand = arg.getOperand();
+    opts = std::move(options); // Tests don't cover composition, so no need to merge options
 
-    const Formattable* toFormat = arg.getSource(errorCode);
+    const Formattable* toFormat = &operand;
     // Check for null or fallback
     if (errorCode == U_ILLEGAL_ARGUMENT_ERROR) {
         errorCode = U_MF_FORMATTING_ERROR;
-        return errorVal;
+        return;
     }
     UnicodeString in;
     switch (toFormat->getType()) {
@@ -725,30 +731,33 @@ message2::FormattedPlaceholder ResourceManager::format(FormattedPlaceholder&& ar
         }
         default: {
             // Ignore non-strings
-            return errorVal;
+            return;
         }
     }
-    FunctionOptionsMap opt = FunctionOptions::getOptions(std::move(options));
-    bool hasProperties = opt.count("resbundle") > 0 && opt["resbundle"].getValue().getType() == UFMT_OBJECT && opt["resbundle"].getValue().getObject(errorCode)->tag() == u"properties";
+    FunctionOptionsMap opt = opts.getOptions();
+    bool hasProperties = opt.count("resbundle") > 0
+        && opt["resbundle"]->getOperand().getType() == UFMT_OBJECT
+        && opt["resbundle"]->getOperand().getObject(errorCode)->tag() == u"properties";
 
     // If properties were provided, look up the given string in the properties,
     // yielding a message
     if (hasProperties) {
-        const FormattableProperties* properties = reinterpret_cast<const FormattableProperties*>(opt["resbundle"].getValue().getObject(errorCode));
+        const FormattableProperties* properties = reinterpret_cast<const FormattableProperties*>
+            (opt["resbundle"]->getOperand().getObject(errorCode));
         U_ASSERT(U_SUCCESS(errorCode));
         UnicodeString* msg = static_cast<UnicodeString*>(properties->properties->get(in));
         if (msg == nullptr) {
             // No message given for this key -- error out
             errorCode = U_MF_FORMATTING_ERROR;
-            return errorVal;
+            return;
         }
 	MessageFormatter::Builder mfBuilder(errorCode);
         UParseError parseErr;
         // Any parse/data model errors will be propagated
 	MessageFormatter mf = mfBuilder.setPattern(*msg, parseErr, errorCode).build(errorCode);
         Arguments arguments = localToGlobal(opt, errorCode);
         if (U_FAILURE(errorCode)) {
-            return errorVal;
+            return;
         }
 
         UErrorCode savedStatus = errorCode;
@@ -759,14 +768,16 @@ message2::FormattedPlaceholder ResourceManager::format(FormattedPlaceholder&& ar
         if (U_FAILURE(errorCode)) {
             errorCode = savedStatus;
         }
-        return arg.withOutput(FormattedValue(std::move(result)), errorCode);
+        formattedString = result;
     } else {
         // Properties must be provided
         errorCode = U_MF_FORMATTING_ERROR;
     }
-    return errorVal;
+    return;
 }
 
+ResourceManager::~ResourceManager() {}
+ResourceManagerValue::~ResourceManagerValue() {}
 
 void TestMessageFormat2::testMessageRefFormatter(IcuTestErrorCode& errorCode) {
     CHECK_ERROR(errorCode);
@@ -779,7 +790,7 @@ void TestMessageFormat2::testMessageRefFormatter(IcuTestErrorCode& errorCode) {
         return;
     }
     MFFunctionRegistry reg = MFFunctionRegistry::Builder(errorCode)
-        .adoptFormatter(FunctionName("msgRef"), new ResourceManagerFactory(), errorCode)
+        .adoptFunction(FunctionName("msgRef"), new ResourceManager(), errorCode)
         .build();
     CHECK_ERROR(errorCode);
 
@@ -839,7 +850,6 @@ void TestMessageFormat2::testMessageRefFormatter(IcuTestErrorCode& errorCode) {
                                 .build();
     TestUtils::runTestCase(*this, test, errorCode);
 }
-#endif
 
 FunctionValue* NounFunction::call(const FunctionContext&,
                                   FunctionValue& arg,