2150 |
mathias |
1 |
if(!dojo._hasResource["tests.number"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
|
|
|
2 |
dojo._hasResource["tests.number"] = true;
|
|
|
3 |
dojo.provide("tests.number");
|
|
|
4 |
|
|
|
5 |
dojo.require("dojo.number");
|
|
|
6 |
|
|
|
7 |
/**
|
|
|
8 |
* Refer to ICU4J's NumberFormatTest.expect(...)
|
|
|
9 |
*/
|
|
|
10 |
tests.number.check=function(t,options,sourceInput,expectResult){
|
|
|
11 |
tests.number.checkFormatParseCycle(t, t,options,sourceInput,expectResult,false);
|
|
|
12 |
tests.number.checkParse(t, t,options,expectResult,sourceInput);
|
|
|
13 |
}
|
|
|
14 |
|
|
|
15 |
/**
|
|
|
16 |
* Perform a single formatting check or a backward check
|
|
|
17 |
* backward check:number1 -(formatted)-> string1 -(parsed)-> number2 -(formated)-> string2
|
|
|
18 |
* then number should == number2; string1 should == string2
|
|
|
19 |
*/
|
|
|
20 |
tests.number.checkFormatParseCycle=function(t,options,sourceInput,expectResult,
|
|
|
21 |
backwardCheck/*boolean,indicates whether need a backward chain check,like formate->parse->format*/){
|
|
|
22 |
if(null != options){
|
|
|
23 |
var pattern = options.pattern;
|
|
|
24 |
var locale = options.locale;
|
|
|
25 |
//TODO: add more fields
|
|
|
26 |
}
|
|
|
27 |
|
|
|
28 |
//print("\n");
|
|
|
29 |
var str = null==pattern?"default":pattern;
|
|
|
30 |
//print("pattern:" + str + "| locale:" + locale);
|
|
|
31 |
//print("input:" + sourceInput);
|
|
|
32 |
var result = dojo.number.format(sourceInput,options);
|
|
|
33 |
//print("result:" + result);
|
|
|
34 |
if(null != expectResult){
|
|
|
35 |
t.is(expectResult,result);
|
|
|
36 |
}
|
|
|
37 |
if(backwardCheck){
|
|
|
38 |
var resultParsed = dojo.number.parse(result,options);
|
|
|
39 |
//print("resultParsed:" + resultParsed);
|
|
|
40 |
if(!tests.number._decimalNumberDiff(sourceInput,resultParsed)){
|
|
|
41 |
t.is(sourceInput,resultParsed);
|
|
|
42 |
}
|
|
|
43 |
var resultParsedReformatted = dojo.number.format(resultParsed,options);
|
|
|
44 |
//print("resultParsedReformatted:" + resultParsedReformatted);
|
|
|
45 |
if(!tests.number._decimalNumberDiff(result,resultParsedReformatted)){
|
|
|
46 |
t.is(result,resultParsedReformatted);
|
|
|
47 |
}
|
|
|
48 |
}
|
|
|
49 |
}
|
|
|
50 |
|
|
|
51 |
/**
|
|
|
52 |
* Perform a single parsing check
|
|
|
53 |
*/
|
|
|
54 |
tests.number.checkParse=function(t,options,sourceInput,expectResult){
|
|
|
55 |
var str = "default";
|
|
|
56 |
if(null != options && null != options.pattern){
|
|
|
57 |
str = options.pattern;
|
|
|
58 |
}
|
|
|
59 |
//print("input:" + sourceInput);
|
|
|
60 |
var result = dojo.number.parse(sourceInput,options);
|
|
|
61 |
//print("result :" + result);
|
|
|
62 |
if(null != expectResult){
|
|
|
63 |
t.is(expectResult,result);
|
|
|
64 |
}
|
|
|
65 |
}
|
|
|
66 |
|
|
|
67 |
/**
|
|
|
68 |
* //TODO:Round a given number
|
|
|
69 |
*/
|
|
|
70 |
tests.number.rounding = function(t,number,maxFractionDigits,expected){
|
|
|
71 |
var pattern="#0.";
|
|
|
72 |
for(var i=0; i<maxFractionDigits; i++){pattern += "#";}
|
|
|
73 |
var result = dojo.number.format(number,{pattern:pattern});
|
|
|
74 |
t.is(expected,result);
|
|
|
75 |
}
|
|
|
76 |
|
|
|
77 |
/**
|
|
|
78 |
* Run a batch parsing
|
|
|
79 |
*/
|
|
|
80 |
function runBatchParse(options,dataArray/*array*/,pass/*boolean*/){
|
|
|
81 |
var exception = null;
|
|
|
82 |
var result;
|
|
|
83 |
var i=0;
|
|
|
84 |
var str = (null==options.pattern)?"default":options.pattern;
|
|
|
85 |
|
|
|
86 |
//print("\n");
|
|
|
87 |
for(; i<dataArray.length; i++){
|
|
|
88 |
try{
|
|
|
89 |
//print("["+i+"]"+"input:"+dataArray[i]);
|
|
|
90 |
result = dojo.number.parse(dataArray[i],options);
|
|
|
91 |
if(isNaN(result)){
|
|
|
92 |
throw "\"" + dataArray[i] + "\" is parsed to NaN with pattern " + str;
|
|
|
93 |
}
|
|
|
94 |
//print("["+i+"]"+"output:"+result);
|
|
|
95 |
}catch(e){
|
|
|
96 |
exception = e;
|
|
|
97 |
break;
|
|
|
98 |
}
|
|
|
99 |
}
|
|
|
100 |
|
|
|
101 |
if(!pass && (exception == null)) {
|
|
|
102 |
throw "runBatchParse() - stric parse failed, no exception when parsing illegal data";
|
|
|
103 |
}else if(exception != null){
|
|
|
104 |
if(!pass && i == 0){
|
|
|
105 |
//strict parsing should fail for all the dataArray elements as expected
|
|
|
106 |
//pass condition for strict parsing
|
|
|
107 |
return;
|
|
|
108 |
}
|
|
|
109 |
throw "runBatchParse() failed: " + exception;
|
|
|
110 |
}
|
|
|
111 |
}
|
|
|
112 |
|
|
|
113 |
/**
|
|
|
114 |
* Check whether the given two numbers differ under the decimal bound
|
|
|
115 |
*
|
|
|
116 |
*/
|
|
|
117 |
tests.number._decimalNumberDiff = function(num1,num2){
|
|
|
118 |
//TODO: should be more accurate when dojo.number finish rounding in the future
|
|
|
119 |
var diffBound = 1e-3;
|
|
|
120 |
var diff = num1 - num2;
|
|
|
121 |
//print("Math.abs(diff) " + Math.abs(diff));
|
|
|
122 |
if(Math.abs(diff) < diffBound ){
|
|
|
123 |
return true;
|
|
|
124 |
}else if(isNaN(Math.abs(diff))){
|
|
|
125 |
var s = num1.toString().split(num2);
|
|
|
126 |
s[1] = s[1].replace(",","0");
|
|
|
127 |
s[1] = s[1].replace('\u066b','0');
|
|
|
128 |
return (new Number(s[1])< diffBound);
|
|
|
129 |
}
|
|
|
130 |
return false;
|
|
|
131 |
}
|
|
|
132 |
|
|
|
133 |
tests.register("tests.number",
|
|
|
134 |
[
|
|
|
135 |
{
|
|
|
136 |
// Test formatting and parsing of currencies in various locales pre-built in dojo.cldr
|
|
|
137 |
// NOTE: we can't set djConfig.extraLocale before bootstrapping unit tests, so directly
|
|
|
138 |
// load resources here for specific locales:
|
|
|
139 |
|
|
|
140 |
name: "number",
|
|
|
141 |
setUp: function(){
|
|
|
142 |
var partLocaleList = ["en-us", "fr-fr", "de-de"];
|
|
|
143 |
|
|
|
144 |
for(var i = 0 ; i < partLocaleList.length; i ++){
|
|
|
145 |
dojo.requireLocalization("dojo.cldr","number",partLocaleList[i], "zh-cn,en,en-ca,zh-tw,en-us,it,ja-jp,ROOT,de-de,es-es,fr,pt,ko-kr,es,de");
|
|
|
146 |
}
|
|
|
147 |
},
|
|
|
148 |
runTest: function(t){
|
|
|
149 |
}
|
|
|
150 |
},
|
|
|
151 |
{
|
|
|
152 |
name: "format", // old tests
|
|
|
153 |
runTest: function(t){
|
|
|
154 |
|
|
|
155 |
t.is("0123", dojo.number.format(123, {pattern: "0000"}));
|
|
|
156 |
t.is("-12,34,567.890", dojo.number.format(-1234567.89, {pattern: "#,##,##0.000##"}));
|
|
|
157 |
t.is("-12,34,567.89012", dojo.number.format(-1234567.890123, {pattern: "#,##,##0.000##"}));
|
|
|
158 |
t.is("(1,234,567.89012)", dojo.number.format(-1234567.890123, {pattern: "#,##0.000##;(#,##0.000##)"}));
|
|
|
159 |
t.is("(1,234,567.89012)", dojo.number.format(-1234567.890123, {pattern: "#,##0.000##;(#)"}));
|
|
|
160 |
t.is("50.1%", dojo.number.format(0.501, {pattern: "#0.#%"}));
|
|
|
161 |
t.is("98", dojo.number.format(1998, {pattern: "00"}));
|
|
|
162 |
t.is("01998", dojo.number.format(1998, {pattern: "00000"}));
|
|
|
163 |
t.is("0.13", dojo.number.format(0.125, {pattern: "0.##"})); //NOTE: expects round_half_up, not round_half_even
|
|
|
164 |
t.is("0.1250", dojo.number.format(0.125, {pattern: "0.0000"}));
|
|
|
165 |
t.is("0.1", dojo.number.format(0.100004, {pattern: "0.####"}));
|
|
|
166 |
|
|
|
167 |
t.is("-12", dojo.number.format(-12.3, {places:0, locale: "en-us"}));
|
|
|
168 |
t.is("-1,234,567.89", dojo.number.format(-1234567.89, {locale: "en-us"}));
|
|
|
169 |
// t.is("-12,34,567.89", dojo.number.format(-1234567.89, {locale: "en-in"}));
|
|
|
170 |
t.is("-1,234,568", dojo.number.format(-1234567.89, {places:0, locale: "en-us"}));
|
|
|
171 |
// t.is("-12,34,568", dojo.number.format(-1234567.89, {places:0, locale: "en-in"}));
|
|
|
172 |
t.is("-1\xa0000,10", dojo.number.format(-1000.1, {places:2, locale: "fr-fr"}));
|
|
|
173 |
t.is("-1,000.10", dojo.number.format(-1000.1, {places:2, locale: "en-us"}));
|
|
|
174 |
t.is("-1\xa0000,10", dojo.number.format(-1000.1, {places:2, locale: "fr-fr"}));
|
|
|
175 |
t.is("-1.234,56", dojo.number.format(-1234.56, {places:2, locale: "de-de"}));
|
|
|
176 |
t.is("-1,000.10", dojo.number.format(-1000.1, {places:2, locale: "en-us"}));
|
|
|
177 |
t.is("123.46%", dojo.number.format(1.23456, {places:2, locale: "en-us", type: "percent"}));
|
|
|
178 |
|
|
|
179 |
//rounding
|
|
|
180 |
t.is("-1,234,568", dojo.number.format(-1234567.89, {places:0, locale: "en-us"}));
|
|
|
181 |
// t.is("-12,34,568", dojo.number.format(-1234567.89, {places:0, locale: "en-in"}));
|
|
|
182 |
t.is("-1,000.11", dojo.number.format(-1000.114, {places:2, locale: "en-us"}));
|
|
|
183 |
t.is("-1,000.11", dojo.number.format(-1000.115, {places:2, locale: "en-us"}));
|
|
|
184 |
t.is("-1,000.12", dojo.number.format(-1000.116, {places:2, locale: "en-us"}));
|
|
|
185 |
t.is("-0.00", dojo.number.format(-0.0001, {places:2, locale: "en-us"}));
|
|
|
186 |
t.is("0.00", dojo.number.format(0, {places:2, locale: "en-us"}));
|
|
|
187 |
|
|
|
188 |
//change decimal places
|
|
|
189 |
t.is("-1\xa0000,100", dojo.number.format(-1000.1, {places:3, locale: "fr-fr"}));
|
|
|
190 |
t.is("-1,000.100", dojo.number.format(-1000.1, {places:3, locale: "en-us"}));
|
|
|
191 |
}
|
|
|
192 |
},
|
|
|
193 |
{
|
|
|
194 |
name: "parse", // old tests
|
|
|
195 |
runTest: function(t){
|
|
|
196 |
t.is(1000, dojo.number.parse("1000", {locale: "en-us"}));
|
|
|
197 |
t.is(1000.123, dojo.number.parse("1000.123", {locale: "en-us"}));
|
|
|
198 |
t.is(1000, dojo.number.parse("1,000", {locale: "en-us"}));
|
|
|
199 |
t.is(-1000, dojo.number.parse("-1000", {locale: "en-us"}));
|
|
|
200 |
t.is(-1000.123, dojo.number.parse("-1000.123", {locale: "en-us"}));
|
|
|
201 |
t.is(-1234567.89, dojo.number.parse("-1,234,567.89", {locale: "en-us"}));
|
|
|
202 |
t.is(-1234567.89, dojo.number.parse("-1 234 567,89", {locale: "fr-fr"}));
|
|
|
203 |
t.t(isNaN(dojo.number.parse("-1 234 567,89", {locale: "en-us"})));
|
|
|
204 |
|
|
|
205 |
t.t(isNaN(dojo.number.parse("10,00", {locale: "en-us"})));
|
|
|
206 |
t.t(isNaN(dojo.number.parse("1000.1", {locale: "fr-fr"})));
|
|
|
207 |
|
|
|
208 |
t.t(isNaN(dojo.number.parse("")));
|
|
|
209 |
t.t(isNaN(dojo.number.parse("abcd")));
|
|
|
210 |
|
|
|
211 |
//test whitespace
|
|
|
212 |
// t.is(-1234567, dojo.number.parse(" -1,234,567 ", {locale: "en-us"}));
|
|
|
213 |
|
|
|
214 |
// t.t(dojo.number.parse("9.1093826E-31"));
|
|
|
215 |
t.is(0.501, dojo.number.parse("50.1%", {pattern: "#0.#%"}));
|
|
|
216 |
|
|
|
217 |
t.is(123.4, dojo.number.parse("123.4", {pattern: "#0.#"}));
|
|
|
218 |
t.is(-123.4, dojo.number.parse("-123.4", {pattern: "#0.#"}));
|
|
|
219 |
t.is(123.4, dojo.number.parse("123.4", {pattern: "#0.#;(#0.#)"}));
|
|
|
220 |
t.is(-123.4, dojo.number.parse("(123.4)", {pattern: "#0.#;(#0.#)"}));
|
|
|
221 |
|
|
|
222 |
t.is(null, dojo.number.format("abcd", {pattern: "0000"}));
|
|
|
223 |
|
|
|
224 |
t.is(123, dojo.number.parse("123", {places:0}));
|
|
|
225 |
t.is(123, dojo.number.parse("123", {places:'0'}));
|
|
|
226 |
t.is(123.4, dojo.number.parse("123.4", {places:1}));
|
|
|
227 |
t.is(123.45, dojo.number.parse("123.45", {places:'1,3'}));
|
|
|
228 |
t.is(123.45, dojo.number.parse("123.45", {places:'0,2'}));
|
|
|
229 |
}
|
|
|
230 |
},
|
|
|
231 |
{
|
|
|
232 |
name: "format_icu4j3_6",
|
|
|
233 |
runTest: function(t){
|
|
|
234 |
|
|
|
235 |
/*************************************************************************************************
|
|
|
236 |
* Evan:The following test cases are referred from ICU4J 3.6 (NumberFormatTest etc.)
|
|
|
237 |
* see http://icu.sourceforge.net/download/3.6.html#ICU4J
|
|
|
238 |
*************************************************************************************************/
|
|
|
239 |
|
|
|
240 |
|
|
|
241 |
/**
|
|
|
242 |
* In ICU4J, testing logic for NumberFormat.format() is seperated into
|
|
|
243 |
* differernt single tese cases. So part of these logic are
|
|
|
244 |
* collected together in this single method.
|
|
|
245 |
*
|
|
|
246 |
* !!Failed cases are as follows:
|
|
|
247 |
* 1.1234567890987654321234567890987654321 should be formatted as
|
|
|
248 |
* 1,234,567,890,987,654,321,234,567,890,987,654,321 with all the default parameters,
|
|
|
249 |
* but got 1.234 instead, may due to the unimplemeted exponent.
|
|
|
250 |
* 2.\u00a4 and ' are not replaced
|
|
|
251 |
* with pattern "'*&'' '\u00a4' ''&*' #,##0.00"
|
|
|
252 |
* 1.0 should be formatted to "*&' Re. '&* 1.00",but got "'*&'' '\u00a4' ''&*' 1.00" instead
|
|
|
253 |
* etc.
|
|
|
254 |
*
|
|
|
255 |
*/
|
|
|
256 |
//print("test_number_format_icu4j3_6() start..............");
|
|
|
257 |
/* !!Failed case, 1.234 returned instead
|
|
|
258 |
//refer to ICU4J's NumberFormatTest.TestCoverage()
|
|
|
259 |
var bigNum = 1234567890987654321234567890987654321;
|
|
|
260 |
var expectResult = "1,234,567,890,987,654,321,234,567,890,987,654,321";
|
|
|
261 |
tests.number.checkFormatParseCycle(t, null,bigNum,expectResult,false);
|
|
|
262 |
*/
|
|
|
263 |
|
|
|
264 |
//in icu4j should throw out an exception when formatting a string,
|
|
|
265 |
//but it seems dojo.number.format can deal with strings
|
|
|
266 |
//return 123,456,789
|
|
|
267 |
dojo.number.format("123456789");
|
|
|
268 |
|
|
|
269 |
//!!Failed case, \u00a4 and ' are not replaced
|
|
|
270 |
/*
|
|
|
271 |
var options = {pattern:"'*&'' '\u00a4' ''&*' #,##0.00",locale:"en-us"};
|
|
|
272 |
tests.number.check(t, options,1.0, "*&' Re. '&* 1.00");
|
|
|
273 |
tests.number.check(t, options,-2.0, "-*&' Rs. '&* 2.00");
|
|
|
274 |
|
|
|
275 |
options = {pattern:"#,##0.00 '*&'' '\u00a4' ''&*'",locale:"en-us"};
|
|
|
276 |
tests.number.check(t, options,1.0,"1.00 *&' Re. '&*");
|
|
|
277 |
tests.number.check(t, options,-2.0,"-2.00 *&' Rs. '&*");
|
|
|
278 |
*/
|
|
|
279 |
//print("test_number_format_icu4j3_6() end..............\n");
|
|
|
280 |
}
|
|
|
281 |
},
|
|
|
282 |
{
|
|
|
283 |
name: "format_patterns",
|
|
|
284 |
runTest: function(t){
|
|
|
285 |
|
|
|
286 |
/**
|
|
|
287 |
* Refer to ICU4J's NumberFormatTest.TestPatterns() which now only coveres us locale
|
|
|
288 |
*/
|
|
|
289 |
//print("test_number_format_Patterns() start..............");
|
|
|
290 |
var patterns = (["#0.#", "#0.", "#.0", "#"]);
|
|
|
291 |
var patternsLength = patterns.length;
|
|
|
292 |
var num = (["0","0", "0.0", "0"]);
|
|
|
293 |
var options;
|
|
|
294 |
//icu4j result seems doesn't work as:
|
|
|
295 |
//var num = (["0","0.", ".0", "0"]);
|
|
|
296 |
for (var i=0; i<patternsLength; ++i)
|
|
|
297 |
{
|
|
|
298 |
options = {pattern:patterns[i]};
|
|
|
299 |
tests.number.checkFormatParseCycle(t, options,0,num[i],false);
|
|
|
300 |
}
|
|
|
301 |
|
|
|
302 |
//!!Failed case
|
|
|
303 |
//In ICU4J:
|
|
|
304 |
// unquoted special characters in the suffix are illegal
|
|
|
305 |
// so "000.000|###" is illegal; "000.000'|###'" is legal
|
|
|
306 |
//dojo.number.format:
|
|
|
307 |
// when formatting 1.2 with illegal pattern "000.000|###"
|
|
|
308 |
// no exception was thrown but got "001.200|###" instead.
|
|
|
309 |
|
|
|
310 |
/*
|
|
|
311 |
patterns = (["000.000|###","000.000'|###'"]);
|
|
|
312 |
var exception = false;
|
|
|
313 |
var result;
|
|
|
314 |
for(var i = 0; i < patterns.length; i ++){
|
|
|
315 |
try{
|
|
|
316 |
//"001.200'|###'" is return for "000.000'|###'"
|
|
|
317 |
//"001.200|###" is return for "000.000|###"
|
|
|
318 |
result = dojo.number.format(1.2,{pattern:patterns[i]});
|
|
|
319 |
print("["+i+"] 1.2 is formatted to " + result + " with pattern " + patterns[i]);
|
|
|
320 |
}catch(e){
|
|
|
321 |
exception = true;
|
|
|
322 |
}
|
|
|
323 |
if(exception && i==1){
|
|
|
324 |
throw "["+i+"]Failed when formatting 1.2 using legal pattern " + patterns[i];
|
|
|
325 |
}else if(!exception && i==0){
|
|
|
326 |
throw "["+i+"]Failed when formatting 1.2 using illegal pattern " + patterns[i];
|
|
|
327 |
}
|
|
|
328 |
}*/
|
|
|
329 |
//print("test_number_format_Patterns() end..............\n");
|
|
|
330 |
}
|
|
|
331 |
},
|
|
|
332 |
{
|
|
|
333 |
name: "exponential",
|
|
|
334 |
runTest: function(t){
|
|
|
335 |
/**
|
|
|
336 |
* TODO: For dojo.number future version
|
|
|
337 |
* Refer to ICU4J's NumberFormatTest.TestExponential()
|
|
|
338 |
*/
|
|
|
339 |
}
|
|
|
340 |
},
|
|
|
341 |
{
|
|
|
342 |
name: "format_quotes",
|
|
|
343 |
runTest: function(t){
|
|
|
344 |
/**
|
|
|
345 |
* TODO: Failed case
|
|
|
346 |
* Refer to ICU4J's NumberFormatTest.TestQuotes()
|
|
|
347 |
*/
|
|
|
348 |
//print("test_number_format_Quotes() start..............");
|
|
|
349 |
//TODO: add more locales
|
|
|
350 |
|
|
|
351 |
//TODO:!!Failed case
|
|
|
352 |
//Pattern "s'aa''s'c#" should format 6666 to "saa'sc6666", but got s'aa''s'c6666 instead
|
|
|
353 |
// is this case necessary?
|
|
|
354 |
/*
|
|
|
355 |
var pattern = "s'aa''s'c#";
|
|
|
356 |
var result = dojo.number.format(6666,{pattern:pattern,locale:"en-us"});
|
|
|
357 |
var expectResult = "saa'sc6666";
|
|
|
358 |
t.is(expectResult,result);
|
|
|
359 |
*/
|
|
|
360 |
//print("test_number_format_Quotes() end..............");
|
|
|
361 |
}
|
|
|
362 |
},
|
|
|
363 |
{
|
|
|
364 |
name: "format_rounding",
|
|
|
365 |
runTest: function(t){
|
|
|
366 |
/**
|
|
|
367 |
* Refer to ICU4J's NumberFormatTest.TestRounding487() and NumberFormatTest.TestRounding()
|
|
|
368 |
*/
|
|
|
369 |
//print("test_number_format_rounding() start..............");
|
|
|
370 |
tests.number.rounding(t,0.000179999, 5, "0.00018");
|
|
|
371 |
tests.number.rounding(t,0.00099, 4, "0.001");
|
|
|
372 |
tests.number.rounding(t,17.6995, 3, "17.7");
|
|
|
373 |
tests.number.rounding(t,15.3999, 0, "15");
|
|
|
374 |
tests.number.rounding(t,-29.6, 0, "-30");
|
|
|
375 |
|
|
|
376 |
//TODO refer to NumberFormatTest.TestRounding()
|
|
|
377 |
|
|
|
378 |
//print("test_number_format_rounding() end..............");
|
|
|
379 |
}
|
|
|
380 |
},
|
|
|
381 |
{
|
|
|
382 |
name: "format_scientific",
|
|
|
383 |
runTest: function(t){
|
|
|
384 |
/**
|
|
|
385 |
* TODO: For dojo.number future version
|
|
|
386 |
* Refer to ICU4J's NumberFormatTest.TestScientific()- Exponential testing
|
|
|
387 |
* Refer to ICU4J's NumberFormatTest.TestScientific2()
|
|
|
388 |
* Refer to ICU4J's NumberFormatTest.TestScientificGrouping()
|
|
|
389 |
*/
|
|
|
390 |
}
|
|
|
391 |
},
|
|
|
392 |
{
|
|
|
393 |
name: "format_perMill",
|
|
|
394 |
runTest: function(t){
|
|
|
395 |
/**
|
|
|
396 |
* TODO: Failed case
|
|
|
397 |
* Refer to ICU4J's NumberFormatTest.TestPerMill()
|
|
|
398 |
*/
|
|
|
399 |
//print("test_number_format_PerMill() start..............");
|
|
|
400 |
var pattern;
|
|
|
401 |
var result;
|
|
|
402 |
var expectResult;
|
|
|
403 |
|
|
|
404 |
//TODO: !!Failed case - ###.###\u2030(\u2030 is ‰)
|
|
|
405 |
//Pattern ###.###\u2030 should format 0.4857 as 485.7\u2030,but got 485.700\u2030 instead
|
|
|
406 |
pattern = "###.###\u2030";
|
|
|
407 |
expectResult = "485.7\u2030";
|
|
|
408 |
result = dojo.number.format(0.4857,{pattern:pattern});
|
|
|
409 |
t.is(expectResult,result);
|
|
|
410 |
|
|
|
411 |
//TODO: !!Failed mile percent case - ###.###m
|
|
|
412 |
//Pattern "###.###m" should format 0.4857 to 485.7m, but got 0.485m instead
|
|
|
413 |
/*
|
|
|
414 |
pattern = "###.###m";
|
|
|
415 |
expectResult = "485.7m";
|
|
|
416 |
result = dojo.number.format(0.4857,{pattern:pattern,locale:"en"});
|
|
|
417 |
t.is(expectResult,result);
|
|
|
418 |
*/
|
|
|
419 |
//print("test_number_format_PerMill() end..............\n");
|
|
|
420 |
}
|
|
|
421 |
},
|
|
|
422 |
{
|
|
|
423 |
name: "format_grouping",
|
|
|
424 |
runTest: function(t){
|
|
|
425 |
/**
|
|
|
426 |
* Only test en-us and en-in
|
|
|
427 |
* Refer to ICU4J's NumberFormatTest.TestSecondaryGrouping()
|
|
|
428 |
*/
|
|
|
429 |
//print("test_number_format_Grouping() start..............");
|
|
|
430 |
//primary grouping
|
|
|
431 |
var sourceInput = 123456789;
|
|
|
432 |
var expectResult = "12,34,56,789";
|
|
|
433 |
var options = {pattern:"#,##,###",locale:"en-us"};
|
|
|
434 |
|
|
|
435 |
//step1: 123456789 formated=> 12,34,56,789
|
|
|
436 |
//step2:12,34,56,789 parsed=> 123456789 => formated => 12,34,56,789
|
|
|
437 |
tests.number.checkFormatParseCycle(t, options,sourceInput,expectResult,true);
|
|
|
438 |
|
|
|
439 |
//TODO: sencondary grouping not implemented yet ?
|
|
|
440 |
//Pattern "#,###" and secondaryGroupingSize=4 should format 123456789 to "12,3456,789"
|
|
|
441 |
|
|
|
442 |
//Special case for "en-in" locale
|
|
|
443 |
//1876543210 should be formated as 1,87,65,43,210 in "en-in" (India)
|
|
|
444 |
/*
|
|
|
445 |
sourceInput = 1876543210;
|
|
|
446 |
expectResult = "1,87,65,43,210";
|
|
|
447 |
var result = dojo.number.format(sourceInput,{locale:"en-in"});
|
|
|
448 |
t.is(expectResult,result);
|
|
|
449 |
*/
|
|
|
450 |
//print("test_number_format_Grouping() end..............\n");
|
|
|
451 |
}
|
|
|
452 |
},
|
|
|
453 |
{
|
|
|
454 |
name: "format_pad",
|
|
|
455 |
runTest: function(t){
|
|
|
456 |
/**
|
|
|
457 |
* TODO:!!Failed cases:
|
|
|
458 |
* According to ICU4J test criteria:
|
|
|
459 |
* 1.with pattern "*^##.##":
|
|
|
460 |
* 0 should be formatted to "^^^^0",but got "*^0" instead,
|
|
|
461 |
* -1.3 should be formatted to "^-1.3",but got "-*^1.3" instead.
|
|
|
462 |
*
|
|
|
463 |
* 2.with pattern "##0.0####*_ 'g-m/s^2'" :
|
|
|
464 |
* 0 should be formatted to "0.0______ g-m/s^2",but got ":0.0*_ 'g-m/s^2'" instead
|
|
|
465 |
* 1.0/3 should be formatted to "0.33333__ g-m/s^2",but got "0.33333*_ 'g-m/s^2'" instead
|
|
|
466 |
*
|
|
|
467 |
* 3.with pattern "*x#,###,###,##0.0#;*x(###,###,##0.0#)":
|
|
|
468 |
* -10 should be formatted to "xxxxxxxxxx(10.0)",but got "*x(10.0)" instead.
|
|
|
469 |
* 10 should be formatted to "xxxxxxxxxxxx10.0",but got "*x10.0" instead.
|
|
|
470 |
* ......
|
|
|
471 |
* -1120456.37 should be formatted to "xx(1,120,456.37)",but got "*x(1,120,456.37)" instead.
|
|
|
472 |
* 1120456.37 should be formatted to "xxxx1,120,456.37",but got "*x1,120,456.37" instead.
|
|
|
473 |
* -1252045600.37 should be formatted to "(1,252,045,600.37)",but got "*x(1,252,045,600.37)" instead.
|
|
|
474 |
* 1252045600.37 should be formatted to "10,252,045,600.37",but got "*x10,252,045,600.37" instead.
|
|
|
475 |
*
|
|
|
476 |
* 4.with pattern "#,###,###,##0.0#*x;(###,###,##0.0#*x)"
|
|
|
477 |
* -10 should be formatted to (10.0xxxxxxxxxx),but got "(10.0*x)" instead.
|
|
|
478 |
* 10 should be formatted to "10.0xxxxxxxxxxxx",but got "10.0*x" instead.
|
|
|
479 |
* ......
|
|
|
480 |
* -1120456.37 should be formatted to "(1,120,456.37xx)",but got "(1,120,456.37*x)" instead.
|
|
|
481 |
* 1120456.37 should be formatted to "xxxx1,120,456.37",but got "1,120,456.37*x" instead.
|
|
|
482 |
* -1252045600.37 should be formatted to "(1,252,045,600.37)",but got "(1,252,045,600.37*x)" instead.
|
|
|
483 |
* 1252045600.37 should be formatted to ""10,252,045,600.37"",but got "10,252,045,600.37*x" instead.*
|
|
|
484 |
*
|
|
|
485 |
* Refer to ICU4J's NumberFormatTest.TestPad()
|
|
|
486 |
*/
|
|
|
487 |
/*
|
|
|
488 |
function test_number_format_pad(){
|
|
|
489 |
var locale = "en-us";
|
|
|
490 |
print("test_number_format_Pad() start..............");
|
|
|
491 |
var options = {pattern:"*^##.##",locale:locale};
|
|
|
492 |
|
|
|
493 |
tests.number.check(t, options,0,"^^^^0");
|
|
|
494 |
tests.number.check(t, options,-1.3,"^-1.3");
|
|
|
495 |
|
|
|
496 |
|
|
|
497 |
options = {pattern:"##0.0####*_ 'g-m/s^2'",locale:locale};
|
|
|
498 |
tests.number.check(t, options,0,"0.0______ g-m/s^2");
|
|
|
499 |
tests.number.checkFormatParseCycle(t, options,1.0/3,"0.33333__ g-m/s^2",true);
|
|
|
500 |
|
|
|
501 |
//exponent not implemented
|
|
|
502 |
//options = {pattern:"##0.0####E0*_ 'g-m/s^2'",locale:locale};
|
|
|
503 |
//tests.number.check(t, options,0,"0.0E0______ g-m/s^2");
|
|
|
504 |
//tests.number.checkFormatParseCycle(t, options,1.0/3,"333.333E-3_ g-m/s^2",true);
|
|
|
505 |
|
|
|
506 |
// Test padding before a sign
|
|
|
507 |
options = {pattern:"*x#,###,###,##0.0#;*x(###,###,##0.0#)",locale:locale};
|
|
|
508 |
|
|
|
509 |
tests.number.check(t, options,-10,"xxxxxxxxxx(10.0)");
|
|
|
510 |
tests.number.check(t, options,-1000, "xxxxxxx(1,000.0)");
|
|
|
511 |
tests.number.check(t, options,-1000000, "xxx(1,000,000.0)");
|
|
|
512 |
tests.number.check(t, options,-100.37, "xxxxxxxx(100.37)");
|
|
|
513 |
tests.number.check(t, options,-10456.37, "xxxxx(10,456.37)");
|
|
|
514 |
tests.number.check(t, options,-1120456.37, "xx(1,120,456.37)");
|
|
|
515 |
tests.number.check(t, options,-112045600.37, "(112,045,600.37)");
|
|
|
516 |
tests.number.check(t, options,-1252045600.37, "(1,252,045,600.37)");
|
|
|
517 |
|
|
|
518 |
|
|
|
519 |
tests.number.check(t, options,10, "xxxxxxxxxxxx10.0");
|
|
|
520 |
tests.number.check(t, options,1000, "xxxxxxxxx1,000.0");
|
|
|
521 |
tests.number.check(t, options,1000000, "xxxxx1,000,000.0");
|
|
|
522 |
tests.number.check(t, options,100.37, "xxxxxxxxxx100.37");
|
|
|
523 |
tests.number.check(t, options,10456.37, "xxxxxxx10,456.37");
|
|
|
524 |
tests.number.check(t, options,1120456.37, "xxxx1,120,456.37");
|
|
|
525 |
tests.number.check(t, options,112045600.37, "xx112,045,600.37");
|
|
|
526 |
tests.number.check(t, options,10252045600.37, "10,252,045,600.37");
|
|
|
527 |
|
|
|
528 |
// Test padding between a sign and a number
|
|
|
529 |
options = {pattern:"#,###,###,##0.0#*x;(###,###,##0.0#*x)",locale:locale};
|
|
|
530 |
tests.number.check(t, options, -10, "(10.0xxxxxxxxxx)");
|
|
|
531 |
tests.number.check(t, options, -1000, "(1,000.0xxxxxxx)");
|
|
|
532 |
tests.number.check(t, options, -1000000, "(1,000,000.0xxx)");
|
|
|
533 |
tests.number.check(t, options, -100.37, "(100.37xxxxxxxx)");
|
|
|
534 |
tests.number.check(t, options, -10456.37, "(10,456.37xxxxx)");
|
|
|
535 |
tests.number.check(t, options, -1120456.37, "(1,120,456.37xx)");
|
|
|
536 |
tests.number.check(t, options, -112045600.37, "(112,045,600.37)");
|
|
|
537 |
tests.number.check(t, options, -1252045600.37, "(1,252,045,600.37)");
|
|
|
538 |
|
|
|
539 |
tests.number.check(t, options, 10, "10.0xxxxxxxxxxxx");
|
|
|
540 |
tests.number.check(t, options, 1000, "1,000.0xxxxxxxxx");
|
|
|
541 |
tests.number.check(t, options, 1000000, "1,000,000.0xxxxx");
|
|
|
542 |
tests.number.check(t, options, 100.37, "100.37xxxxxxxxxx");
|
|
|
543 |
tests.number.check(t, options, 10456.37, "10,456.37xxxxxxx");
|
|
|
544 |
tests.number.check(t, options, 1120456.37, "1,120,456.37xxxx");
|
|
|
545 |
tests.number.check(t, options, 112045600.37, "112,045,600.37xx");
|
|
|
546 |
tests.number.check(t, options, 10252045600.37, "10,252,045,600.37");
|
|
|
547 |
|
|
|
548 |
//Not implemented yet,refer to NumberFormatTest.TestPatterns2()
|
|
|
549 |
//For future use - maily test pad patterns
|
|
|
550 |
print("test_number_format_Pad() end..............");
|
|
|
551 |
}
|
|
|
552 |
*/
|
|
|
553 |
}
|
|
|
554 |
},
|
|
|
555 |
{
|
|
|
556 |
name: "parse_icu4j3_6",
|
|
|
557 |
runTest: function(t){
|
|
|
558 |
/**
|
|
|
559 |
* In ICU4J, testing logic for NumberFormat.parse() is seperated into
|
|
|
560 |
* differernt single tese cases. So part of these logic are
|
|
|
561 |
* collected together in this test case. *
|
|
|
562 |
*/
|
|
|
563 |
//print("test_number_parse_icu4j3_6() start..............");
|
|
|
564 |
//Refer to ICU4J's NumberFormatTest.TestParse() which is only a rudimentary version
|
|
|
565 |
var pattern = "00";
|
|
|
566 |
var str = "0.0";
|
|
|
567 |
var result = dojo.number.parse(str,{pattern:pattern});
|
|
|
568 |
//TODO: add more locales
|
|
|
569 |
//FIXME: is this a valid test?
|
|
|
570 |
// t.is(0,result);
|
|
|
571 |
|
|
|
572 |
/**************************************** tolerant parse *****************************************
|
|
|
573 |
* refers to ICU4J's NumberFormatTest.TestStrictParse()??
|
|
|
574 |
* TODO: Seems dojo.number parses string in a tolerant way.
|
|
|
575 |
*/
|
|
|
576 |
var options = {locale:"en-us"};
|
|
|
577 |
/*
|
|
|
578 |
* TODO: !!Failed case,Should all pass,
|
|
|
579 |
* but the following elements failed (all parsed to NaN):
|
|
|
580 |
* [1]-"0 ",[2]-"0.",[3]-"0,",[5]-"0. ",[6]-"0.100,5",
|
|
|
581 |
* [7]-".00",[9]-"12345, ",[10]-"1,234, ",[12]-"0E"
|
|
|
582 |
*/
|
|
|
583 |
var passData = ([
|
|
|
584 |
"0", //[0] single zero before end of text is not leading
|
|
|
585 |
//"0 ", //[1] single zero at end of number is not leading
|
|
|
586 |
//"0.", //[2] single zero before period (or decimal, it's ambiguous) is not leading
|
|
|
587 |
//"0,", //[3] single zero before comma (not group separator) is not leading
|
|
|
588 |
"0.0", //[4] single zero before decimal followed by digit is not leading
|
|
|
589 |
//"0. ", //[5] same as above before period (or decimal) is not leading
|
|
|
590 |
//"0.100,5", //[6] comma stops parse of decimal (no grouping)
|
|
|
591 |
//".00", //[7] leading decimal is ok, even with zeros
|
|
|
592 |
"1234567", //[8] group separators are not required
|
|
|
593 |
//"12345, ", //[9] comma not followed by digit is not a group separator, but end of number
|
|
|
594 |
//"1,234, ", //[10] if group separator is present, group sizes must be appropriate
|
|
|
595 |
"1,234,567" //[11] ...secondary too
|
|
|
596 |
//,"0E" //[12]not implemented yet,an exponnent not followed by zero or digits is not an exponent
|
|
|
597 |
]);
|
|
|
598 |
runBatchParse(options,passData,true/*tolerant parse*/);
|
|
|
599 |
|
|
|
600 |
/*
|
|
|
601 |
* TODO:!!Failed case,should all pass,
|
|
|
602 |
* but the following failed,
|
|
|
603 |
* [10]-"1,45 that" implies that we partially parse input
|
|
|
604 |
*/
|
|
|
605 |
var failData = ([
|
|
|
606 |
"00", //[0] leading zero before zero
|
|
|
607 |
"012", //[1] leading zero before digit
|
|
|
608 |
"0,456", //[2] leading zero before group separator
|
|
|
609 |
"1,2", //[3] wrong number of digits after group separator
|
|
|
610 |
",0", //[4] leading group separator before zero
|
|
|
611 |
",1", //[5] leading group separator before digit
|
|
|
612 |
",.02", //[6] leading group separator before decimal
|
|
|
613 |
"1,.02", //[7] group separator before decimal
|
|
|
614 |
"1,,200", //[8] multiple group separators
|
|
|
615 |
"1,45", //[9] wrong number of digits in primary group
|
|
|
616 |
//"1,45 that", //[10] wrong number of digits in primary group
|
|
|
617 |
"1,45.34", //[11] wrong number of digits in primary group
|
|
|
618 |
"1234,567", //[12] wrong number of digits in secondary group
|
|
|
619 |
"12,34,567", //[13] wrong number of digits in secondary group
|
|
|
620 |
"1,23,456,7890" //[14] wrong number of digits in primary and secondary groups
|
|
|
621 |
]);
|
|
|
622 |
runBatchParse(options,failData,false);
|
|
|
623 |
|
|
|
624 |
options = {pattern:"#,##,##0.#",locale:"en-us"};
|
|
|
625 |
/*
|
|
|
626 |
* TODO:!!Failed case,shoudl all pass.
|
|
|
627 |
|
|
|
628 |
* but [1] [2] and [3] failed
|
|
|
629 |
* should be parsed to 1234567,but NaN instead
|
|
|
630 |
*/
|
|
|
631 |
var mixedPassData = ([
|
|
|
632 |
"12,34,567" //[0]
|
|
|
633 |
//,"12,34,567," //[1]
|
|
|
634 |
//"12,34,567, that",//[2]
|
|
|
635 |
//"12,34,567 that" //[3]
|
|
|
636 |
]);
|
|
|
637 |
runBatchParse(options,mixedPassData,true/*tolerant parse*/);
|
|
|
638 |
|
|
|
639 |
/*
|
|
|
640 |
* TODO:!!Failed case,should all pass,
|
|
|
641 |
* but actually mixedFailData[2] and mixedFailData[3] passed.
|
|
|
642 |
* "12,34,56, that " and [3]-"12,34,56 that" should be parsed to 123456,but NaN instead
|
|
|
643 |
*/
|
|
|
644 |
var mixedFailData = ([
|
|
|
645 |
"12,34,56", //[0]
|
|
|
646 |
"12,34,56," //[1]
|
|
|
647 |
//,"12,34,56, that ",//[2]
|
|
|
648 |
//"12,34,56 that", //[3]
|
|
|
649 |
]);
|
|
|
650 |
runBatchParse(options,mixedFailData,false);
|
|
|
651 |
|
|
|
652 |
|
|
|
653 |
/**************************************** strict parse ******************************************
|
|
|
654 |
* TODO:May need to test strict parsing in the future?
|
|
|
655 |
* e.g. A strict parsing like (with pattern "#,##0.#")
|
|
|
656 |
* 1.Leading zeros
|
|
|
657 |
* '00', '0123' fail the parse, but '0' and '0.001' pass
|
|
|
658 |
* 2.Leading or doubled grouping separators
|
|
|
659 |
* ',123' and '1,,234" fail
|
|
|
660 |
* 3.Groups of incorrect length when grouping is used
|
|
|
661 |
* '1,23' and '1234,567' fail, but '1234' passes
|
|
|
662 |
* 4.Grouping separators used in numbers followed by exponents
|
|
|
663 |
* '1,234E5' fails, but '1234E5' and '1,234E' pass
|
|
|
664 |
*/
|
|
|
665 |
//options={locale:"en",strict:true};
|
|
|
666 |
//runBatchParse(options,passData,false/*strict parse*/);
|
|
|
667 |
//runBatchParse(options,failData,false/*strict parse*/);
|
|
|
668 |
|
|
|
669 |
//options = {pattern:"#,##,##0.#",locale:"en-us",strict:true};
|
|
|
670 |
//runBatchParse(options,mixedPassData,false/*strict parse*/);
|
|
|
671 |
//runBatchParse(options,mixedFailData,false/*strict parse*/);
|
|
|
672 |
|
|
|
673 |
//print("test_number_parse_icu4j3_6() end..............\n");
|
|
|
674 |
}
|
|
|
675 |
},
|
|
|
676 |
{
|
|
|
677 |
name: "parse_whitespace",
|
|
|
678 |
runTest: function(t){
|
|
|
679 |
/**
|
|
|
680 |
* TODO:!!Failed case
|
|
|
681 |
* With pattern "a b#0c ",both "a b3456c " and and "a b1234c " should be parsed to 3456,but got NaN instead.
|
|
|
682 |
*
|
|
|
683 |
* Refer to ICU4J's NumberFormatTest.TestWhiteSpaceParsing
|
|
|
684 |
*/
|
|
|
685 |
/*
|
|
|
686 |
print("test_number_parse_WhiteSpace() start..............");
|
|
|
687 |
var pattern = "a b#0c ";
|
|
|
688 |
var expectResult = 3456;
|
|
|
689 |
result = dojo.number.parse("a b3456c ",{pattern:pattern,locale:"en-us"});
|
|
|
690 |
t.is(expectResult,result);
|
|
|
691 |
result = dojo.number.parse("a b3456c ",{pattern:pattern,locale:"en-us"});
|
|
|
692 |
t.is(expectResult,result);
|
|
|
693 |
print("test_number_parse_WhiteSpace() end..............\n");
|
|
|
694 |
*/
|
|
|
695 |
}
|
|
|
696 |
},
|
|
|
697 |
/*************************************************************************************************
|
|
|
698 |
* Regression test cases
|
|
|
699 |
* These test cases are referred to ICU4J's NumberFormatRegressionTest and NumberFormatRegression.
|
|
|
700 |
* The regression cases in ICU4J are used as unit test cases for bug fixing,
|
|
|
701 |
* They are inluced here so that dojo.number may avoid those similar bugs.
|
|
|
702 |
*************************************************************************************************/
|
|
|
703 |
{
|
|
|
704 |
name: "number_regression_1",
|
|
|
705 |
runTest: function(t){
|
|
|
706 |
/**
|
|
|
707 |
* Refer to ICU4J's NumberFormatRegressionTest.Test4161100()
|
|
|
708 |
*/
|
|
|
709 |
tests.number.checkFormatParseCycle(t, {pattern:"#0.#"},-0.09,"-0.1",false);
|
|
|
710 |
}
|
|
|
711 |
},
|
|
|
712 |
{
|
|
|
713 |
name: "number_regression_2",
|
|
|
714 |
runTest: function(t){
|
|
|
715 |
/**
|
|
|
716 |
* !!Failed case,rounding hasn't been implemented yet.
|
|
|
717 |
* Refer to ICU4J's NumberFormatRegressionTest.Test4408066()
|
|
|
718 |
*/
|
|
|
719 |
/*
|
|
|
720 |
var data = ([-3.75, -2.5, -1.5,
|
|
|
721 |
-1.25, 0, 1.0,
|
|
|
722 |
1.25, 1.5, 2.5,
|
|
|
723 |
3.75, 10.0, 255.5]);
|
|
|
724 |
var expected = (["-4", "-2", "-2",
|
|
|
725 |
"-1", "0", "1",
|
|
|
726 |
"1", "2", "2",
|
|
|
727 |
"4", "10", "256"]);
|
|
|
728 |
var options = {locale:"zh-cn",round:true};
|
|
|
729 |
for(var i =0; i < data.length; i++){
|
|
|
730 |
tests.number.checkFormatParseCycle(t, options,data[i],expected[i],false);
|
|
|
731 |
}
|
|
|
732 |
|
|
|
733 |
data = ([ "-3.75", "-2.5", "-1.5",
|
|
|
734 |
"-1.25", "0", "1.0",
|
|
|
735 |
"1.25", "1.5", "2.5",
|
|
|
736 |
"3.75", "10.0", "255.5"]);
|
|
|
737 |
expected =([ -3, -2, -1,
|
|
|
738 |
-1, 0, 1,
|
|
|
739 |
1, 1, 2,
|
|
|
740 |
3, 10, 255]);
|
|
|
741 |
|
|
|
742 |
for(var i =0; i < data.length; i++){
|
|
|
743 |
tests.number.checkParse(t, options,data[i],expected[i]);
|
|
|
744 |
}
|
|
|
745 |
*/
|
|
|
746 |
}
|
|
|
747 |
},
|
|
|
748 |
{
|
|
|
749 |
name: "number_regression_3",
|
|
|
750 |
runTest: function(t){
|
|
|
751 |
/**
|
|
|
752 |
* Refer to ICU4J's NumberRegression.Test4087535() and Test4243108()
|
|
|
753 |
*/
|
|
|
754 |
tests.number.checkFormatParseCycle(t, {places:0},0,"0",false);
|
|
|
755 |
//TODO:in icu4j,0.1 should be formatted to ".1" when minimumIntegerDigits=0
|
|
|
756 |
tests.number.checkFormatParseCycle(t, {places:0},0.1,"0",false);
|
|
|
757 |
tests.number.checkParse(t, {pattern:"#0.#####"},123.55456,123.55456);
|
|
|
758 |
//!! fails because default pattern only has 3 decimal places
|
|
|
759 |
// tests.number.checkParse(t, null,123.55456,123.55456);
|
|
|
760 |
|
|
|
761 |
//See whether it fails first format 0.0 ,parse "99.99",and then reformat 0.0
|
|
|
762 |
tests.number.checkFormatParseCycle(t, {pattern:"#.#"},0.0,"0",false);
|
|
|
763 |
tests.number.checkParse(t, null,"99.99",99.99);
|
|
|
764 |
tests.number.checkFormatParseCycle(t, {pattern:"#.#"},0.0,"0",false);
|
|
|
765 |
}
|
|
|
766 |
},
|
|
|
767 |
{
|
|
|
768 |
name: "number_regression_4",
|
|
|
769 |
runTest: function(t){
|
|
|
770 |
/**
|
|
|
771 |
* TODO:
|
|
|
772 |
* In ICU -0.0 and -0.0001 should be formatted to "-0" with FieldPosition(0)
|
|
|
773 |
* dojo.i18n.number format -0.0 to "-0"; -0.0001 to "-0.000100"
|
|
|
774 |
*
|
|
|
775 |
* Refer to ICU4J's NumberRegression.Test4088503() and Test4106658()
|
|
|
776 |
*/
|
|
|
777 |
tests.number.checkFormatParseCycle(t, {places:0},123,"123",false);
|
|
|
778 |
|
|
|
779 |
//TODO: differernt from ICU where -0.0 is formatted to "-0"
|
|
|
780 |
tests.number.checkFormatParseCycle(t, {locale:"en-us"},-0.0,"0",false);
|
|
|
781 |
|
|
|
782 |
//TODO: differernt from ICU where -0.0001 is formatted to "-0"
|
|
|
783 |
tests.number.checkFormatParseCycle(t, {locale:"en-us",places:6},-0.0001,"-0.000100",false);
|
|
|
784 |
}
|
|
|
785 |
},
|
|
|
786 |
{
|
|
|
787 |
name: "number_regression_5",
|
|
|
788 |
runTest: function(t){
|
|
|
789 |
/**
|
|
|
790 |
* !!Failed case,rounding has not implemented yet.
|
|
|
791 |
* 0.00159999 should be formatted as 0.0016 but got 0.0015 instead.
|
|
|
792 |
* Refer to ICU4J's NumberRegression.Test4071492()
|
|
|
793 |
*/
|
|
|
794 |
//tests.number.checkFormatParseCycle(t, {places:4,round:true},0.00159999,"0.0016",false);
|
|
|
795 |
}
|
|
|
796 |
},
|
|
|
797 |
{
|
|
|
798 |
name: "number_regression_6",
|
|
|
799 |
runTest: function(t){
|
|
|
800 |
/**
|
|
|
801 |
* Refer to ICU4J's NumberRegression.Test4086575()
|
|
|
802 |
*/
|
|
|
803 |
var pattern = "###.00;(###.00)";
|
|
|
804 |
var locale = "fr";
|
|
|
805 |
var options = {pattern:pattern,locale:locale};
|
|
|
806 |
|
|
|
807 |
//no group separator
|
|
|
808 |
tests.number.checkFormatParseCycle(t, options,1234,"1234,00",false);
|
|
|
809 |
tests.number.checkFormatParseCycle(t, options,-1234,"(1234,00)",false);
|
|
|
810 |
|
|
|
811 |
//space as group separator
|
|
|
812 |
pattern = "#,###.00;(#,###.00)";
|
|
|
813 |
options = {pattern:pattern,locale:locale};
|
|
|
814 |
tests.number.checkFormatParseCycle(t, options,1234,"1\u00a0234,00",false);// Expect 1 234,00
|
|
|
815 |
tests.number.checkFormatParseCycle(t, options,-1234,"(1\u00a0234,00)",false); // Expect (1 234,00)
|
|
|
816 |
}
|
|
|
817 |
},
|
|
|
818 |
{
|
|
|
819 |
name: "number_regression_7",
|
|
|
820 |
runTest: function(t){
|
|
|
821 |
/**
|
|
|
822 |
* !!Failed case - expontent has not implemented yet
|
|
|
823 |
* shuold format 1.000000000000001E7 to 10000000.00000001, but got 10,000,000.000 instead
|
|
|
824 |
* Refer to ICU4J's NumberRegression.Test4090489() - loses precision
|
|
|
825 |
*/
|
|
|
826 |
//tests.number.checkFormatParseCycle(t, null,1.000000000000001E7,"10000000.00000001",false);
|
|
|
827 |
}
|
|
|
828 |
},
|
|
|
829 |
{
|
|
|
830 |
name: "number_regression_8",
|
|
|
831 |
runTest: function(t){
|
|
|
832 |
/**
|
|
|
833 |
* !!Failed case
|
|
|
834 |
* 1.with pattern "#,#00.00 p''ieces;-#,#00.00 p''ieces"
|
|
|
835 |
* 3456.78 should be formated to "3,456.78 p'ieces",
|
|
|
836 |
* but got "3,456.78 p''ieces","''" should be replaced with "'"
|
|
|
837 |
* 2.with illegal pattern "000.0#0"
|
|
|
838 |
* no error for the illegal pattern, and 3456.78 is formatted to 456.780
|
|
|
839 |
* 3.with illegal pattern "0#0.000"
|
|
|
840 |
* no error for the illegal pattern, and 3456.78 is formatted to 3456.780
|
|
|
841 |
*
|
|
|
842 |
* Refer to ICU4J's NumberRegression.Test4092480(),Test4074454()
|
|
|
843 |
*/
|
|
|
844 |
var patterns = (["#0000","#000","#00","#0","#"]);
|
|
|
845 |
var expect = (["0042","042","42","42","42"]);
|
|
|
846 |
|
|
|
847 |
for(var i =0; i < patterns.length; i ++){
|
|
|
848 |
tests.number.checkFormatParseCycle(t, {pattern:patterns[i]},42,expect[i],false);
|
|
|
849 |
tests.number.checkFormatParseCycle(t, {pattern:patterns[i]},-42,"-"+expect[i],false);
|
|
|
850 |
}
|
|
|
851 |
|
|
|
852 |
tests.number.checkFormatParseCycle(t, {pattern:"#,#00.00;-#.#"},3456.78,"3,456.78",false);
|
|
|
853 |
//!!Failed case
|
|
|
854 |
//tests.number.checkFormatParseCycle(t, {pattern:"#,#00.00 p''ieces;-#,#00.00 p''ieces"},3456.78,"3,456.78 p'ieces",false);
|
|
|
855 |
//tests.number.checkFormatParseCycle(t, {pattern:"000.0#0"},3456.78,null,false);
|
|
|
856 |
//tests.number.checkFormatParseCycle(t, {pattern:"0#0.000"},3456.78,null,false);
|
|
|
857 |
}
|
|
|
858 |
},
|
|
|
859 |
{
|
|
|
860 |
name: "number_regression_9",
|
|
|
861 |
runTest: function(t){
|
|
|
862 |
/**
|
|
|
863 |
* TODO
|
|
|
864 |
* Refer to ICU4J's NumberRegression.Test4052223()
|
|
|
865 |
*/
|
|
|
866 |
//TODO:only got NaN,need an illegal pattern exception?
|
|
|
867 |
tests.number.checkParse(t, {pattern:"#,#00.00"},"abc3");
|
|
|
868 |
|
|
|
869 |
//TODO: got NaN instead of 1.222, is it ok?
|
|
|
870 |
//tests.number.checkParse(t, {pattern:"#,##0.###",locale:"en-us"},"1.222,111",1.222);
|
|
|
871 |
//tests.number.checkParse(t, {pattern:"#,##0.###",locale:"en-us"},"1.222x111",1.222);
|
|
|
872 |
|
|
|
873 |
//got NaN for illeal input,ok
|
|
|
874 |
tests.number.checkParse(t, null,"hello: ,.#$@^&**10x");
|
|
|
875 |
}
|
|
|
876 |
},
|
|
|
877 |
{
|
|
|
878 |
name: "number_regression_10",
|
|
|
879 |
runTest: function(t){
|
|
|
880 |
/**
|
|
|
881 |
* Refer to ICU4J's NumberRegression.Test4125885()
|
|
|
882 |
*/
|
|
|
883 |
tests.number.checkFormatParseCycle(t, {pattern:"000.00"},12.34,"012.34",false);
|
|
|
884 |
tests.number.checkFormatParseCycle(t, {pattern:"+000.00%;-000.00%"},0.1234,"+012.34%",false);
|
|
|
885 |
tests.number.checkFormatParseCycle(t, {pattern:"##,###,###.00"},9.02,"9.02",false);
|
|
|
886 |
|
|
|
887 |
var patterns =(["#.00", "0.00", "00.00", "#0.0#", "#0.00"]);
|
|
|
888 |
var expect = (["1.20", "1.20", "01.20", "1.2", "1.20" ]);
|
|
|
889 |
for(var i =0 ; i < patterns.length; i ++){
|
|
|
890 |
tests.number.checkFormatParseCycle(t, {pattern:patterns[i]},1.2,expect[i],false);
|
|
|
891 |
}
|
|
|
892 |
}
|
|
|
893 |
},
|
|
|
894 |
{
|
|
|
895 |
name: "number_regression_11",
|
|
|
896 |
runTest: function(t){
|
|
|
897 |
/**
|
|
|
898 |
* TODO:!!Failed case
|
|
|
899 |
* Make sure that all special characters, when quoted in a suffix or prefix, lose their special meaning.
|
|
|
900 |
* The detail error info :
|
|
|
901 |
* for input 123
|
|
|
902 |
* pattern:'0'#0'0'; expect:"01230"; but got "'3'#0'0'" instead
|
|
|
903 |
* pattern:','#0','; expect:",123,"; but got "','123','" instead
|
|
|
904 |
* pattern:'.'#0'.'; expect:".123."; but got "'.'123'.'" instead
|
|
|
905 |
* pattern:'‰'#0'‰'; expect:"‰123‰"; but got "'‰'123000'‰'" instead
|
|
|
906 |
* pattern:'%'#0'%'; expect:"%123%"; but got "'%'12300'%'" instead
|
|
|
907 |
* pattern:'#'#0'#'; expect:"#123#"; but got "'123'#0'#'" instead
|
|
|
908 |
* pattern:';'#0';'; expect:";123;"; but got "[dojo-test] FATAL exception raised:
|
|
|
909 |
* unable to find a number expression in pattern: '"
|
|
|
910 |
* pattern:'E'#0'E'; expect:"E123E"; not implemeted yet
|
|
|
911 |
* pattern:'*'#0'*'; expect:"*123*"; but got "'*'123'*'" instead
|
|
|
912 |
* pattern:'+'#0'+'; expect:"+123+"; but got "'+'123'+'" instead
|
|
|
913 |
* pattern:'-'#0'-'; expect:"-123-"; but got "'-'123'-'" instead
|
|
|
914 |
*
|
|
|
915 |
* TODO: is it ok to remain "'" in the formatted result as above??
|
|
|
916 |
*
|
|
|
917 |
* Refer to ICU4J's NumberRegression.Test4212072()
|
|
|
918 |
*/
|
|
|
919 |
/*
|
|
|
920 |
var specials = ([ '0', ',', '.', '\u2030', '%', '#',';', 'E', '*', '+', '-']);
|
|
|
921 |
var pattern;
|
|
|
922 |
var expect;
|
|
|
923 |
|
|
|
924 |
for(var i=0; i < specials.length; i ++){
|
|
|
925 |
pattern = "'" + specials[i] + "'#0'" + specials[i] + "'";
|
|
|
926 |
expect = "" + specials[i] + "123" + specials[i];
|
|
|
927 |
tests.number.checkFormatParseCycle(t, {pattern:pattern,locale:"en-us"},123,expect,false);
|
|
|
928 |
}
|
|
|
929 |
*/
|
|
|
930 |
}
|
|
|
931 |
},
|
|
|
932 |
{
|
|
|
933 |
name: "number_regression_12",
|
|
|
934 |
runTest: function(t){
|
|
|
935 |
/**
|
|
|
936 |
* TODO: add more rounding test cases, refer to ICU4J's NumberRegression.Test4071005(),Test4071014() etc..
|
|
|
937 |
*/
|
|
|
938 |
|
|
|
939 |
/**
|
|
|
940 |
* TODO:Decimal format doesnt round a double properly when the number is less than 1
|
|
|
941 |
*
|
|
|
942 |
* Refer to ICU4J's NumberRegression.test4241880()
|
|
|
943 |
*/
|
|
|
944 |
/*
|
|
|
945 |
var input = ([ .019, .009, .015, .016, .014,
|
|
|
946 |
.004, .005, .006, .007, .008,
|
|
|
947 |
.5, 1.5, .05, .15, .005,
|
|
|
948 |
.015, .0005, .0015]);
|
|
|
949 |
var patterns = (["##0%", "##0%", "##0%", "##0%", "##0%",
|
|
|
950 |
"##0%", "##0%", "##0%", "##0%", "##0%",
|
|
|
951 |
"#,##0", "#,##0", "#,##0.0", "#,##0.0", "#,##0.00",
|
|
|
952 |
"#,##0.00", "#,##0.000", "#,##0.000"]);
|
|
|
953 |
var expect =([ "2%", "1%", "2%", "2%", "1%",
|
|
|
954 |
"0%", "0%", "1%", "1%", "1%",
|
|
|
955 |
"0", "2", "0.0", "0.2", "0.00",
|
|
|
956 |
"0.02", "0.000", "0.002",]);
|
|
|
957 |
for(var i = 0; i <input.length; i ++){
|
|
|
958 |
tests.number.checkFormatParseCycle(t, {pattern:patterns[i],round:true},input[i],expect[i],false);
|
|
|
959 |
}
|
|
|
960 |
*/
|
|
|
961 |
}
|
|
|
962 |
}
|
|
|
963 |
]
|
|
|
964 |
);
|
|
|
965 |
|
|
|
966 |
}
|