| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2011, 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 /** | |
| 6 * A test of simple runtime behavior on numbers, strings and lists with | |
| 7 * a focus on both correct behavior and runtime errors. | |
| 8 * | |
| 9 * This file is written to use minimal type declarations to match a | |
| 10 * typical dynamic language coding style. | |
| 11 */ | |
| 12 class CoreRuntimeTypesTest { | |
| 13 static testMain() { | |
| 14 testBooleanOperators(); | |
| 15 testRationalOperators(); | |
| 16 testIntegerOperators(); | |
| 17 testOperatorErrors(); | |
| 18 testRationalMethods(); | |
| 19 testIntegerMethods(); | |
| 20 testStringOperators(); | |
| 21 testStringMethods(); | |
| 22 testListOperators(); | |
| 23 testListMethods(); | |
| 24 testMapOperators(); | |
| 25 testMapMethods(); | |
| 26 testLiterals(); | |
| 27 testDateMethods(); | |
| 28 } | |
| 29 | |
| 30 static assertEquals(a, b) { | |
| 31 Expect.equals(b, a); | |
| 32 } | |
| 33 | |
| 34 static assertListEquals(List a, List b) { | |
| 35 Expect.equals(b.length, a.length); | |
| 36 for (int i = 0; i < a.length; i++) { | |
| 37 Expect.equals(b[i], a[i]); | |
| 38 } | |
| 39 } | |
| 40 | |
| 41 static assertListContains(List<Comparable> a, List<Comparable> b) { | |
| 42 a.sort((x, y) => x.compareTo(y)); | |
| 43 b.sort((x, y) => x.compareTo(y)); | |
| 44 assertListEquals(a, b); | |
| 45 } | |
| 46 | |
| 47 static assertTypeError(void f()) { | |
| 48 try { | |
| 49 f(); | |
| 50 } catch (var exception) { | |
| 51 Expect.equals(true, (exception is TypeError) || | |
| 52 (exception is NoSuchMethodException) || | |
| 53 (exception is NullPointerException) || | |
| 54 (exception is IllegalArgumentException)); | |
| 55 return; | |
| 56 } | |
| 57 Expect.equals(true, false); | |
| 58 } | |
| 59 | |
| 60 static testBooleanOperators() { | |
| 61 var x = true, y = false; | |
| 62 assertEquals(x, true); | |
| 63 assertEquals(y, false); | |
| 64 assertEquals(x, !y); | |
| 65 assertEquals(!x, y); | |
| 66 } | |
| 67 | |
| 68 | |
| 69 static testRationalOperators() { | |
| 70 var x = 10, y = 20; | |
| 71 assertEquals(x + y, 30); | |
| 72 assertEquals(x - y, -10); | |
| 73 assertEquals(x * y, 200); | |
| 74 assertEquals(x / y, 0.5); | |
| 75 assertEquals(x ~/ y, 0); | |
| 76 assertEquals(x % y, 10); | |
| 77 } | |
| 78 | |
| 79 static testIntegerOperators() { | |
| 80 var x = 18, y = 17; | |
| 81 assertEquals(x | y, 19); | |
| 82 assertEquals(x & y, 16); | |
| 83 assertEquals(x ^ y, 3); | |
| 84 assertEquals(2 >> 1, 1); | |
| 85 assertEquals(1 << 1, 2); | |
| 86 } | |
| 87 | |
| 88 static testOperatorErrors() { | |
| 89 var objs = [1, '2', [3], null, true, new Map()]; | |
| 90 for (var i=0; i < objs.length; i++) { | |
| 91 for (var j=i+1; j < objs.length; j++) { | |
| 92 testBinaryOperatorErrors(objs[i], objs[j]); | |
| 93 testBinaryOperatorErrors(objs[j], objs[i]); | |
| 94 } | |
| 95 if (objs[i] != 1) { | |
| 96 testUnaryOperatorErrors(objs[i]); | |
| 97 } | |
| 98 } | |
| 99 } | |
| 100 | |
| 101 static testBinaryOperatorErrors(x, y) { | |
| 102 assertTypeError(() { x - y;}); | |
| 103 assertTypeError(() { x * y;}); | |
| 104 assertTypeError(() { x / y;}); | |
| 105 assertTypeError(() { x | y;}); | |
| 106 assertTypeError(() { x ^ y;}); | |
| 107 assertTypeError(() { x & y;}); | |
| 108 assertTypeError(() { x << y;}); | |
| 109 assertTypeError(() { x >> y;}); | |
| 110 assertTypeError(() { x ~/ y;}); | |
| 111 assertTypeError(() { x % y;}); | |
| 112 | |
| 113 testComparisonOperatorErrors(x, y); | |
| 114 } | |
| 115 | |
| 116 static testComparisonOperatorErrors(x, y) { | |
| 117 assertEquals(x == y, false); | |
| 118 assertEquals(x != y, true); | |
| 119 assertTypeError(() { x < y; }); | |
| 120 assertTypeError(() { x <= y; }); | |
| 121 assertTypeError(() { x > y; }); | |
| 122 assertTypeError(() { x >= y; }); | |
| 123 } | |
| 124 | |
| 125 static testUnaryOperatorErrors(x) { | |
| 126 // TODO(jimhug): Add guard for 'is num' when 'is' is working | |
| 127 assertTypeError(() { ~x;}); | |
| 128 assertTypeError(() { -x;}); | |
| 129 // TODO(jimhug): Add check for !x as an error when x is not a bool | |
| 130 } | |
| 131 | |
| 132 static testRationalMethods() { | |
| 133 var x = 10.6; | |
| 134 assertEquals(x.abs(), 10.6); | |
| 135 assertEquals((-x).abs(), 10.6); | |
| 136 assertEquals(x.round(), 11); | |
| 137 assertEquals(x.floor(), 10); | |
| 138 assertEquals(x.ceil(), 11); | |
| 139 } | |
| 140 | |
| 141 // TODO(jimhug): Determine correct behavior for mixing ints and floats. | |
| 142 static testIntegerMethods() { | |
| 143 var y = 9; | |
| 144 assertEquals(y.isEven(), false); | |
| 145 assertEquals(y.isOdd(), true); | |
| 146 assertEquals(y.toRadixString(2), '1001'); | |
| 147 assertEquals(y.toRadixString(3), '100'); | |
| 148 assertEquals(y.toRadixString(16), '9'); | |
| 149 assertEquals((0).toRadixString(16), '0'); | |
| 150 try { | |
| 151 y.toRadixString(0); | |
| 152 Expect.fail("Illegal radix 0 accepted."); | |
| 153 } catch (var e) { } | |
| 154 try { | |
| 155 y.toRadixString(-1); | |
| 156 Expect.fail("Illegal radix -1 accepted."); | |
| 157 } catch (var e) { } | |
| 158 } | |
| 159 | |
| 160 static testStringOperators() { | |
| 161 var s = "abcdef"; | |
| 162 assertEquals(s, "abcdef"); | |
| 163 assertEquals(s.charCodeAt(0), 97); | |
| 164 assertEquals(s[0], 'a'); | |
| 165 assertEquals(s.length, 6); | |
| 166 assertTypeError(() { s[null]; }); | |
| 167 assertTypeError(() { s['hello']; }); | |
| 168 assertTypeError(() { s[0] = 'x'; }); | |
| 169 } | |
| 170 | |
| 171 // TODO(jimhug): Fill out full set of string methods. | |
| 172 static testStringMethods() { | |
| 173 var s = "abcdef"; | |
| 174 assertEquals(s.isEmpty(), false); | |
| 175 assertEquals(s.startsWith("abc"), true); | |
| 176 assertEquals(s.endsWith("def"), true); | |
| 177 assertEquals(s.startsWith("aa"), false); | |
| 178 assertEquals(s.endsWith("ff"), false); | |
| 179 assertEquals(s.contains('cd', 0), true); | |
| 180 assertEquals(s.contains('cd', 2), true); | |
| 181 assertEquals(s.contains('cd', 3), false); | |
| 182 assertEquals(s.indexOf('cd', 2), 2); | |
| 183 assertEquals(s.indexOf('cd', 3), -1); | |
| 184 | |
| 185 assertTypeError(() { s.startsWith(1); }); | |
| 186 assertTypeError(() { s.endsWith(1); }); | |
| 187 } | |
| 188 | |
| 189 static testListOperators() { | |
| 190 var a = [1,2,3,4]; | |
| 191 assertEquals(a[0], 1); | |
| 192 assertTypeError(() { a['0']; }); | |
| 193 a[0] = 42; | |
| 194 assertEquals(a[0], 42); | |
| 195 assertTypeError(() { a['0'] = 99; }); | |
| 196 assertEquals(a.length, 4); | |
| 197 } | |
| 198 | |
| 199 // TODO(jimhug): Fill out full set of list methods. | |
| 200 static testListMethods() { | |
| 201 var a = [1,2,3,4]; | |
| 202 assertEquals(a.isEmpty(), false); | |
| 203 assertEquals(a.length, 4); | |
| 204 var exception = null; | |
| 205 a.clear(); | |
| 206 assertEquals(a.length, 0); | |
| 207 } | |
| 208 | |
| 209 static testMapOperators() { | |
| 210 var d = new Map(); | |
| 211 d['a'] = 1; | |
| 212 d['b'] = 2; | |
| 213 assertEquals(d['a'], 1); | |
| 214 assertEquals(d['b'], 2); | |
| 215 assertEquals(d['c'], null); | |
| 216 } | |
| 217 | |
| 218 static testMapMethods() { | |
| 219 var d = new Map(); | |
| 220 d['a'] = 1; | |
| 221 d['b'] = 2; | |
| 222 assertEquals(d.containsValue(2), true); | |
| 223 assertEquals(d.containsValue(3), false); | |
| 224 assertEquals(d.containsKey('a'), true); | |
| 225 assertEquals(d.containsKey('c'), false); | |
| 226 assertEquals(d.getKeys().length, 2); | |
| 227 assertEquals(d.getValues().length, 2); | |
| 228 | |
| 229 assertEquals(d.remove('c'), null); | |
| 230 assertEquals(d.remove('b'), 2); | |
| 231 assertListEquals(d.getKeys(), ['a']); | |
| 232 assertListEquals(d.getValues(), [1]); | |
| 233 | |
| 234 d['c'] = 3; | |
| 235 d['f'] = 4; | |
| 236 assertEquals(d.getKeys().length, 3); | |
| 237 assertEquals(d.getValues().length, 3); | |
| 238 assertListContains(d.getKeys(), ['a', 'c', 'f']); | |
| 239 assertListContains(d.getValues(), [1, 3, 4]); | |
| 240 | |
| 241 var count = 0; | |
| 242 d.forEach((key, value) { | |
| 243 count++; | |
| 244 assertEquals(value, d[key]); | |
| 245 }); | |
| 246 assertEquals(count, 3); | |
| 247 | |
| 248 d = { 'a': 1, 'b': 2 }; | |
| 249 assertEquals(d.containsValue(2), true); | |
| 250 assertEquals(d.containsValue(3), false); | |
| 251 assertEquals(d.containsKey('a'), true); | |
| 252 assertEquals(d.containsKey('c'), false); | |
| 253 assertEquals(d.getKeys().length, 2); | |
| 254 assertEquals(d.getValues().length, 2); | |
| 255 | |
| 256 d['g'] = null; | |
| 257 assertEquals(d.containsKey('g'), true); | |
| 258 assertEquals(d['g'], null); | |
| 259 } | |
| 260 | |
| 261 static testDateMethods() { | |
| 262 var msec = 115201000; | |
| 263 var d = new Date.fromEpoch(msec, const TimeZone.utc()); | |
| 264 assertEquals(d.seconds, 1); | |
| 265 assertEquals(d.year, 1970); | |
| 266 | |
| 267 d = new Date.now(); | |
| 268 assertEquals(d.year >= 2011, true); | |
| 269 } | |
| 270 | |
| 271 static testLiterals() { | |
| 272 true.toString(); | |
| 273 1.0.toString(); | |
| 274 .5.toString(); | |
| 275 1.toString(); | |
| 276 if (false) { | |
| 277 // Depends on http://b/4198808. | |
| 278 null.toString(); | |
| 279 } | |
| 280 '${null}'.toString(); | |
| 281 '${true}'.toString(); | |
| 282 '${false}'.toString(); | |
| 283 ''.toString(); | |
| 284 ''.endsWith(''); | |
| 285 } | |
| 286 } | |
| 287 | |
| 288 main() { | |
| 289 CoreRuntimeTypesTest.testMain(); | |
| 290 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 10244009:
test rename overhaul: step 7 - corelib tests (Closed)
Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart