icuSources/test/intltest/quantityformattertest.cpp

   1 // © 2016 and later: Unicode, Inc. and others.
   2 // License & terms of use: http://www.unicode.org/copyright.html
   3 /*
   4 *******************************************************************************
   5 * Copyright (C) 2014-2016, International Business Machines Corporation and
   6 * others. All Rights Reserved.
   7 *******************************************************************************
   8 *
   9 * File QUANTITYFORMATTERTEST.CPP
  10 *
  11 ********************************************************************************
  12 */
  13 #include "cstring.h"
  14 #include "intltest.h"
  15 #include "quantityformatter.h"
  16 #include "unicode/simpleformatter.h"
  17 #include "unicode/numfmt.h"
  18 #include "unicode/plurrule.h"
  19
  20
  21 class QuantityFormatterTest : public IntlTest {
  22 public:
  23     QuantityFormatterTest() {
  24     }
  25     void TestBasic();
  26     void runIndexedTest(int32_t index, UBool exec, const char *&name, char *par=0);
  27 private:
  28 };
  29
  30 void QuantityFormatterTest::runIndexedTest(int32_t index, UBool exec, const char* &name, char* /*par*/) {
  31   TESTCASE_AUTO_BEGIN;
  32   TESTCASE_AUTO(TestBasic);
  33   TESTCASE_AUTO_END;
  34 }
  35
  36 void QuantityFormatterTest::TestBasic() {
  37     UErrorCode status = U_ZERO_ERROR;
  38 #if !UCONFIG_NO_FORMATTING
  39     QuantityFormatter fmt;
  40     assertFalse(
  41             "adding bad variant",
  42             fmt.addIfAbsent("a bad variant", "{0} pounds", status));
  43     assertEquals("adding bad variant status", (int32_t)U_ILLEGAL_ARGUMENT_ERROR, status);
  44     status = U_ZERO_ERROR;
  45     assertFalse(
  46             "Adding bad pattern",
  47             fmt.addIfAbsent("other", "{0} {1} too many placeholders", status));
  48     assertEquals("adding bad pattern status", (int32_t)U_ILLEGAL_ARGUMENT_ERROR, status);
  49     status = U_ZERO_ERROR;
  50     assertFalse("isValid with no patterns", fmt.isValid());
  51     assertTrue(
  52             "Adding good pattern with no placeholders",
  53             fmt.addIfAbsent("zero", "no placeholder", status));
  54     assertTrue(
  55             "Adding good pattern",
  56             fmt.addIfAbsent("other", "{0} pounds", status));
  57     assertTrue("isValid with other", fmt.isValid());
  58     assertTrue(
  59             "Adding good pattern",
  60             fmt.addIfAbsent("one", "{0} pound", status));
  61
  62     assertEquals(
  63             "getByVariant",
  64             fmt.getByVariant("bad variant")->getTextWithNoArguments(),
  65             " pounds");
  66     assertEquals(
  67             "getByVariant",
  68             fmt.getByVariant("other")->getTextWithNoArguments(),
  69             " pounds");
  70     assertEquals(
  71             "getByVariant",
  72             fmt.getByVariant("one")->getTextWithNoArguments(),
  73             " pound");
  74     assertEquals(
  75             "getByVariant",
  76             fmt.getByVariant("few")->getTextWithNoArguments(),
  77             " pounds");
  78
  79     // Test copy constructor
  80     {
  81         QuantityFormatter copied(fmt);
  82         assertEquals(
  83                 "copied getByVariant",
  84                 copied.getByVariant("other")->getTextWithNoArguments(),
  85                 " pounds");
  86         assertEquals(
  87                 "copied getByVariant",
  88                 copied.getByVariant("one")->getTextWithNoArguments(),
  89                 " pound");
  90         assertEquals(
  91                 "copied getByVariant",
  92                 copied.getByVariant("few")->getTextWithNoArguments(),
  93                 " pounds");
  94     }
  95
  96     // Test assignment
  97     {
  98         QuantityFormatter assigned;
  99         assigned = fmt;
 100         assertEquals(
 101                 "assigned getByVariant",
 102                 assigned.getByVariant("other")->getTextWithNoArguments(),
 103                 " pounds");
 104         assertEquals(
 105                 "assigned getByVariant",
 106                 assigned.getByVariant("one")->getTextWithNoArguments(),
 107                 " pound");
 108         assertEquals(
 109                 "assigned getByVariant",
 110                 assigned.getByVariant("few")->getTextWithNoArguments(),
 111                 " pounds");
 112     }
 113
 114     // Test format.
 115     {
 116         LocalPointer<NumberFormat> numfmt(
 117                 NumberFormat::createInstance(Locale::getEnglish(), status));
 118         LocalPointer<PluralRules> plurrule(
 119                 PluralRules::forLocale("en", status));
 120         FieldPosition pos(FieldPosition::DONT_CARE);
 121         UnicodeString appendTo;
 122         assertEquals(
 123                 "format singular",
 124                 UnicodeString("1 pound"),
 125                 fmt.format(
 126                         1.0,
 127                         *numfmt,
 128                         *plurrule,
 129                         appendTo,
 130                         pos,
 131                         status), TRUE);
 132         appendTo.remove();
 133         assertEquals(
 134                 "format plural",
 135                 UnicodeString("2 pounds"),
 136                 fmt.format(
 137                         2.0,
 138                         *numfmt,
 139                         *plurrule,
 140                         appendTo,
 141                         pos,
 142                         status), TRUE);
 143     }
 144     fmt.reset();
 145     assertFalse("isValid after reset", fmt.isValid());
 146 #endif
 147     assertSuccess("", status);
 148 }
 149
 150 extern IntlTest *createQuantityFormatterTest() {
 151     return new QuantityFormatterTest();
 152 }