Address pedantic lints (#52)
* Update int64.dart
* Update analysis_options.yaml
* Update int32.dart
* Update int64.dart
* Update int32.dart
* Update int32.dart
* Update intx.dart
* Update int32.dart
* Update all_tests.dart
* Update int32_test.dart
* Update pubspec.yaml
* Update int_64_vm_test.dart
* Update int64_test.dart
* Update int64_test.dart
* Update int64_test.dart
diff --git a/analysis_options.yaml b/analysis_options.yaml
index 6ddb107..628d93e 100644
--- a/analysis_options.yaml
+++ b/analysis_options.yaml
@@ -4,7 +4,6 @@
implicit-casts: false
linter:
rules:
- #- annotate_overrides
- avoid_function_literals_in_foreach_calls
- avoid_init_to_null
- avoid_null_checks_in_equality_operators
@@ -30,7 +29,6 @@
- list_remove_unrelated_type
- no_adjacent_strings_in_list
- non_constant_identifier_names
- #- omit_local_variable_types
- only_throw_errors
- overridden_fields
- package_api_docs
@@ -44,7 +42,6 @@
- prefer_generic_function_type_aliases
- prefer_initializing_formals
- prefer_interpolation_to_compose_strings
- #- prefer_single_quotes
- prefer_typing_uninitialized_variables
- slash_for_doc_comments
- test_types_in_equals
@@ -57,4 +54,3 @@
- unnecessary_new
- unnecessary_null_aware_assignments
- unnecessary_statements
- #- unnecessary_this
diff --git a/lib/src/int32.dart b/lib/src/int32.dart
index 3a9d017..ec31d9d 100644
--- a/lib/src/int32.dart
+++ b/lib/src/int32.dart
@@ -54,12 +54,12 @@
// TODO(rice) - Make this faster by converting several digits at once.
static Int32 parseRadix(String s, int radix) {
_validateRadix(radix);
- Int32 x = ZERO;
- for (int i = 0; i < s.length; i++) {
- int c = s.codeUnitAt(i);
- int digit = _decodeDigit(c);
+ var x = ZERO;
+ for (var i = 0; i < s.length; i++) {
+ var c = s.codeUnitAt(i);
+ var digit = _decodeDigit(c);
if (digit < 0 || digit >= radix) {
- throw FormatException("Non-radix code unit: $c");
+ throw FormatException('Non-radix code unit: $c');
}
x = ((x * radix) + digit) as Int32;
}
@@ -145,76 +145,88 @@
// Int32 % Int32 => Int32
// Int32 % Int64 => Int32
+ @override
IntX operator +(other) {
if (other is Int64) {
- return this.toInt64() + other;
+ return toInt64() + other;
}
return Int32(_i + _toInt(other));
}
+ @override
IntX operator -(other) {
if (other is Int64) {
- return this.toInt64() - other;
+ return toInt64() - other;
}
return Int32(_i - _toInt(other));
}
+ @override
Int32 operator -() => Int32(-_i);
+ @override
IntX operator *(other) {
if (other is Int64) {
- return this.toInt64() * other;
+ return toInt64() * other;
}
// TODO(rice) - optimize
- return (this.toInt64() * other).toInt32();
+ return (toInt64() * other).toInt32();
}
+ @override
Int32 operator %(other) {
if (other is Int64) {
// Result will be Int32
- return (this.toInt64() % other).toInt32();
+ return (toInt64() % other).toInt32();
}
return Int32(_i % _toInt(other));
}
+ @override
Int32 operator ~/(other) {
if (other is Int64) {
- return (this.toInt64() ~/ other).toInt32();
+ return (toInt64() ~/ other).toInt32();
}
return Int32(_i ~/ _toInt(other));
}
+ @override
Int32 remainder(other) {
if (other is Int64) {
- Int64 t = this.toInt64();
+ var t = toInt64();
return (t - (t ~/ other) * other).toInt32();
}
return (this - (this ~/ other) * other) as Int32;
}
+ @override
Int32 operator &(other) {
if (other is Int64) {
- return (this.toInt64() & other).toInt32();
+ return (toInt64() & other).toInt32();
}
return Int32(_i & _toInt(other));
}
+ @override
Int32 operator |(other) {
if (other is Int64) {
- return (this.toInt64() | other).toInt32();
+ return (toInt64() | other).toInt32();
}
return Int32(_i | _toInt(other));
}
+ @override
Int32 operator ^(other) {
if (other is Int64) {
- return (this.toInt64() ^ other).toInt32();
+ return (toInt64() ^ other).toInt32();
}
return Int32(_i ^ _toInt(other));
}
+ @override
Int32 operator ~() => Int32(~_i);
+ @override
Int32 operator <<(int n) {
if (n < 0) {
throw ArgumentError(n);
@@ -225,6 +237,7 @@
return Int32(_i << n);
}
+ @override
Int32 operator >>(int n) {
if (n < 0) {
throw ArgumentError(n);
@@ -241,6 +254,7 @@
return Int32(value);
}
+ @override
Int32 shiftRightUnsigned(int n) {
if (n < 0) {
throw ArgumentError(n);
@@ -259,64 +273,86 @@
/// Returns [:true:] if this [Int32] has the same numeric value as the
/// given object. The argument may be an [int] or an [IntX].
+ @override
bool operator ==(other) {
if (other is Int32) {
return _i == other._i;
} else if (other is Int64) {
- return this.toInt64() == other;
+ return toInt64() == other;
} else if (other is int) {
return _i == other;
}
return false;
}
+ @override
int compareTo(other) {
if (other is Int64) {
- return this.toInt64().compareTo(other);
+ return toInt64().compareTo(other);
}
return _i.compareTo(_toInt(other));
}
+ @override
bool operator <(other) {
if (other is Int64) {
- return this.toInt64() < other;
+ return toInt64() < other;
}
return _i < _toInt(other);
}
+ @override
bool operator <=(other) {
if (other is Int64) {
- return this.toInt64() <= other;
+ return toInt64() <= other;
}
return _i <= _toInt(other);
}
+ @override
bool operator >(other) {
if (other is Int64) {
- return this.toInt64() > other;
+ return toInt64() > other;
}
return _i > _toInt(other);
}
+ @override
bool operator >=(other) {
if (other is Int64) {
- return this.toInt64() >= other;
+ return toInt64() >= other;
}
return _i >= _toInt(other);
}
+ @override
bool get isEven => (_i & 0x1) == 0;
+
+ @override
bool get isMaxValue => _i == 2147483647;
+
+ @override
bool get isMinValue => _i == -2147483648;
+
+ @override
bool get isNegative => _i < 0;
+
+ @override
bool get isOdd => (_i & 0x1) == 1;
+
+ @override
bool get isZero => _i == 0;
+
+ @override
int get bitLength => _i.bitLength;
+ @override
int get hashCode => _i;
+ @override
Int32 abs() => _i < 0 ? Int32(-_i) : this;
+ @override
Int32 clamp(lowerLimit, upperLimit) {
if (this < lowerLimit) {
if (lowerLimit is IntX) return lowerLimit.toInt32();
@@ -330,21 +366,27 @@
return this;
}
+ @override
int numberOfLeadingZeros() => _numberOfLeadingZeros(_i);
+
+ @override
int numberOfTrailingZeros() => _numberOfTrailingZeros(_i);
+ @override
Int32 toSigned(int width) {
if (width < 1 || width > 32) throw RangeError.range(width, 1, 32);
return Int32(_i.toSigned(width));
}
+ @override
Int32 toUnsigned(int width) {
if (width < 0 || width > 32) throw RangeError.range(width, 0, 32);
return Int32(_i.toUnsigned(width));
}
+ @override
List<int> toBytes() {
- List<int> result = List<int>(4);
+ var result = List<int>(4);
result[0] = _i & 0xff;
result[1] = (_i >> 8) & 0xff;
result[2] = (_i >> 16) & 0xff;
@@ -352,12 +394,24 @@
return result;
}
+ @override
double toDouble() => _i.toDouble();
+
+ @override
int toInt() => _i;
+
+ @override
Int32 toInt32() => this;
+
+ @override
Int64 toInt64() => Int64(_i);
+ @override
String toString() => _i.toString();
+
+ @override
String toHexString() => _i.toRadixString(16);
+
+ @override
String toRadixString(int radix) => _i.toRadixString(radix);
}
diff --git a/lib/src/int64.dart b/lib/src/int64.dart
index 3453a09..d624073 100644
--- a/lib/src/int64.dart
+++ b/lib/src/int64.dart
@@ -2,6 +2,11 @@
// 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.
+// Many locals are declared as `int` or `double`. We keep local variable types
+// because the types are critical to the efficiency of many operations.
+//
+// ignore_for_file: omit_local_variable_types
+
part of fixnum;
/// An immutable 64-bit signed integer, in the range [-2^63, 2^63 - 1].
@@ -75,7 +80,7 @@
int c = s.codeUnitAt(i);
int digit = Int32._decodeDigit(c);
if (digit < 0 || digit >= radix) {
- throw FormatException("Non-radix char code: $c");
+ throw FormatException('Non-radix char code: $c');
}
// [radix] and [digit] are at most 6 bits, component is 22, so we can
@@ -192,6 +197,7 @@
throw ArgumentError.value(value);
}
+ @override
Int64 operator +(other) {
Int64 o = _promote(other);
int sum0 = _l + o._l;
@@ -200,13 +206,16 @@
return Int64._masked(sum0, sum1, sum2);
}
+ @override
Int64 operator -(other) {
Int64 o = _promote(other);
return _sub(_l, _m, _h, o._l, o._m, o._h);
}
+ @override
Int64 operator -() => _negate(_l, _m, _h);
+ @override
Int64 operator *(other) {
Int64 o = _promote(other);
@@ -288,12 +297,16 @@
return Int64._masked(c0, c1, c2);
}
+ @override
Int64 operator %(other) => _divide(this, other, _RETURN_MOD);
+ @override
Int64 operator ~/(other) => _divide(this, other, _RETURN_DIV);
+ @override
Int64 remainder(other) => _divide(this, other, _RETURN_REM);
+ @override
Int64 operator &(other) {
Int64 o = _promote(other);
int a0 = _l & o._l;
@@ -302,6 +315,7 @@
return Int64._masked(a0, a1, a2);
}
+ @override
Int64 operator |(other) {
Int64 o = _promote(other);
int a0 = _l | o._l;
@@ -310,6 +324,7 @@
return Int64._masked(a0, a1, a2);
}
+ @override
Int64 operator ^(other) {
Int64 o = _promote(other);
int a0 = _l ^ o._l;
@@ -318,10 +333,12 @@
return Int64._masked(a0, a1, a2);
}
+ @override
Int64 operator ~() {
return Int64._masked(~_l, ~_m, ~_h);
}
+ @override
Int64 operator <<(int n) {
if (n < 0) {
throw ArgumentError.value(n);
@@ -348,6 +365,7 @@
return Int64._masked(res0, res1, res2);
}
+ @override
Int64 operator >>(int n) {
if (n < 0) {
throw ArgumentError.value(n);
@@ -393,6 +411,7 @@
return Int64._masked(res0, res1, res2);
}
+ @override
Int64 shiftRightUnsigned(int n) {
if (n < 0) {
throw ArgumentError.value(n);
@@ -422,6 +441,7 @@
/// Returns [:true:] if this [Int64] has the same numeric value as the
/// given object. The argument may be an [int] or an [IntX].
+ @override
bool operator ==(other) {
Int64 o;
if (other is Int64) {
@@ -441,6 +461,7 @@
return false;
}
+ @override
int compareTo(other) => _compareTo(other);
int _compareTo(other) {
@@ -468,18 +489,37 @@
return 0;
}
+ @override
bool operator <(other) => _compareTo(other) < 0;
+
+ @override
bool operator <=(other) => _compareTo(other) <= 0;
- bool operator >(other) => this._compareTo(other) > 0;
+
+ @override
+ bool operator >(other) => _compareTo(other) > 0;
+
+ @override
bool operator >=(other) => _compareTo(other) >= 0;
+ @override
bool get isEven => (_l & 0x1) == 0;
+
+ @override
bool get isMaxValue => (_h == _MASK2 >> 1) && _m == _MASK && _l == _MASK;
+
+ @override
bool get isMinValue => _h == _SIGN_BIT_MASK && _m == 0 && _l == 0;
+
+ @override
bool get isNegative => (_h & _SIGN_BIT_MASK) != 0;
+
+ @override
bool get isOdd => (_l & 0x1) == 1;
+
+ @override
bool get isZero => _h == 0 && _m == 0 && _l == 0;
+ @override
int get bitLength {
if (isZero) return 0;
int a0 = _l, a1 = _m, a2 = _h;
@@ -494,6 +534,7 @@
}
/// Returns a hash code based on all the bits of this [Int64].
+ @override
int get hashCode {
// TODO(sra): Should we ensure that hashCode values match corresponding int?
// i.e. should `new Int64(x).hashCode == x.hashCode`?
@@ -502,10 +543,12 @@
return bottom ^ top;
}
+ @override
Int64 abs() {
- return this.isNegative ? -this : this;
+ return isNegative ? -this : this;
}
+ @override
Int64 clamp(lowerLimit, upperLimit) {
Int64 lower = _promote(lowerLimit);
Int64 upper = _promote(upperLimit);
@@ -516,6 +559,7 @@
/// Returns the number of leading zeros in this [Int64] as an [int]
/// between 0 and 64.
+ @override
int numberOfLeadingZeros() {
int b2 = Int32._numberOfLeadingZeros(_h);
if (b2 == 32) {
@@ -532,6 +576,7 @@
/// Returns the number of trailing zeros in this [Int64] as an [int]
/// between 0 and 64.
+ @override
int numberOfTrailingZeros() {
int zeros = Int32._numberOfTrailingZeros(_l);
if (zeros < 32) {
@@ -551,6 +596,7 @@
return 64;
}
+ @override
Int64 toSigned(int width) {
if (width < 1 || width > 64) throw RangeError.range(width, 1, 64);
if (width > _BITS01) {
@@ -568,6 +614,7 @@
}
}
+ @override
Int64 toUnsigned(int width) {
if (width < 0 || width > 64) throw RangeError.range(width, 0, 64);
if (width > _BITS01) {
@@ -582,6 +629,7 @@
}
}
+ @override
List<int> toBytes() {
List<int> result = List<int>(8);
result[0] = _l & 0xff;
@@ -595,8 +643,10 @@
return result;
}
+ @override
double toDouble() => toInt().toDouble();
+ @override
int toInt() {
int l = _l;
int m = _m;
@@ -614,24 +664,28 @@
}
/// Returns an [Int32] containing the low 32 bits of this [Int64].
+ @override
Int32 toInt32() {
return Int32(((_m & 0x3ff) << _BITS) | _l);
}
/// Returns `this`.
+ @override
Int64 toInt64() => this;
/// Returns the value of this [Int64] as a decimal [String].
+ @override
String toString() => _toRadixString(10);
// TODO(rice) - Make this faster by avoiding arithmetic.
+ @override
String toHexString() {
- if (isZero) return "0";
+ if (isZero) return '0';
Int64 x = this;
- String hexStr = "";
+ String hexStr = '';
while (!x.isZero) {
int digit = x._l & 0xf;
- hexStr = "${_hexDigit(digit)}$hexStr";
+ hexStr = '${_hexDigit(digit)}$hexStr';
x = x.shiftRightUnsigned(4);
}
return hexStr;
@@ -648,6 +702,7 @@
return _toRadixStringUnsigned(Int32._validateRadix(radix), _l, _m, _h, '');
}
+ @override
String toRadixString(int radix) {
return _toRadixString(Int32._validateRadix(radix));
}
@@ -712,7 +767,7 @@
// need only two chunks, but radix values 17-19 and 33-36 generate only 15
// or 16 bits per iteration, so sometimes the third chunk is needed.
- String chunk1 = "", chunk2 = "", chunk3 = "";
+ String chunk1 = '', chunk2 = '', chunk3 = '';
while (!(d4 == 0 && d3 == 0)) {
int q = d4 ~/ fatRadix;
@@ -739,7 +794,7 @@
r = d0 - q * fatRadix;
d0 = q;
- assert(chunk3 == "");
+ assert(chunk3 == '');
chunk3 = chunk2;
chunk2 = chunk1;
// Adding [fatRadix] Forces an extra digit which we discard to get a fixed
@@ -814,7 +869,7 @@
];
String toDebugString() {
- return "Int64[_l=$_l, _m=$_m, _h=$_h]";
+ return 'Int64[_l=$_l, _m=$_m, _h=$_h]';
}
static Int64 _masked(int a0, int a1, int a2) =>
@@ -831,7 +886,7 @@
return _sub(0, 0, 0, b0, b1, b2);
}
- String _hexDigit(int digit) => "0123456789ABCDEF"[digit];
+ String _hexDigit(int digit) => '0123456789ABCDEF'[digit];
// Work around dart2js bugs with negative arguments to '>>' operator.
static int _shiftRight(int x, int n) {
diff --git a/lib/src/intx.dart b/lib/src/intx.dart
index cdc4b05..e1c1342 100644
--- a/lib/src/intx.dart
+++ b/lib/src/intx.dart
@@ -65,10 +65,12 @@
/// bits to the right. High-order bits are filled with zeros.
IntX shiftRightUnsigned(int shiftAmount);
+ @override
int compareTo(other);
/// Returns `true` if and only if [other] is an int or IntX equal in
/// value to this integer.
+ @override
bool operator ==(other);
/// Relational less than operator.
@@ -103,6 +105,7 @@
/// Returns `true` if and only if this integer is zero.
bool get isZero;
+ @override
int get hashCode;
/// Returns the absolute value of this integer.
@@ -179,6 +182,7 @@
/// Returns a string representing the value of this integer in decimal
/// notation; example: `'13'`.
+ @override
String toString();
/// Returns a string representing the value of this integer in hexadecimal
diff --git a/pubspec.yaml b/pubspec.yaml
index a08ee33..51c8708 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -1,5 +1,5 @@
name: fixnum
-version: 0.10.11
+version: 0.10.12-dev
description: Library for 32- and 64-bit signed fixed-width integers.
author: Dart Team <misc@dartlang.org>
diff --git a/test/all_tests.dart b/test/all_tests.dart
index a93d00b..eb530b7 100644
--- a/test/all_tests.dart
+++ b/test/all_tests.dart
@@ -1,7 +1,7 @@
import 'int32_test.dart' as int32_test;
import 'int64_test.dart' as int64_test;
-main() {
+void main() {
int32_test.main();
int64_test.main();
}
diff --git a/test/int32_test.dart b/test/int32_test.dart
index b9ba31a..db96123 100644
--- a/test/int32_test.dart
+++ b/test/int32_test.dart
@@ -6,40 +6,40 @@
import 'package:test/test.dart';
void main() {
- group("isX tests", () {
- test("isEven", () {
+ group('isX tests', () {
+ test('isEven', () {
expect((-Int32.ONE).isEven, false);
expect(Int32.ZERO.isEven, true);
expect(Int32.ONE.isEven, false);
expect(Int32.TWO.isEven, true);
});
- test("isMaxValue", () {
+ test('isMaxValue', () {
expect(Int32.MIN_VALUE.isMaxValue, false);
expect(Int32.ZERO.isMaxValue, false);
expect(Int32.MAX_VALUE.isMaxValue, true);
});
- test("isMinValue", () {
+ test('isMinValue', () {
expect(Int32.MIN_VALUE.isMinValue, true);
expect(Int32.ZERO.isMinValue, false);
expect(Int32.MAX_VALUE.isMinValue, false);
});
- test("isNegative", () {
+ test('isNegative', () {
expect(Int32.MIN_VALUE.isNegative, true);
expect(Int32.ZERO.isNegative, false);
expect(Int32.ONE.isNegative, false);
});
- test("isOdd", () {
+ test('isOdd', () {
expect((-Int32.ONE).isOdd, true);
expect(Int32.ZERO.isOdd, false);
expect(Int32.ONE.isOdd, true);
expect(Int32.TWO.isOdd, false);
});
- test("isZero", () {
+ test('isZero', () {
expect(Int32.MIN_VALUE.isZero, false);
expect(Int32.ZERO.isZero, true);
expect(Int32.MAX_VALUE.isZero, false);
});
- test("bitLength", () {
+ test('bitLength', () {
expect(Int32(-2).bitLength, 1);
expect((-Int32.ONE).bitLength, 0);
expect(Int32.ZERO.bitLength, 0);
@@ -50,13 +50,13 @@
});
});
- group("arithmetic operators", () {
- Int32 n1 = Int32(1234);
- Int32 n2 = Int32(9876);
- Int32 n3 = Int32(-1234);
- Int32 n4 = Int32(-9876);
+ group('arithmetic operators', () {
+ var n1 = Int32(1234);
+ var n2 = Int32(9876);
+ var n3 = Int32(-1234);
+ var n4 = Int32(-9876);
- test("+", () {
+ test('+', () {
expect(n1 + n2, Int32(11110));
expect(n3 + n2, Int32(8642));
expect(n3 + n4, Int32(-11110));
@@ -65,7 +65,7 @@
expect(() => Int32(17) + null, throwsArgumentError);
});
- test("-", () {
+ test('-', () {
expect(n1 - n2, Int32(-8642));
expect(n3 - n2, Int32(-11110));
expect(n3 - n4, Int32(8642));
@@ -74,12 +74,12 @@
expect(() => Int32(17) - null, throwsArgumentError);
});
- test("unary -", () {
+ test('unary -', () {
expect(-n1, Int32(-1234));
expect(-Int32.ZERO, Int32.ZERO);
});
- test("*", () {
+ test('*', () {
expect(n1 * n2, Int32(12186984));
expect(n2 * n3, Int32(-12186984));
expect(n3 * n3, Int32(1522756));
@@ -92,7 +92,7 @@
expect(() => Int32(17) * null, throwsArgumentError);
});
- test("~/", () {
+ test('~/', () {
expect(Int32(829893893) ~/ Int32(1919), Int32(432461));
expect(Int32(0x12345678) ~/ Int32(0x22), Int32(0x12345678 ~/ 0x22));
expect(Int32(829893893) ~/ Int64(1919), Int32(432461));
@@ -107,13 +107,13 @@
expect(() => Int32(17) ~/ null, throwsArgumentError);
});
- test("%", () {
+ test('%', () {
expect(Int32(0x12345678) % Int32(0x22), Int32(0x12345678 % 0x22));
expect(Int32(0x12345678) % Int64(0x22), Int32(0x12345678 % 0x22));
expect(() => Int32(17) % null, throwsArgumentError);
});
- test("remainder", () {
+ test('remainder', () {
expect(Int32(0x12345678).remainder(Int32(0x22)),
Int32(0x12345678.remainder(0x22) as int));
expect(Int32(0x12345678).remainder(Int32(-0x22)),
@@ -127,7 +127,7 @@
expect(() => Int32(17).remainder(null), throwsArgumentError);
});
- test("abs", () {
+ test('abs', () {
// NOTE: Int32.MIN_VALUE.abs() is undefined
expect((Int32.MIN_VALUE + 1).abs(), Int32.MAX_VALUE);
expect(Int32(-1).abs(), Int32(1));
@@ -136,8 +136,8 @@
expect(Int32.MAX_VALUE.abs(), Int32.MAX_VALUE);
});
- test("clamp", () {
- Int32 val = Int32(17);
+ test('clamp', () {
+ var val = Int32(17);
expect(val.clamp(20, 30), Int32(20));
expect(val.clamp(10, 20), Int32(17));
expect(val.clamp(10, 15), Int32(15));
@@ -160,14 +160,14 @@
});
});
- group("leading/trailing zeros", () {
- test("numberOfLeadingZeros", () {
+ group('leading/trailing zeros', () {
+ test('numberOfLeadingZeros', () {
expect(Int32(0).numberOfLeadingZeros(), 32);
expect(Int32(1).numberOfLeadingZeros(), 31);
expect(Int32(0xffff).numberOfLeadingZeros(), 16);
expect(Int32(-1).numberOfLeadingZeros(), 0);
});
- test("numberOfTrailingZeros", () {
+ test('numberOfTrailingZeros', () {
expect(Int32(0).numberOfTrailingZeros(), 32);
expect(Int32(0x80000000).numberOfTrailingZeros(), 31);
expect(Int32(1).numberOfTrailingZeros(), 0);
@@ -175,8 +175,8 @@
});
});
- group("comparison operators", () {
- test("compareTo", () {
+ group('comparison operators', () {
+ test('compareTo', () {
expect(Int32(0).compareTo(-1), 1);
expect(Int32(0).compareTo(0), 0);
expect(Int32(0).compareTo(1), -1);
@@ -188,7 +188,7 @@
expect(Int32(0).compareTo(Int64(1)), -1);
});
- test("<", () {
+ test('<', () {
expect(Int32(17) < Int32(18), true);
expect(Int32(17) < Int32(17), false);
expect(Int32(17) < Int32(16), false);
@@ -200,7 +200,7 @@
expect(() => Int32(17) < null, throwsArgumentError);
});
- test("<=", () {
+ test('<=', () {
expect(Int32(17) <= Int32(18), true);
expect(Int32(17) <= Int32(17), true);
expect(Int32(17) <= Int32(16), false);
@@ -212,7 +212,7 @@
expect(() => Int32(17) <= null, throwsArgumentError);
});
- test("==", () {
+ test('==', () {
expect(Int32(17), isNot(equals(Int32(18))));
expect(Int32(17), equals(Int32(17)));
expect(Int32(17), isNot(equals(Int32(16))));
@@ -227,7 +227,7 @@
expect(Int32(17), isNot(equals(null)));
});
- test(">=", () {
+ test('>=', () {
expect(Int32(17) >= Int32(18), false);
expect(Int32(17) >= Int32(17), true);
expect(Int32(17) >= Int32(16), true);
@@ -239,7 +239,7 @@
expect(() => Int32(17) >= null, throwsArgumentError);
});
- test(">", () {
+ test('>', () {
expect(Int32(17) > Int32(18), false);
expect(Int32(17) > Int32(17), false);
expect(Int32(17) > Int32(16), true);
@@ -252,8 +252,8 @@
});
});
- group("bitwise operators", () {
- test("&", () {
+ group('bitwise operators', () {
+ test('&', () {
expect(Int32(0x12345678) & Int32(0x22222222),
Int32(0x12345678 & 0x22222222));
expect(Int32(0x12345678) & Int64(0x22222222),
@@ -261,7 +261,7 @@
expect(() => Int32(17) & null, throwsArgumentError);
});
- test("|", () {
+ test('|', () {
expect(Int32(0x12345678) | Int32(0x22222222),
Int32(0x12345678 | 0x22222222));
expect(Int32(0x12345678) | Int64(0x22222222),
@@ -269,7 +269,7 @@
expect(() => Int32(17) | null, throwsArgumentError);
});
- test("^", () {
+ test('^', () {
expect(Int32(0x12345678) ^ Int32(0x22222222),
Int32(0x12345678 ^ 0x22222222));
expect(Int32(0x12345678) ^ Int64(0x22222222),
@@ -277,14 +277,14 @@
expect(() => Int32(17) ^ null, throwsArgumentError);
});
- test("~", () {
+ test('~', () {
expect(~(Int32(0x12345678)), Int32(~0x12345678));
expect(-(Int32(0x12345678)), Int64(-0x12345678));
});
});
- group("bitshift operators", () {
- test("<<", () {
+ group('bitshift operators', () {
+ test('<<', () {
expect(Int32(0x12345678) << 7, Int32(0x12345678 << 7));
expect(Int32(0x12345678) << 32, Int32.ZERO);
expect(Int32(0x12345678) << 33, Int32.ZERO);
@@ -292,7 +292,7 @@
expect(() => Int32(17) << null, throwsNoSuchMethodError);
});
- test(">>", () {
+ test('>>', () {
expect(Int32(0x12345678) >> 7, Int32(0x12345678 >> 7));
expect(Int32(0x12345678) >> 32, Int32.ZERO);
expect(Int32(0x12345678) >> 33, Int32.ZERO);
@@ -302,7 +302,7 @@
expect(() => Int32(17) >> null, throwsNoSuchMethodError);
});
- test("shiftRightUnsigned", () {
+ test('shiftRightUnsigned', () {
expect(Int32(0x12345678).shiftRightUnsigned(7), Int32(0x12345678 >> 7));
expect(Int32(0x12345678).shiftRightUnsigned(32), Int32.ZERO);
expect(Int32(0x12345678).shiftRightUnsigned(33), Int32.ZERO);
@@ -314,8 +314,8 @@
});
});
- group("conversions", () {
- test("toSigned", () {
+ group('conversions', () {
+ test('toSigned', () {
expect(Int32.ONE.toSigned(2), Int32.ONE);
expect(Int32.ONE.toSigned(1), -Int32.ONE);
expect(Int32.MAX_VALUE.toSigned(32), Int32.MAX_VALUE);
@@ -325,7 +325,7 @@
expect(() => Int32.ONE.toSigned(0), throwsRangeError);
expect(() => Int32.ONE.toSigned(33), throwsRangeError);
});
- test("toUnsigned", () {
+ test('toUnsigned', () {
expect(Int32.ONE.toUnsigned(1), Int32.ONE);
expect(Int32.ONE.toUnsigned(0), Int32.ZERO);
expect(Int32.MAX_VALUE.toUnsigned(32), Int32.MAX_VALUE);
@@ -335,23 +335,23 @@
expect(() => Int32.ONE.toUnsigned(-1), throwsRangeError);
expect(() => Int32.ONE.toUnsigned(33), throwsRangeError);
});
- test("toDouble", () {
+ test('toDouble', () {
expect(Int32(17).toDouble(), same(17.0));
expect(Int32(-17).toDouble(), same(-17.0));
});
- test("toInt", () {
+ test('toInt', () {
expect(Int32(17).toInt(), 17);
expect(Int32(-17).toInt(), -17);
});
- test("toInt32", () {
+ test('toInt32', () {
expect(Int32(17).toInt32(), Int32(17));
expect(Int32(-17).toInt32(), Int32(-17));
});
- test("toInt64", () {
+ test('toInt64', () {
expect(Int32(17).toInt64(), Int64(17));
expect(Int32(-17).toInt64(), Int64(-17));
});
- test("toBytes", () {
+ test('toBytes', () {
expect(Int32(0).toBytes(), [0, 0, 0, 0]);
expect(Int32(0x01020304).toBytes(), [4, 3, 2, 1]);
expect(Int32(0x04030201).toBytes(), [1, 2, 3, 4]);
@@ -359,9 +359,9 @@
});
});
- group("parse", () {
- test("base 10", () {
- checkInt(int x) {
+ group('parse', () {
+ test('base 10', () {
+ void checkInt(int x) {
expect(Int32.parseRadix('$x', 10), Int32(x));
}
@@ -377,8 +377,8 @@
expect(() => Int32.parseRadix('plugh', 10), throwsFormatException);
});
- test("parseRadix", () {
- check(String s, int r, String x) {
+ test('parseRadix', () {
+ void check(String s, int r, String x) {
expect(Int32.parseRadix(s, r).toString(), x);
}
@@ -386,50 +386,50 @@
check('95', 12, '113');
});
- test("parseInt", () {
+ test('parseInt', () {
expect(Int32.parseInt('0'), Int32(0));
expect(Int32.parseInt('1000'), Int32(1000));
expect(Int32.parseInt('4294967296'), Int32(4294967296));
});
- test("parseHex", () {
+ test('parseHex', () {
expect(Int32.parseHex('deadbeef'), Int32(0xdeadbeef));
expect(Int32.parseHex('cafebabe'), Int32(0xcafebabe));
expect(Int32.parseHex('8badf00d'), Int32(0x8badf00d));
});
});
- group("string representation", () {
- test("toString", () {
- expect(Int32(0).toString(), "0");
- expect(Int32(1).toString(), "1");
- expect(Int32(-1).toString(), "-1");
- expect(Int32(1000).toString(), "1000");
- expect(Int32(-1000).toString(), "-1000");
- expect(Int32(123456789).toString(), "123456789");
- expect(Int32(2147483647).toString(), "2147483647");
- expect(Int32(2147483648).toString(), "-2147483648");
- expect(Int32(2147483649).toString(), "-2147483647");
- expect(Int32(2147483650).toString(), "-2147483646");
- expect(Int32(-2147483648).toString(), "-2147483648");
- expect(Int32(-2147483649).toString(), "2147483647");
- expect(Int32(-2147483650).toString(), "2147483646");
+ group('string representation', () {
+ test('toString', () {
+ expect(Int32(0).toString(), '0');
+ expect(Int32(1).toString(), '1');
+ expect(Int32(-1).toString(), '-1');
+ expect(Int32(1000).toString(), '1000');
+ expect(Int32(-1000).toString(), '-1000');
+ expect(Int32(123456789).toString(), '123456789');
+ expect(Int32(2147483647).toString(), '2147483647');
+ expect(Int32(2147483648).toString(), '-2147483648');
+ expect(Int32(2147483649).toString(), '-2147483647');
+ expect(Int32(2147483650).toString(), '-2147483646');
+ expect(Int32(-2147483648).toString(), '-2147483648');
+ expect(Int32(-2147483649).toString(), '2147483647');
+ expect(Int32(-2147483650).toString(), '2147483646');
});
});
- group("toHexString", () {
- test("returns hexadecimal string representation", () {
- expect(Int32(-1).toHexString(), "-1");
- expect((Int32(-1) >> 8).toHexString(), "-1");
- expect((Int32(-1) << 8).toHexString(), "-100");
- expect(Int32(123456789).toHexString(), "75bcd15");
- expect(Int32(-1).shiftRightUnsigned(8).toHexString(), "ffffff");
+ group('toHexString', () {
+ test('returns hexadecimal string representation', () {
+ expect(Int32(-1).toHexString(), '-1');
+ expect((Int32(-1) >> 8).toHexString(), '-1');
+ expect((Int32(-1) << 8).toHexString(), '-100');
+ expect(Int32(123456789).toHexString(), '75bcd15');
+ expect(Int32(-1).shiftRightUnsigned(8).toHexString(), 'ffffff');
});
});
- group("toRadixString", () {
- test("returns base n string representation", () {
- expect(Int32(123456789).toRadixString(5), "223101104124");
+ group('toRadixString', () {
+ test('returns base n string representation', () {
+ expect(Int32(123456789).toRadixString(5), '223101104124');
});
});
}
diff --git a/test/int64_test.dart b/test/int64_test.dart
index 1acc3a4..7994a8d 100644
--- a/test/int64_test.dart
+++ b/test/int64_test.dart
@@ -2,15 +2,20 @@
// 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.
+// We permit local variable types in this test because they statically 'assert'
+// that the operations have an expected type.
+//
+// ignore_for_file: omit_local_variable_types
+
library int64test;
import 'package:fixnum/fixnum.dart';
import 'package:test/test.dart';
void main() {
- group("fromBytes", () {
- test("fromBytes", () {
- checkBytes(List<int> bytes, int h, int l) {
+ group('fromBytes', () {
+ test('fromBytes', () {
+ void checkBytes(List<int> bytes, int h, int l) {
expect(Int64.fromBytes(bytes), Int64.fromInts(h, l));
}
@@ -22,8 +27,8 @@
checkBytes([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff], 0xffffffff,
0xffffffff);
});
- test("fromBytesBigEndian", () {
- checkBytes(List<int> bytes, int h, int l) {
+ test('fromBytesBigEndian', () {
+ void checkBytes(List<int> bytes, int h, int l) {
expect(Int64.fromBytesBigEndian(bytes), Int64.fromInts(h, l));
}
@@ -37,48 +42,48 @@
});
});
- argumentErrorTest(name, op, [receiver = Int64.ONE]) {
- throwsArgumentErrorMentioning(String substring) =>
+ void argumentErrorTest(name, op, [receiver = Int64.ONE]) {
+ Matcher throwsArgumentErrorMentioning(String substring) =>
throwsA((e) => e is ArgumentError && '$e'.contains(substring));
expect(() => op(receiver, null), throwsArgumentErrorMentioning('null'));
expect(() => op(receiver, 'foo'), throwsArgumentErrorMentioning(r'"foo"'));
}
- group("is-tests", () {
- test("isEven", () {
+ group('is-tests', () {
+ test('isEven', () {
expect((-Int64.ONE).isEven, false);
expect(Int64.ZERO.isEven, true);
expect(Int64.ONE.isEven, false);
expect(Int64.TWO.isEven, true);
});
- test("isMaxValue", () {
+ test('isMaxValue', () {
expect(Int64.MIN_VALUE.isMaxValue, false);
expect(Int64.ZERO.isMaxValue, false);
expect(Int64.MAX_VALUE.isMaxValue, true);
});
- test("isMinValue", () {
+ test('isMinValue', () {
expect(Int64.MIN_VALUE.isMinValue, true);
expect(Int64.ZERO.isMinValue, false);
expect(Int64.MAX_VALUE.isMinValue, false);
});
- test("isNegative", () {
+ test('isNegative', () {
expect(Int64.MIN_VALUE.isNegative, true);
expect(Int64.ZERO.isNegative, false);
expect(Int64.ONE.isNegative, false);
});
- test("isOdd", () {
+ test('isOdd', () {
expect((-Int64.ONE).isOdd, true);
expect(Int64.ZERO.isOdd, false);
expect(Int64.ONE.isOdd, true);
expect(Int64.TWO.isOdd, false);
});
- test("isZero", () {
+ test('isZero', () {
expect(Int64.MIN_VALUE.isZero, false);
expect(Int64.ZERO.isZero, true);
expect(Int64.MAX_VALUE.isZero, false);
});
- test("bitLength", () {
+ test('bitLength', () {
expect(Int64(-2).bitLength, 1);
expect((-Int64.ONE).bitLength, 0);
expect(Int64.ZERO.bitLength, 0);
@@ -92,7 +97,7 @@
});
});
- group("arithmetic operators", () {
+ group('arithmetic operators', () {
Int64 n1 = Int64(1234);
Int64 n2 = Int64(9876);
Int64 n3 = Int64(-1234);
@@ -100,30 +105,30 @@
Int64 n5 = Int64.fromInts(0x12345678, 0xabcdabcd);
Int64 n6 = Int64.fromInts(0x77773333, 0x22224444);
- test("+", () {
+ test('+', () {
expect(n1 + n2, Int64(11110));
expect(n3 + n2, Int64(8642));
expect(n3 + n4, Int64(-11110));
expect(n5 + n6, Int64.fromInts(0x89ab89ab, 0xcdeff011));
expect(Int64.MAX_VALUE + 1, Int64.MIN_VALUE);
- argumentErrorTest("+", (a, b) => a + b);
+ argumentErrorTest('+', (a, b) => a + b);
});
- test("-", () {
+ test('-', () {
expect(n1 - n2, Int64(-8642));
expect(n3 - n2, Int64(-11110));
expect(n3 - n4, Int64(8642));
expect(n5 - n6, Int64.fromInts(0x9abd2345, 0x89ab6789));
expect(Int64.MIN_VALUE - 1, Int64.MAX_VALUE);
- argumentErrorTest("-", (a, b) => a - b);
+ argumentErrorTest('-', (a, b) => a - b);
});
- test("unary -", () {
+ test('unary -', () {
expect(-n1, Int64(-1234));
expect(-Int64.ZERO, Int64.ZERO);
});
- test("*", () {
+ test('*', () {
expect(Int64(1111) * Int64(3), Int64(3333));
expect(Int64(1111) * Int64(-3), Int64(-3333));
expect(Int64(-1111) * Int64(3), Int64(-3333));
@@ -156,10 +161,10 @@
expect(Int64.MIN_VALUE * Int64(2), Int64.ZERO);
expect(Int64.MIN_VALUE * Int64(1), Int64.MIN_VALUE);
expect(Int64.MIN_VALUE * Int64(-1), Int64.MIN_VALUE);
- argumentErrorTest("*", (a, b) => a * b);
+ argumentErrorTest('*', (a, b) => a * b);
});
- test("~/", () {
+ test('~/', () {
Int64 deadBeef = Int64.fromInts(0xDEADBEEF, 0xDEADBEEF);
Int64 ten = Int64(10);
@@ -233,10 +238,10 @@
expect(Int64.MIN_VALUE ~/ Int64(-1), Int64.MIN_VALUE);
expect(() => Int64(17) ~/ Int64.ZERO,
throwsA(const TypeMatcher<IntegerDivisionByZeroException>()));
- argumentErrorTest("~/", (a, b) => a ~/ b);
+ argumentErrorTest('~/', (a, b) => a ~/ b);
});
- test("%", () {
+ test('%', () {
// Define % as Euclidean mod, with positive result for all arguments
expect(Int64.ZERO % Int64(1000), Int64.ZERO);
expect(Int64.MIN_VALUE % Int64.MIN_VALUE, Int64.ZERO);
@@ -273,10 +278,10 @@
Int64(-0x12345678.remainder(0x22) as int));
expect(Int32(0x12345678).remainder(Int64(0x22)),
Int64(0x12345678.remainder(0x22) as int));
- argumentErrorTest("%", (a, b) => a % b);
+ argumentErrorTest('%', (a, b) => a % b);
});
- test("clamp", () {
+ test('clamp', () {
Int64 val = Int64(17);
expect(val.clamp(20, 30), Int64(20));
expect(val.clamp(10, 20), Int64(17));
@@ -297,9 +302,9 @@
});
});
- group("leading/trailing zeros", () {
- test("numberOfLeadingZeros", () {
- checkZeros(Int64 value, int zeros) {
+ group('leading/trailing zeros', () {
+ test('numberOfLeadingZeros', () {
+ void checkZeros(Int64 value, int zeros) {
expect(value.numberOfLeadingZeros(), zeros);
}
@@ -313,8 +318,8 @@
checkZeros(Int64(-1), 0);
});
- test("numberOfTrailingZeros", () {
- checkZeros(Int64 value, int zeros) {
+ test('numberOfTrailingZeros', () {
+ void checkZeros(Int64 value, int zeros) {
expect(value.numberOfTrailingZeros(), zeros);
}
@@ -330,12 +335,12 @@
});
});
- group("comparison operators", () {
+ group('comparison operators', () {
Int64 largeNeg = Int64.fromInts(0x82341234, 0x0);
Int64 largePos = Int64.fromInts(0x12341234, 0x0);
Int64 largePosPlusOne = largePos + Int64(1);
- test("<", () {
+ test('<', () {
expect(Int64(10) < Int64(11), true);
expect(Int64(10) < Int64(10), false);
expect(Int64(10) < Int64(9), false);
@@ -350,10 +355,10 @@
expect(largePosPlusOne < largePos, false);
expect(Int64.MIN_VALUE < Int64.MAX_VALUE, true);
expect(Int64.MAX_VALUE < Int64.MIN_VALUE, false);
- argumentErrorTest("<", (a, b) => a < b);
+ argumentErrorTest('<', (a, b) => a < b);
});
- test("<=", () {
+ test('<=', () {
expect(Int64(10) <= Int64(11), true);
expect(Int64(10) <= Int64(10), true);
expect(Int64(10) <= Int64(9), false);
@@ -369,10 +374,10 @@
expect(largePosPlusOne <= largePos, false);
expect(Int64.MIN_VALUE <= Int64.MAX_VALUE, true);
expect(Int64.MAX_VALUE <= Int64.MIN_VALUE, false);
- argumentErrorTest("<=", (a, b) => a <= b);
+ argumentErrorTest('<=', (a, b) => a <= b);
});
- test("==", () {
+ test('==', () {
expect(Int64(0), equals(Int64(0)));
expect(Int64(0), isNot(equals(Int64(1))));
expect(Int64(0), equals(Int32(0)));
@@ -400,7 +405,7 @@
expect(Int64(17), isNot(equals(null)));
});
- test(">=", () {
+ test('>=', () {
expect(Int64(10) >= Int64(11), false);
expect(Int64(10) >= Int64(10), true);
expect(Int64(10) >= Int64(9), true);
@@ -416,10 +421,10 @@
expect(largePosPlusOne >= largePos, true);
expect(Int64.MIN_VALUE >= Int64.MAX_VALUE, false);
expect(Int64.MAX_VALUE >= Int64.MIN_VALUE, true);
- argumentErrorTest(">=", (a, b) => a >= b);
+ argumentErrorTest('>=', (a, b) => a >= b);
});
- test(">", () {
+ test('>', () {
expect(Int64(10) > Int64(11), false);
expect(Int64(10) > Int64(10), false);
expect(Int64(10) > Int64(9), true);
@@ -437,42 +442,42 @@
expect(Int64.ZERO > Int64.MIN_VALUE, true);
expect(Int64.MIN_VALUE > Int64.MAX_VALUE, false);
expect(Int64.MAX_VALUE > Int64.MIN_VALUE, true);
- argumentErrorTest(">", (a, b) => a > b);
+ argumentErrorTest('>', (a, b) => a > b);
});
});
- group("bitwise operators", () {
+ group('bitwise operators', () {
Int64 n1 = Int64(1234);
Int64 n2 = Int64(9876);
Int64 n3 = Int64(-1234);
Int64 n4 = Int64(0x1234) << 32;
Int64 n5 = Int64(0x9876) << 32;
- test("&", () {
+ test('&', () {
expect(n1 & n2, Int64(1168));
expect(n3 & n2, Int64(8708));
expect(n4 & n5, Int64(0x1034) << 32);
expect(() => n1 & null, throwsArgumentError);
- argumentErrorTest("&", (a, b) => a & b);
+ argumentErrorTest('&', (a, b) => a & b);
});
- test("|", () {
+ test('|', () {
expect(n1 | n2, Int64(9942));
expect(n3 | n2, Int64(-66));
expect(n4 | n5, Int64(0x9a76) << 32);
expect(() => n1 | null, throwsArgumentError);
- argumentErrorTest("|", (a, b) => a | b);
+ argumentErrorTest('|', (a, b) => a | b);
});
- test("^", () {
+ test('^', () {
expect(n1 ^ n2, Int64(8774));
expect(n3 ^ n2, Int64(-8774));
expect(n4 ^ n5, Int64(0x8a42) << 32);
expect(() => n1 ^ null, throwsArgumentError);
- argumentErrorTest("^", (a, b) => a ^ b);
+ argumentErrorTest('^', (a, b) => a ^ b);
});
- test("~", () {
+ test('~', () {
expect(-Int64(1), Int64(-1));
expect(-Int64(-1), Int64(1));
expect(-Int64.MIN_VALUE, Int64.MIN_VALUE);
@@ -485,8 +490,8 @@
});
});
- group("bitshift operators", () {
- test("<<", () {
+ group('bitshift operators', () {
+ test('<<', () {
expect(Int64.fromInts(0x12341234, 0x45674567) << 10,
Int64.fromInts(0xd048d115, 0x9d159c00));
expect(Int64.fromInts(0x92341234, 0x45674567) << 10,
@@ -499,8 +504,8 @@
expect(() => Int64(17) << null, throwsNoSuchMethodError);
});
- test(">>", () {
- expect((Int64.MIN_VALUE >> 13).toString(), "-1125899906842624");
+ test('>>', () {
+ expect((Int64.MIN_VALUE >> 13).toString(), '-1125899906842624');
expect(Int64.fromInts(0x12341234, 0x45674567) >> 10,
Int64.fromInts(0x48d04, 0x8d1159d1));
expect(Int64.fromInts(0x92341234, 0x45674567) >> 10,
@@ -551,7 +556,7 @@
expect(() => Int64(17) >> null, throwsNoSuchMethodError);
});
- test("shiftRightUnsigned", () {
+ test('shiftRightUnsigned', () {
expect(Int64.fromInts(0x12341234, 0x45674567).shiftRightUnsigned(10),
Int64.fromInts(0x48d04, 0x8d1159d1));
expect(Int64.fromInts(0x92341234, 0x45674567).shiftRightUnsigned(10),
@@ -598,7 +603,7 @@
expect(() => Int64(17).shiftRightUnsigned(null), throwsNoSuchMethodError);
});
- test("overflow", () {
+ test('overflow', () {
expect((Int64(1) << 63) >> 1, -Int64.fromInts(0x40000000, 0x00000000));
expect((Int64(-1) << 32) << 32, Int64(0));
expect(Int64.MIN_VALUE << 0, Int64.MIN_VALUE);
@@ -610,8 +615,8 @@
});
});
- group("conversions", () {
- test("toSigned", () {
+ group('conversions', () {
+ test('toSigned', () {
expect((Int64.ONE << 44).toSigned(46), Int64.ONE << 44);
expect((Int64.ONE << 44).toSigned(45), -(Int64.ONE << 44));
expect((Int64.ONE << 22).toSigned(24), Int64.ONE << 22);
@@ -625,7 +630,7 @@
expect(() => Int64.ONE.toSigned(0), throwsRangeError);
expect(() => Int64.ONE.toSigned(65), throwsRangeError);
});
- test("toUnsigned", () {
+ test('toUnsigned', () {
expect((Int64.ONE << 44).toUnsigned(45), Int64.ONE << 44);
expect((Int64.ONE << 44).toUnsigned(44), Int64.ZERO);
expect((Int64.ONE << 22).toUnsigned(23), Int64.ONE << 22);
@@ -639,7 +644,7 @@
expect(() => Int64.ONE.toUnsigned(-1), throwsRangeError);
expect(() => Int64.ONE.toUnsigned(65), throwsRangeError);
});
- test("toDouble", () {
+ test('toDouble', () {
expect(Int64(0).toDouble(), same(0.0));
expect(Int64(100).toDouble(), same(100.0));
expect(Int64(-100).toDouble(), same(-100.0));
@@ -651,27 +656,27 @@
expect(Int64(4503599627370496).toDouble(), same(4503599627370496.0));
expect(Int64(-4503599627370495).toDouble(), same(-4503599627370495.0));
expect(Int64(-4503599627370496).toDouble(), same(-4503599627370496.0));
- expect(Int64.parseInt("-10000000000000000").toDouble().toStringAsFixed(1),
- "-10000000000000000.0");
- expect(Int64.parseInt("-10000000000000001").toDouble().toStringAsFixed(1),
- "-10000000000000000.0");
- expect(Int64.parseInt("-10000000000000002").toDouble().toStringAsFixed(1),
- "-10000000000000002.0");
- expect(Int64.parseInt("-10000000000000003").toDouble().toStringAsFixed(1),
- "-10000000000000004.0");
- expect(Int64.parseInt("-10000000000000004").toDouble().toStringAsFixed(1),
- "-10000000000000004.0");
- expect(Int64.parseInt("-10000000000000005").toDouble().toStringAsFixed(1),
- "-10000000000000004.0");
- expect(Int64.parseInt("-10000000000000006").toDouble().toStringAsFixed(1),
- "-10000000000000006.0");
- expect(Int64.parseInt("-10000000000000007").toDouble().toStringAsFixed(1),
- "-10000000000000008.0");
- expect(Int64.parseInt("-10000000000000008").toDouble().toStringAsFixed(1),
- "-10000000000000008.0");
+ expect(Int64.parseInt('-10000000000000000').toDouble().toStringAsFixed(1),
+ '-10000000000000000.0');
+ expect(Int64.parseInt('-10000000000000001').toDouble().toStringAsFixed(1),
+ '-10000000000000000.0');
+ expect(Int64.parseInt('-10000000000000002').toDouble().toStringAsFixed(1),
+ '-10000000000000002.0');
+ expect(Int64.parseInt('-10000000000000003').toDouble().toStringAsFixed(1),
+ '-10000000000000004.0');
+ expect(Int64.parseInt('-10000000000000004').toDouble().toStringAsFixed(1),
+ '-10000000000000004.0');
+ expect(Int64.parseInt('-10000000000000005').toDouble().toStringAsFixed(1),
+ '-10000000000000004.0');
+ expect(Int64.parseInt('-10000000000000006').toDouble().toStringAsFixed(1),
+ '-10000000000000006.0');
+ expect(Int64.parseInt('-10000000000000007').toDouble().toStringAsFixed(1),
+ '-10000000000000008.0');
+ expect(Int64.parseInt('-10000000000000008').toDouble().toStringAsFixed(1),
+ '-10000000000000008.0');
});
- test("toInt", () {
+ test('toInt', () {
expect(Int64(0).toInt(), 0);
expect(Int64(100).toInt(), 100);
expect(Int64(-100).toInt(), -100);
@@ -685,7 +690,7 @@
expect(Int64(-4503599627370496).toInt(), -4503599627370496);
});
- test("toInt32", () {
+ test('toInt32', () {
expect(Int64(0).toInt32(), Int32(0));
expect(Int64(1).toInt32(), Int32(1));
expect(Int64(-1).toInt32(), Int32(-1));
@@ -699,7 +704,7 @@
expect(Int64(-2147483651).toInt32(), Int32(2147483645));
});
- test("toBytes", () {
+ test('toBytes', () {
expect(Int64(0).toBytes(), [0, 0, 0, 0, 0, 0, 0, 0]);
expect(Int64.fromInts(0x08070605, 0x04030201).toBytes(),
[1, 2, 3, 4, 5, 6, 7, 8]);
@@ -710,7 +715,7 @@
});
});
- test("JavaScript 53-bit integer boundary", () {
+ test('JavaScript 53-bit integer boundary', () {
Int64 _factorial(Int64 n) {
if (n.isZero) {
return Int64(1);
@@ -724,13 +729,13 @@
expect(fact18 ~/ fact17, Int64(18));
});
- test("min, max values", () {
+ test('min, max values', () {
expect(Int64(1) << 63, Int64.MIN_VALUE);
expect(-(Int64.MIN_VALUE + Int64(1)), Int64.MAX_VALUE);
});
- test("negation", () {
- check(int n) {
+ test('negation', () {
+ void check(int n) {
// Sign change should commute with conversion.
expect(-Int64(-n), Int64(n));
expect(Int64(-n), -Int64(n));
@@ -741,9 +746,9 @@
check(9223372000000000000); // near Int64.MAX_VALUE, has exact double value
});
- group("parse", () {
- test("parseRadix10", () {
- checkInt(int x) {
+ group('parse', () {
+ test('parseRadix10', () {
+ void checkInt(int x) {
expect(Int64.parseRadix('$x', 10), Int64(x));
}
@@ -767,8 +772,8 @@
expect(() => Int64.parseRadix('-', 10), throwsFormatException);
});
- test("parseHex", () {
- checkHex(String hexStr, int h, int l) {
+ test('parseHex', () {
+ void checkHex(String hexStr, int h, int l) {
expect(Int64.parseHex(hexStr), Int64.fromInts(h, l));
}
@@ -789,18 +794,18 @@
expect(() => Int64.parseHex('-'), throwsFormatException);
});
- test("parseRadix", () {
- check(String s, int r, String x) {
+ test('parseRadix', () {
+ void check(String s, int r, String x) {
expect(Int64.parseRadix(s, r).toString(), x);
}
check('ghoul', 36, '27699213');
check('ghoul', 35, '24769346');
// Min and max value.
- check("-9223372036854775808", 10, "-9223372036854775808");
- check("9223372036854775807", 10, "9223372036854775807");
+ check('-9223372036854775808', 10, '-9223372036854775808');
+ check('9223372036854775807', 10, '9223372036854775807');
// Overflow during parsing.
- check("9223372036854775808", 10, "-9223372036854775808");
+ check('9223372036854775808', 10, '-9223372036854775808');
expect(() => Int64.parseRadix('0', 1), throwsRangeError);
expect(() => Int64.parseRadix('0', 37), throwsRangeError);
@@ -808,85 +813,85 @@
expect(() => Int64.parseRadix('xyzzy', 10), throwsFormatException);
});
- test("parseRadixN", () {
- check(String s, int r) {
+ test('parseRadixN', () {
+ void check(String s, int r) {
expect(Int64.parseRadix(s, r).toRadixString(r), s);
}
- check("2ppp111222333", 33); // This value & radix requires three chunks.
+ check('2ppp111222333', 33); // This value & radix requires three chunks.
});
});
- group("string representation", () {
- test("toString", () {
- expect(Int64(0).toString(), "0");
- expect(Int64(1).toString(), "1");
- expect(Int64(-1).toString(), "-1");
- expect(Int64(-10).toString(), "-10");
- expect(Int64.MIN_VALUE.toString(), "-9223372036854775808");
- expect(Int64.MAX_VALUE.toString(), "9223372036854775807");
+ group('string representation', () {
+ test('toString', () {
+ expect(Int64(0).toString(), '0');
+ expect(Int64(1).toString(), '1');
+ expect(Int64(-1).toString(), '-1');
+ expect(Int64(-10).toString(), '-10');
+ expect(Int64.MIN_VALUE.toString(), '-9223372036854775808');
+ expect(Int64.MAX_VALUE.toString(), '9223372036854775807');
int top = 922337201;
int bottom = 967490662;
Int64 fullnum = (Int64(1000000000) * Int64(top)) + Int64(bottom);
- expect(fullnum.toString(), "922337201967490662");
- expect((-fullnum).toString(), "-922337201967490662");
- expect(Int64(123456789).toString(), "123456789");
+ expect(fullnum.toString(), '922337201967490662');
+ expect((-fullnum).toString(), '-922337201967490662');
+ expect(Int64(123456789).toString(), '123456789');
});
- test("toHexString", () {
+ test('toHexString', () {
Int64 deadbeef12341234 = Int64.fromInts(0xDEADBEEF, 0x12341234);
- expect(Int64.ZERO.toHexString(), "0");
- expect(deadbeef12341234.toHexString(), "DEADBEEF12341234");
+ expect(Int64.ZERO.toHexString(), '0');
+ expect(deadbeef12341234.toHexString(), 'DEADBEEF12341234');
expect(Int64.fromInts(0x17678A7, 0xDEF01234).toHexString(),
- "17678A7DEF01234");
- expect(Int64(123456789).toHexString(), "75BCD15");
+ '17678A7DEF01234');
+ expect(Int64(123456789).toHexString(), '75BCD15');
});
- test("toRadixString", () {
- expect(Int64(123456789).toRadixString(5), "223101104124");
+ test('toRadixString', () {
+ expect(Int64(123456789).toRadixString(5), '223101104124');
expect(Int64.MIN_VALUE.toRadixString(2),
- "-1000000000000000000000000000000000000000000000000000000000000000");
+ '-1000000000000000000000000000000000000000000000000000000000000000');
expect(Int64.MIN_VALUE.toRadixString(3),
- "-2021110011022210012102010021220101220222");
+ '-2021110011022210012102010021220101220222');
expect(Int64.MIN_VALUE.toRadixString(4),
- "-20000000000000000000000000000000");
- expect(Int64.MIN_VALUE.toRadixString(5), "-1104332401304422434310311213");
- expect(Int64.MIN_VALUE.toRadixString(6), "-1540241003031030222122212");
- expect(Int64.MIN_VALUE.toRadixString(7), "-22341010611245052052301");
- expect(Int64.MIN_VALUE.toRadixString(8), "-1000000000000000000000");
- expect(Int64.MIN_VALUE.toRadixString(9), "-67404283172107811828");
- expect(Int64.MIN_VALUE.toRadixString(10), "-9223372036854775808");
- expect(Int64.MIN_VALUE.toRadixString(11), "-1728002635214590698");
- expect(Int64.MIN_VALUE.toRadixString(12), "-41a792678515120368");
- expect(Int64.MIN_VALUE.toRadixString(13), "-10b269549075433c38");
- expect(Int64.MIN_VALUE.toRadixString(14), "-4340724c6c71dc7a8");
- expect(Int64.MIN_VALUE.toRadixString(15), "-160e2ad3246366808");
- expect(Int64.MIN_VALUE.toRadixString(16), "-8000000000000000");
+ '-20000000000000000000000000000000');
+ expect(Int64.MIN_VALUE.toRadixString(5), '-1104332401304422434310311213');
+ expect(Int64.MIN_VALUE.toRadixString(6), '-1540241003031030222122212');
+ expect(Int64.MIN_VALUE.toRadixString(7), '-22341010611245052052301');
+ expect(Int64.MIN_VALUE.toRadixString(8), '-1000000000000000000000');
+ expect(Int64.MIN_VALUE.toRadixString(9), '-67404283172107811828');
+ expect(Int64.MIN_VALUE.toRadixString(10), '-9223372036854775808');
+ expect(Int64.MIN_VALUE.toRadixString(11), '-1728002635214590698');
+ expect(Int64.MIN_VALUE.toRadixString(12), '-41a792678515120368');
+ expect(Int64.MIN_VALUE.toRadixString(13), '-10b269549075433c38');
+ expect(Int64.MIN_VALUE.toRadixString(14), '-4340724c6c71dc7a8');
+ expect(Int64.MIN_VALUE.toRadixString(15), '-160e2ad3246366808');
+ expect(Int64.MIN_VALUE.toRadixString(16), '-8000000000000000');
expect(Int64.MAX_VALUE.toRadixString(2),
- "111111111111111111111111111111111111111111111111111111111111111");
+ '111111111111111111111111111111111111111111111111111111111111111');
expect(Int64.MAX_VALUE.toRadixString(3),
- "2021110011022210012102010021220101220221");
+ '2021110011022210012102010021220101220221');
expect(
- Int64.MAX_VALUE.toRadixString(4), "13333333333333333333333333333333");
- expect(Int64.MAX_VALUE.toRadixString(5), "1104332401304422434310311212");
- expect(Int64.MAX_VALUE.toRadixString(6), "1540241003031030222122211");
- expect(Int64.MAX_VALUE.toRadixString(7), "22341010611245052052300");
- expect(Int64.MAX_VALUE.toRadixString(8), "777777777777777777777");
- expect(Int64.MAX_VALUE.toRadixString(9), "67404283172107811827");
- expect(Int64.MAX_VALUE.toRadixString(10), "9223372036854775807");
- expect(Int64.MAX_VALUE.toRadixString(11), "1728002635214590697");
- expect(Int64.MAX_VALUE.toRadixString(12), "41a792678515120367");
- expect(Int64.MAX_VALUE.toRadixString(13), "10b269549075433c37");
- expect(Int64.MAX_VALUE.toRadixString(14), "4340724c6c71dc7a7");
- expect(Int64.MAX_VALUE.toRadixString(15), "160e2ad3246366807");
- expect(Int64.MAX_VALUE.toRadixString(16), "7fffffffffffffff");
+ Int64.MAX_VALUE.toRadixString(4), '13333333333333333333333333333333');
+ expect(Int64.MAX_VALUE.toRadixString(5), '1104332401304422434310311212');
+ expect(Int64.MAX_VALUE.toRadixString(6), '1540241003031030222122211');
+ expect(Int64.MAX_VALUE.toRadixString(7), '22341010611245052052300');
+ expect(Int64.MAX_VALUE.toRadixString(8), '777777777777777777777');
+ expect(Int64.MAX_VALUE.toRadixString(9), '67404283172107811827');
+ expect(Int64.MAX_VALUE.toRadixString(10), '9223372036854775807');
+ expect(Int64.MAX_VALUE.toRadixString(11), '1728002635214590697');
+ expect(Int64.MAX_VALUE.toRadixString(12), '41a792678515120367');
+ expect(Int64.MAX_VALUE.toRadixString(13), '10b269549075433c37');
+ expect(Int64.MAX_VALUE.toRadixString(14), '4340724c6c71dc7a7');
+ expect(Int64.MAX_VALUE.toRadixString(15), '160e2ad3246366807');
+ expect(Int64.MAX_VALUE.toRadixString(16), '7fffffffffffffff');
expect(() => Int64(42).toRadixString(-1), throwsArgumentError);
expect(() => Int64(42).toRadixString(0), throwsArgumentError);
expect(() => Int64(42).toRadixString(37), throwsArgumentError);
});
- test("toStringUnsigned", () {
+ test('toStringUnsigned', () {
List<Int64> values = [];
for (int high = 0; high < 16; high++) {
for (int low = -2; low <= 2; low++) {
diff --git a/test/int_64_vm_test.dart b/test/int_64_vm_test.dart
index e5e1303..2ab161e 100644
--- a/test/int_64_vm_test.dart
+++ b/test/int_64_vm_test.dart
@@ -8,31 +8,31 @@
import 'package:test/test.dart';
void main() {
- group("conversions", () {
- test("toInt", () {
- expect(Int64.parseInt("-10000000000000000").toInt(),
+ group('conversions', () {
+ test('toInt', () {
+ expect(Int64.parseInt('-10000000000000000').toInt(),
same(-10000000000000000));
- expect(Int64.parseInt("-10000000000000001").toInt(),
+ expect(Int64.parseInt('-10000000000000001').toInt(),
same(-10000000000000001));
- expect(Int64.parseInt("-10000000000000002").toInt(),
+ expect(Int64.parseInt('-10000000000000002').toInt(),
same(-10000000000000002));
- expect(Int64.parseInt("-10000000000000003").toInt(),
+ expect(Int64.parseInt('-10000000000000003').toInt(),
same(-10000000000000003));
- expect(Int64.parseInt("-10000000000000004").toInt(),
+ expect(Int64.parseInt('-10000000000000004').toInt(),
same(-10000000000000004));
- expect(Int64.parseInt("-10000000000000005").toInt(),
+ expect(Int64.parseInt('-10000000000000005').toInt(),
same(-10000000000000005));
- expect(Int64.parseInt("-10000000000000006").toInt(),
+ expect(Int64.parseInt('-10000000000000006').toInt(),
same(-10000000000000006));
- expect(Int64.parseInt("-10000000000000007").toInt(),
+ expect(Int64.parseInt('-10000000000000007').toInt(),
same(-10000000000000007));
- expect(Int64.parseInt("-10000000000000008").toInt(),
+ expect(Int64.parseInt('-10000000000000008').toInt(),
same(-10000000000000008));
});
});
- test("", () {
- check(int n) {
+ test('', () {
+ void check(int n) {
// Sign change should commute with conversion.
expect(-Int64(-n), Int64(n));
expect(Int64(-n), -Int64(n));
