blob: ab3220fcfeecd92a343f9e16115d1817fd1664e3 [file] [log] [blame]
// Copyright (c) 2019, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
// SharedOptions=--enable-experiment=triple-shift
import "package:expect/expect.dart";
// The >>> operator is (again) supported by Dart, and used on `int`.
// This test assumes that the JS implementation of `>>>` uses the JS `>>>`
// operator directly (that is, convert the value to Uint32, shift right,)
main() {
testIntegerShifts();
testNonIntegerShifts();
testConstantShifts();
}
void testIntegerShifts() {
for (int i = -1; i <= 65; i++) {
testShift(0, i);
testShift(1, i);
testShift(2, i);
testShift(3, i);
testShift(-1, i);
testShift(-5, i);
// . . .
testShift(0x7fffffff, i);
testShift(0x55555555, i);
testShift(0xaaaaaaaa, i);
testShift(0x80000000, i);
// . . . .
testShift(0x7fffffffffff, i);
testShift(0xffffffffffff, i);
// . . . . .
testShift(0x7ffffffffffff000, i);
testShift(0xfffffffffffff000, i);
// Construct the values below to get 'all ones' values on the VM without a
// compile-time error for roundned literals on the web. The arithmetic
// produces rounded values on the web, so they are effectively testing zero.
testShift(0x7ffffffffffff000 + 0xfff, i);
testShift(0xfffffffffffff000 + 0xfff, i);
}
// JavaScript numbers may consider Infinity as an integer.
// If so, it is zero when converted to a fixed precision.
if (double.infinity is int) {
int number = (double.infinity as int);
Expect.equals(0, number >>> 1);
Expect.equals(0, 1 >>> number); // infinity > 64.
}
}
void testNonIntegerShifts() {
double n = 0.0;
n >>> 1; //# 01: compile-time error
for (dynamic number in [0.0, 1.0, 2.4, -2.4, double.infinity, double.nan]) {
if (number is! int) {
Expect.throws(() => number >>> 1); //# 07: ok
Expect.throws(() => 1 >>> number); //# 08: ok
}
}
}
void testConstantShifts() {
const c = C();
// >>> is a constant operation on integers.
const c1 = 2 >>> 1;
const c2 = (1 >>> 0) >>> 0;
const c3 = 1 >>> 65;
// >>> is a non-constant operation on other types.
const c4 = false ? 1 : c >>> c; //# 02: compile-time error
const c5 = true || c >>> c; //# 03: compile-time error
const c6 = true || "string" >>> 1; //# 04: compile-time error
const c7 = c >>> c; //# 05: compile-time error
// Or if shifting throws
const c8 = 1 >>> -1; //# 06: compile-time error
Expect.isNotNull(c1 + c2 + c3); // Avoid "unused variable" warnings.
}
const bool isJSBitOps = (-1 | 0) > 0;
const String jsFlag = isJSBitOps ? " (JS)" : "";
void testShift(int value, int shift) {
var title = "0x${value.toRadixString(16)} >>> $shift$jsFlag";
if (shift < 0) {
// No platform allows shifting a negative.
Expect.throwsArgumentError(() => value >>> shift, "$title: shift < 0");
return;
}
var expected;
if (isJSBitOps) {
// TODO: Check that this is the desired behavior for JS >>>.
expected = value.toUnsigned(32) >> shift;
} else if (value < 0) {
if (shift >= 64) {
expected = 0;
} else if (shift > 0) {
expected = (value >> shift).toUnsigned(64 - shift);
} else {
expected = value;
}
} else {
expected = value >> shift;
}
Expect.equals(expected, value >>> shift, title);
}
class C {
const C();
C operator >>>(C other) => other;
}