Chromium Code Reviews

Side by Side Diff: test/unittests/compiler/typer-unittest.cc

Issue 1144183004: [strong] Refactor ObjectStrength into a replacement for strong boolean args (Closed) Base URL: https://chromium.googlesource.com/v8/v8.git@master
Patch Set: everything should work now Created 5 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments.
Jump to:
View unified diff |
OLDNEW
1 // Copyright 2015 the V8 project authors. All rights reserved. 1 // Copyright 2015 the V8 project authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include <functional> 5 #include <functional>
6 6
7 #include "src/codegen.h" 7 #include "src/codegen.h"
8 #include "src/compiler/js-operator.h" 8 #include "src/compiler/js-operator.h"
9 #include "src/compiler/node-properties.h" 9 #include "src/compiler/node-properties.h"
10 #include "test/cctest/types-fuzz.h" 10 #include "test/cctest/types-fuzz.h"
(...skipping 207 matching lines...)
218 218
219 219
220 //------------------------------------------------------------------------------ 220 //------------------------------------------------------------------------------
221 // Soundness 221 // Soundness
222 // For simplicity, we currently only test soundness on expression operators 222 // For simplicity, we currently only test soundness on expression operators
223 // that have a direct equivalent in C++. Also, testing is currently limited 223 // that have a direct equivalent in C++. Also, testing is currently limited
224 // to ranges as input types. 224 // to ranges as input types.
225 225
226 226
227 TEST_F(TyperTest, TypeJSAdd) { 227 TEST_F(TyperTest, TypeJSAdd) {
228 TestBinaryArithOp(javascript_.Add(LanguageMode::SLOPPY), std::plus<double>()); 228 TestBinaryArithOp(javascript_.Add(Strength::WEAK), std::plus<double>());
229 TestBinaryArithOp(javascript_.Add(LanguageMode::STRONG), std::plus<double>()); 229 TestBinaryArithOp(javascript_.Add(Strength::FIRM), std::plus<double>());
230 } 230 }
231 231
232 232
233 TEST_F(TyperTest, TypeJSSubtract) { 233 TEST_F(TyperTest, TypeJSSubtract) {
234 TestBinaryArithOp(javascript_.Subtract(LanguageMode::SLOPPY), 234 TestBinaryArithOp(javascript_.Subtract(Strength::WEAK), std::minus<double>());
235 std::minus<double>()); 235 TestBinaryArithOp(javascript_.Subtract(Strength::FIRM), std::minus<double>());
236 TestBinaryArithOp(javascript_.Subtract(LanguageMode::STRONG),
237 std::minus<double>());
238 } 236 }
239 237
240 238
241 TEST_F(TyperTest, TypeJSMultiply) { 239 TEST_F(TyperTest, TypeJSMultiply) {
242 TestBinaryArithOp(javascript_.Multiply(LanguageMode::SLOPPY), 240 TestBinaryArithOp(javascript_.Multiply(Strength::WEAK),
243 std::multiplies<double>()); 241 std::multiplies<double>());
244 TestBinaryArithOp(javascript_.Multiply(LanguageMode::STRONG), 242 TestBinaryArithOp(javascript_.Multiply(Strength::FIRM),
245 std::multiplies<double>()); 243 std::multiplies<double>());
246 } 244 }
247 245
248 246
249 TEST_F(TyperTest, TypeJSDivide) { 247 TEST_F(TyperTest, TypeJSDivide) {
250 TestBinaryArithOp(javascript_.Divide(LanguageMode::SLOPPY), 248 TestBinaryArithOp(javascript_.Divide(Strength::WEAK), std::divides<double>());
251 std::divides<double>()); 249 TestBinaryArithOp(javascript_.Divide(Strength::FIRM), std::divides<double>());
252 TestBinaryArithOp(javascript_.Divide(LanguageMode::STRONG),
253 std::divides<double>());
254 } 250 }
255 251
256 252
257 TEST_F(TyperTest, TypeJSModulus) { 253 TEST_F(TyperTest, TypeJSModulus) {
258 TestBinaryArithOp(javascript_.Modulus(LanguageMode::SLOPPY), modulo); 254 TestBinaryArithOp(javascript_.Modulus(Strength::WEAK), modulo);
259 TestBinaryArithOp(javascript_.Modulus(LanguageMode::STRONG), modulo); 255 TestBinaryArithOp(javascript_.Modulus(Strength::FIRM), modulo);
260 } 256 }
261 257
262 258
263 TEST_F(TyperTest, TypeJSBitwiseOr) { 259 TEST_F(TyperTest, TypeJSBitwiseOr) {
264 TestBinaryBitOp(javascript_.BitwiseOr(LanguageMode::SLOPPY), bit_or); 260 TestBinaryBitOp(javascript_.BitwiseOr(Strength::WEAK), bit_or);
265 TestBinaryBitOp(javascript_.BitwiseOr(LanguageMode::STRONG), bit_or); 261 TestBinaryBitOp(javascript_.BitwiseOr(Strength::FIRM), bit_or);
266 } 262 }
267 263
268 264
269 TEST_F(TyperTest, TypeJSBitwiseAnd) { 265 TEST_F(TyperTest, TypeJSBitwiseAnd) {
270 TestBinaryBitOp(javascript_.BitwiseAnd(LanguageMode::SLOPPY), bit_and); 266 TestBinaryBitOp(javascript_.BitwiseAnd(Strength::WEAK), bit_and);
271 TestBinaryBitOp(javascript_.BitwiseAnd(LanguageMode::STRONG), bit_and); 267 TestBinaryBitOp(javascript_.BitwiseAnd(Strength::FIRM), bit_and);
272 } 268 }
273 269
274 270
275 TEST_F(TyperTest, TypeJSBitwiseXor) { 271 TEST_F(TyperTest, TypeJSBitwiseXor) {
276 TestBinaryBitOp(javascript_.BitwiseXor(LanguageMode::SLOPPY), bit_xor); 272 TestBinaryBitOp(javascript_.BitwiseXor(Strength::WEAK), bit_xor);
277 TestBinaryBitOp(javascript_.BitwiseXor(LanguageMode::STRONG), bit_xor); 273 TestBinaryBitOp(javascript_.BitwiseXor(Strength::FIRM), bit_xor);
278 } 274 }
279 275
280 276
281 TEST_F(TyperTest, TypeJSShiftLeft) { 277 TEST_F(TyperTest, TypeJSShiftLeft) {
282 TestBinaryBitOp(javascript_.ShiftLeft(LanguageMode::SLOPPY), shift_left); 278 TestBinaryBitOp(javascript_.ShiftLeft(Strength::WEAK), shift_left);
283 TestBinaryBitOp(javascript_.ShiftLeft(LanguageMode::STRONG), shift_left); 279 TestBinaryBitOp(javascript_.ShiftLeft(Strength::FIRM), shift_left);
284 } 280 }
285 281
286 282
287 TEST_F(TyperTest, TypeJSShiftRight) { 283 TEST_F(TyperTest, TypeJSShiftRight) {
288 TestBinaryBitOp(javascript_.ShiftRight(LanguageMode::SLOPPY), shift_right); 284 TestBinaryBitOp(javascript_.ShiftRight(Strength::WEAK), shift_right);
289 TestBinaryBitOp(javascript_.ShiftRight(LanguageMode::STRONG), shift_right); 285 TestBinaryBitOp(javascript_.ShiftRight(Strength::FIRM), shift_right);
290 } 286 }
291 287
292 288
293 TEST_F(TyperTest, TypeJSLessThan) { 289 TEST_F(TyperTest, TypeJSLessThan) {
294 TestBinaryCompareOp(javascript_.LessThan(LanguageMode::SLOPPY), 290 TestBinaryCompareOp(javascript_.LessThan(Strength::WEAK),
295 std::less<double>()); 291 std::less<double>());
296 TestBinaryCompareOp(javascript_.LessThan(LanguageMode::STRONG), 292 TestBinaryCompareOp(javascript_.LessThan(Strength::FIRM),
297 std::less<double>()); 293 std::less<double>());
298 } 294 }
299 295
300 296
301 TEST_F(TyperTest, TypeJSLessThanOrEqual) { 297 TEST_F(TyperTest, TypeJSLessThanOrEqual) {
302 TestBinaryCompareOp(javascript_.LessThanOrEqual(LanguageMode::SLOPPY), 298 TestBinaryCompareOp(javascript_.LessThanOrEqual(Strength::WEAK),
303 std::less_equal<double>()); 299 std::less_equal<double>());
304 TestBinaryCompareOp(javascript_.LessThanOrEqual(LanguageMode::STRONG), 300 TestBinaryCompareOp(javascript_.LessThanOrEqual(Strength::FIRM),
305 std::less_equal<double>()); 301 std::less_equal<double>());
306 } 302 }
307 303
308 304
309 TEST_F(TyperTest, TypeJSGreaterThan) { 305 TEST_F(TyperTest, TypeJSGreaterThan) {
310 TestBinaryCompareOp(javascript_.GreaterThan(LanguageMode::SLOPPY), 306 TestBinaryCompareOp(javascript_.GreaterThan(Strength::WEAK),
311 std::greater<double>()); 307 std::greater<double>());
312 TestBinaryCompareOp(javascript_.GreaterThan(LanguageMode::STRONG), 308 TestBinaryCompareOp(javascript_.GreaterThan(Strength::FIRM),
313 std::greater<double>()); 309 std::greater<double>());
314 } 310 }
315 311
316 312
317 TEST_F(TyperTest, TypeJSGreaterThanOrEqual) { 313 TEST_F(TyperTest, TypeJSGreaterThanOrEqual) {
318 TestBinaryCompareOp(javascript_.GreaterThanOrEqual(LanguageMode::SLOPPY), 314 TestBinaryCompareOp(javascript_.GreaterThanOrEqual(Strength::WEAK),
319 std::greater_equal<double>()); 315 std::greater_equal<double>());
320 TestBinaryCompareOp(javascript_.GreaterThanOrEqual(LanguageMode::STRONG), 316 TestBinaryCompareOp(javascript_.GreaterThanOrEqual(Strength::FIRM),
321 std::greater_equal<double>()); 317 std::greater_equal<double>());
322 } 318 }
323 319
324 320
325 TEST_F(TyperTest, TypeJSEqual) { 321 TEST_F(TyperTest, TypeJSEqual) {
326 TestBinaryCompareOp(javascript_.Equal(), std::equal_to<double>()); 322 TestBinaryCompareOp(javascript_.Equal(), std::equal_to<double>());
327 } 323 }
328 324
329 325
330 TEST_F(TyperTest, TypeJSNotEqual) { 326 TEST_F(TyperTest, TypeJSNotEqual) {
(...skipping 44 matching lines...)
375 371
376 372
377 #define TEST_FUNC(name) \ 373 #define TEST_FUNC(name) \
378 TEST_F(TyperTest, Monotonicity_##name) { \ 374 TEST_F(TyperTest, Monotonicity_##name) { \
379 TestBinaryMonotonicity(javascript_.name()); \ 375 TestBinaryMonotonicity(javascript_.name()); \
380 } 376 }
381 JSBINOP_LIST(TEST_FUNC) 377 JSBINOP_LIST(TEST_FUNC)
382 #undef TEST_FUNC 378 #undef TEST_FUNC
383 379
384 380
385 #define TEST_FUNC(name) \ 381 #define TEST_FUNC(name) \
386 TEST_F(TyperTest, Monotonicity_##name) { \ 382 TEST_F(TyperTest, Monotonicity_##name) { \
387 TestBinaryMonotonicity(javascript_.name(LanguageMode::SLOPPY)); \ 383 TestBinaryMonotonicity(javascript_.name(Strength::WEAK)); \
388 TestBinaryMonotonicity(javascript_.name(LanguageMode::STRONG)); \ 384 TestBinaryMonotonicity(javascript_.name(Strength::FIRM)); \
389 } 385 }
390 JSBINOP_WITH_STRONG_LIST(TEST_FUNC) 386 JSBINOP_WITH_STRONG_LIST(TEST_FUNC)
391 #undef TEST_FUNC 387 #undef TEST_FUNC
392 388
393 389
394 //------------------------------------------------------------------------------ 390 //------------------------------------------------------------------------------
395 // Regression tests 391 // Regression tests
396 392
397 393
398 TEST_F(TyperTest, TypeRegressInt32Constant) { 394 TEST_F(TyperTest, TypeRegressInt32Constant) {
399 int values[] = {-5, 10}; 395 int values[] = {-5, 10};
400 for (auto i : values) { 396 for (auto i : values) {
401 Node* c = graph()->NewNode(common()->Int32Constant(i)); 397 Node* c = graph()->NewNode(common()->Int32Constant(i));
402 Type* type = NodeProperties::GetBounds(c).upper; 398 Type* type = NodeProperties::GetBounds(c).upper;
403 EXPECT_TRUE(type->Is(NewRange(i, i))); 399 EXPECT_TRUE(type->Is(NewRange(i, i)));
404 } 400 }
405 } 401 }
OLDNEW
« src/compiler/js-operator.h ('K') | « test/unittests/compiler/scheduler-unittest.cc ('k') | no next file » | no next file with comments »

Powered by Google App Engine