tests/corelib/num_parse_test.dart - Issue 85623004: Revert "Add num.parse."

Side by Side Diff: tests/corelib/num_parse_test.dart

Issue 85623004: Revert "Add num.parse." (Closed) Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart

Patch Set: Created 7 years ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch | Annotate | Revision Log

OLD	NEW
	(Empty)
1 // Copyright (c) 2013 the Dart project authors. Please see the AUTHORS file

2 // for details. All rights reserved. Use of this source code is governed by a

3 // BSD-style license that can be found in the LICENSE file.

4

5 import "package:expect/expect.dart";

6

7 const whiteSpace = const [

8 "",

9 "\x09",

10 "\x0a",

11 "\x0b",

12 "\x0c",

13 "\x0d",

14 "\x85",

15 "\xa0",

16 "\u1680",

17 "\u180e",

18 "\u2000",

19 "\u2001",

20 "\u2002",

21 "\u2003",

22 "\u2004",

23 "\u2005",

24 "\u2006",

25 "\u2007",

26 "\u2008",

27 "\u2009",

28 "\u200a",

29 "\u2028",

30 "\u2029",

31 "\u202f",

32 "\u205f",

33 "\u3000",

34 "\uFEFF"

35 ];

36

37 void testParse(String source, num result) {

38 for (String ws1 in whiteSpace) {

39 for (String ws2 in whiteSpace) {

40 String padded = "$ws1$source$ws2";

41 // Use Expect.identical because it also handles NaN and 0.0/-0.0.

42 // Except on dart2js: http://dartbug.com/11551

43 Expect.identical(result, num.parse(padded), "parse '$padded'");

44 padded = "$ws1$ws2$source";

45 Expect.identical(result, num.parse(padded), "parse '$padded'");

46 padded = "$source$ws1$ws2";

47 Expect.identical(result, num.parse(padded), "parse '$padded'");

48 }

49 }

50 }

51

52 void testInt(int value) {

53 testParse("$value", value);

54 testParse("+$value", value);

55 testParse("-$value", -value);

56 var hex = "0x${value.toRadixString(16)}";

57 var lchex = hex.toLowerCase();

58 testParse(lchex, value);

59 testParse("+$lchex", value);

60 testParse("-$lchex", -value);

61 var uchex = hex.toUpperCase();

62 testParse(uchex, value);

63 testParse("+$uchex", value);

64 testParse("-$uchex", -value);

65 }

66

67 void testIntAround(int value) {

68 testInt(value - 1);

69 testInt(value);

70 testInt(value + 1);

71 }

72

73 void testDouble(double value) {

74 testParse("$value", value);

75 testParse("+$value", value);

76 testParse("-$value", -value);

77 if (value.isFinite) {

78 String exp = value.toStringAsExponential();

79 String lcexp = exp.toLowerCase();

80 testParse(lcexp, value);

81 testParse("+$lcexp", value);

82 testParse("-$lcexp", -value);

83 String ucexp = exp.toUpperCase();

84 testParse(ucexp, value);

85 testParse("+$ucexp", value);

86 testParse("-$ucexp", -value);

87 }

88 }

89

90 void testFail(String source) {

91 var object = new Object();

92 Expect.throws(() {

93 num.parse(source, (s) {

94 Expect.equals(source, s);

95 throw object;

96 });

97 }, (e) => identical(object, e), "Fail: '$source'");

98 }

99

100 void main() {

101 testInt(0);

102 testInt(1);

103 testInt(9);

104 testInt(10);

105 testInt(99);

106 testInt(100);

107 testIntAround(256);

108 testIntAround(0x80000000); // 2^31

109 testIntAround(0x100000000); // 2^32

110 testIntAround(0x10000000000000); // 2^52

111 testIntAround(0x20000000000000); // 2^53

112 testIntAround(0x40000000000000); // 2^54

113 testIntAround(0x8000000000000000); // 2^63

114 testIntAround(0x10000000000000000); // 2^64

115 testIntAround(0x100000000000000000000); // 2^80

116

117 testDouble(0.0);

118 testDouble(5e-324);

119 testDouble(2.225073858507201e-308);

120 testDouble(2.2250738585072014e-308);

121 testDouble(0.49999999999999994);

122 testDouble(0.5);

123 testDouble(0.50000000000000006);

124 testDouble(0.9999999999999999);

125 testDouble(1.0);

126 testDouble(1.0000000000000002);

127 testDouble(4294967295.0);

128 testDouble(4294967296.0);

129 testDouble(4503599627370495.5);

130 testDouble(4503599627370497.0);

131 testDouble(9007199254740991.0);

132 testDouble(9007199254740992.0);

133 testDouble(1.7976931348623157e+308);

134 testDouble(double.INFINITY);

135 testDouble(double.NAN); /// 01: ok

136

137 // Strings that cannot occur from toString of a number.

138 testParse("000000000000", 0);

139 testParse("000000000001", 1);

140 testParse("000000000000.0000000000000", 0.0);

141 testParse("000000000001.0000000000000", 1.0);

142 testParse("0x0000000000", 0);

143 testParse("0e0", 0.0);

144 testParse("0e+0", 0.0);

145 testParse("0e-0", 0.0);

146 testParse("-0e0", -0.0);

147 testParse("-0e+0", -0.0);

148 testParse("-0e-0", -0.0);

149 testParse("1e0", 1.0);

150 testParse("1e+0", 1.0);

151 testParse("1e-0", 1.0);

152 testParse("-1e0", -1.0);

153 testParse("-1e+0", -1.0);

154 testParse("-1e-0", -1.0);

155 testParse("1.", 1.0);

156 testParse(".1", 0.1);

157 testParse("1.e1", 10.0);

158 testParse(".1e1", 1.0);

159

160 // Negative tests - things not to allow.

161

162 // Spaces inside the numeral.

163 testFail("- 1");

164 testFail("+ 1");

165 testFail("2 2");

166 testFail("0x 42");

167 testFail("1 .");

168 testFail(". 1");

169 testFail("1e 2");

170 testFail("1 e2");

171 // Invalid characters.

172 testFail("0x1H");

173 testFail("12H");

174 testFail("1x2");

175 testFail("00x2");

176 // Empty hex number.

177 testFail("0x");

178 testFail("-0x");

179 testFail("+0x");

180 // Double exponent without value.

181 testFail("e1");

182 testFail("e+1");

183 testFail("e-1");

184 testFail("-e1");

185 testFail("-e+1");

186 testFail("-e-1");

187 // Incorrect ways to write NaN/Infinity.

188 testFail("infinity");

189 testFail("INFINITY");

190 testFail("inf");

191 testFail("nan");

192 testFail("NAN");

193 testFail("qnan");

194 testFail("snan");

195 }

OLD	NEW

« no previous file with comments | « tests/corelib/corelib.status ('k') | no next file » | no next file with comments »