tests/corelib/unsigned_shift_test.dart

// 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();
  testNonDoubleShifts();
  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.throws(() => 1 >>> number); // infinity > 64.
  }
}

void testNonDoubleShifts() {
  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);
      Expect.throws(() => 1 >>> number);
    }
  }
}

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;
}