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, International Business Machines Corporation and *
6 * others. All Rights Reserved. *
7 *******************************************************************************
8 *
9 * File SCINUMBERFORMATTERTEST.CPP
10 *
11 *******************************************************************************
12 */
13 #include "unicode/utypes.h"
14
15 #include "intltest.h"
16
17 #if !UCONFIG_NO_FORMATTING
18
19 #include "unicode/scientificnumberformatter.h"
20 #include "unicode/numfmt.h"
21 #include "unicode/decimfmt.h"
22 #include "unicode/localpointer.h"
23
24 class ScientificNumberFormatterTest : public IntlTest {
25 public:
26 void runIndexedTest(int32_t index, UBool exec, const char*& name, char* par = nullptr) override;
27
28 private:
29 void TestBasic();
30 void TestFarsi();
31 void TestPlusSignInExponentMarkup();
32 void TestPlusSignInExponentSuperscript();
33 void TestFixedDecimalMarkup();
34 void TestFixedDecimalSuperscript();
35 };
36
runIndexedTest(int32_t index,UBool exec,const char * & name,char *)37 void ScientificNumberFormatterTest::runIndexedTest(
38 int32_t index, UBool exec, const char *&name, char *) {
39 if (exec) {
40 logln("TestSuite ScientificNumberFormatterTest: ");
41 }
42 TESTCASE_AUTO_BEGIN;
43 TESTCASE_AUTO(TestBasic);
44 TESTCASE_AUTO(TestFarsi);
45 TESTCASE_AUTO(TestPlusSignInExponentMarkup);
46 TESTCASE_AUTO(TestPlusSignInExponentSuperscript);
47 TESTCASE_AUTO(TestFixedDecimalMarkup);
48 TESTCASE_AUTO(TestFixedDecimalSuperscript);
49 TESTCASE_AUTO_END;
50 }
51
TestBasic()52 void ScientificNumberFormatterTest::TestBasic() {
53 UErrorCode status = U_ZERO_ERROR;
54 UnicodeString prefix("String: ");
55 UnicodeString appendTo(prefix);
56 LocalPointer<ScientificNumberFormatter> fmt(
57 ScientificNumberFormatter::createMarkupInstance(
58 "en" , "<sup>", "</sup>", status));
59 if (!assertSuccess("Can't create ScientificNumberFormatter", status)) {
60 return;
61 }
62 fmt->format(1.23456e-78, appendTo, status);
63 const char *expected = "String: 1.23456\\u00d710<sup>-78</sup>";
64 assertEquals(
65 "markup style",
66 UnicodeString(expected).unescape(),
67 appendTo);
68
69 // Test superscript style
70 fmt.adoptInstead(
71 ScientificNumberFormatter::createSuperscriptInstance(
72 "en", status));
73 if (!assertSuccess("Can't create ScientificNumberFormatter2", status)) {
74 return;
75 }
76 appendTo = prefix;
77 fmt->format(1.23456e-78, appendTo, status);
78 expected = "String: 1.23456\\u00d710\\u207b\\u2077\\u2078";
79 assertEquals(
80 "superscript style",
81 UnicodeString(expected).unescape(),
82 appendTo);
83
84 // Test clone
85 LocalPointer<ScientificNumberFormatter> fmt3(fmt->clone());
86 if (fmt3.isNull()) {
87 errln("Allocating clone failed.");
88 return;
89 }
90 appendTo = prefix;
91 fmt3->format(1.23456e-78, appendTo, status);
92 expected = "String: 1.23456\\u00d710\\u207b\\u2077\\u2078";
93 assertEquals(
94 "superscript style",
95 UnicodeString(expected).unescape(),
96 appendTo);
97 assertSuccess("", status);
98 }
99
TestFarsi()100 void ScientificNumberFormatterTest::TestFarsi() {
101 UErrorCode status = U_ZERO_ERROR;
102 UnicodeString prefix("String: ");
103 UnicodeString appendTo(prefix);
104 LocalPointer<ScientificNumberFormatter> fmt(
105 ScientificNumberFormatter::createMarkupInstance(
106 "fa", "<sup>", "</sup>", status));
107 if (!assertSuccess("Can't create ScientificNumberFormatter", status)) {
108 return;
109 }
110 fmt->format(1.23456e-78, appendTo, status);
111 const char *expected = "String: \\u06F1\\u066B\\u06F2\\u06F3\\u06F4\\u06F5\\u06F6\\u00d7\\u06F1\\u06F0<sup>\\u200E\\u2212\\u06F7\\u06F8</sup>";
112 assertEquals(
113 "",
114 UnicodeString(expected).unescape(),
115 appendTo);
116 assertSuccess("", status);
117 }
118
TestPlusSignInExponentMarkup()119 void ScientificNumberFormatterTest::TestPlusSignInExponentMarkup() {
120 UErrorCode status = U_ZERO_ERROR;
121 LocalPointer<DecimalFormat> decfmt(dynamic_cast<DecimalFormat*>(NumberFormat::createScientificInstance("en", status)));
122 if (U_FAILURE(status)) {
123 dataerrln("Failed call NumberFormat::createScientificInstance(\"en\", status) - %s", u_errorName(status));
124 return;
125 }
126 decfmt->applyPattern("0.00E+0", status);
127 if (!assertSuccess("", status)) {
128 return;
129 }
130 UnicodeString appendTo;
131 LocalPointer<ScientificNumberFormatter> fmt(
132 ScientificNumberFormatter::createMarkupInstance(
133 new DecimalFormat(*decfmt), "<sup>", "</sup>", status));
134 if (!assertSuccess("Can't create ScientificNumberFormatter", status)) {
135 return;
136 }
137 fmt->format(6.02e23, appendTo, status);
138 const char *expected = "6.02\\u00d710<sup>+23</sup>";
139 assertEquals(
140 "",
141 UnicodeString(expected).unescape(),
142 appendTo);
143 assertSuccess("", status);
144 }
145
TestPlusSignInExponentSuperscript()146 void ScientificNumberFormatterTest::TestPlusSignInExponentSuperscript() {
147 UErrorCode status = U_ZERO_ERROR;
148 LocalPointer<DecimalFormat> decfmt(dynamic_cast<DecimalFormat*>(NumberFormat::createScientificInstance("en", status)));
149 if (U_FAILURE(status)) {
150 dataerrln("Failed call NumberFormat::createScientificInstance(\"en\", status) - %s", u_errorName(status));
151 return;
152 }
153 decfmt->applyPattern("0.00E+0", status);
154 if (!assertSuccess("", status)) {
155 return;
156 }
157 UnicodeString appendTo;
158 LocalPointer<ScientificNumberFormatter> fmt(
159 ScientificNumberFormatter::createSuperscriptInstance(
160 new DecimalFormat(*decfmt), status));
161 if (!assertSuccess("Can't create ScientificNumberFormatter", status)) {
162 return;
163 }
164 fmt->format(6.02e23, appendTo, status);
165 const char *expected = "6.02\\u00d710\\u207a\\u00b2\\u00b3";
166 assertEquals(
167 "",
168 UnicodeString(expected).unescape(),
169 appendTo);
170 assertSuccess("", status);
171 }
172
TestFixedDecimalMarkup()173 void ScientificNumberFormatterTest::TestFixedDecimalMarkup() {
174 UErrorCode status = U_ZERO_ERROR;
175 LocalPointer<DecimalFormat> decfmt(dynamic_cast<DecimalFormat*>(NumberFormat::createInstance("en", status)));
176 if (assertSuccess("NumberFormat::createInstance", status, true) == false) {
177 return;
178 }
179 LocalPointer<ScientificNumberFormatter> fmt(
180 ScientificNumberFormatter::createMarkupInstance(
181 new DecimalFormat(*decfmt), "<sup>", "</sup>", status));
182 if (!assertSuccess("Can't create ScientificNumberFormatter", status)) {
183 return;
184 }
185 UnicodeString appendTo;
186 fmt->format(123456.0, appendTo, status);
187 const char *expected = "123,456";
188 assertEquals(
189 "",
190 UnicodeString(expected).unescape(),
191 appendTo);
192 assertSuccess("", status);
193 }
194
TestFixedDecimalSuperscript()195 void ScientificNumberFormatterTest::TestFixedDecimalSuperscript() {
196 UErrorCode status = U_ZERO_ERROR;
197 LocalPointer<DecimalFormat> decfmt(dynamic_cast<DecimalFormat*>(NumberFormat::createInstance("en", status)));
198 if (assertSuccess("NumberFormat::createInstance", status, true) == false) {
199 return;
200 }
201 LocalPointer<ScientificNumberFormatter> fmt(
202 ScientificNumberFormatter::createSuperscriptInstance(
203 new DecimalFormat(*decfmt), status));
204 if (!assertSuccess("Can't create ScientificNumberFormatter", status)) {
205 return;
206 }
207 UnicodeString appendTo;
208 fmt->format(123456.0, appendTo, status);
209 const char *expected = "123,456";
210 assertEquals(
211 "",
212 UnicodeString(expected).unescape(),
213 appendTo);
214 assertSuccess("", status);
215 }
216
createScientificNumberFormatterTest()217 extern IntlTest *createScientificNumberFormatterTest() {
218 return new ScientificNumberFormatterTest();
219 }
220
221 #endif /* !UCONFIG_NO_FORMATTING */
222