Added bitLength, clamp(), toDouble(), toSigned(), toUnsigned().

pkg/fixnum/test/int_32_test.dart

 // Copyright (c) 2012, 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.
 
 library Int32test;
 import 'package:fixnum/fixnum.dart';
 import 'package:unittest/unittest.dart';
 
 void main() {
+  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", () {
+      expect(Int32.MIN_VALUE.isMaxValue, false);
+      expect(Int32.ZERO.isMaxValue, false);
+      expect(Int32.MAX_VALUE.isMaxValue, true);
+    });
+    test("isMinValue", () {
+      expect(Int32.MIN_VALUE.isMinValue, true);
+      expect(Int32.ZERO.isMinValue, false);
+      expect(Int32.MAX_VALUE.isMinValue, false);
+    });
+    test("isNegative", () {
+      expect(Int32.MIN_VALUE.isNegative, true);
+      expect(Int32.ZERO.isNegative, false);
+      expect(Int32.ONE.isNegative, false);
+    });
+    test("isOdd", () {
+      expect((-Int32.ONE).isOdd, true);
+      expect(Int32.ZERO.isOdd, false);
+      expect(Int32.ONE.isOdd, true);
+      expect(Int32.TWO.isOdd, false);
+    });
+    test("isZero", () {
+      expect(Int32.MIN_VALUE.isZero, false);
+      expect(Int32.ZERO.isZero, true);
+      expect(Int32.MAX_VALUE.isZero, false);
+    });
+    test("bitLength", () {
+      expect(new Int32(-2).bitLength, 1);
+      expect((-Int32.ONE).bitLength, 0);
+      expect(Int32.ZERO.bitLength, 0);
+      expect(Int32.ONE.bitLength, 1);
+      expect(new Int32(2).bitLength, 2);
+      expect(Int32.MAX_VALUE.bitLength, 31);
+      expect(Int32.MIN_VALUE.bitLength, 31);
+    });
+  });
+
   group("arithmetic operators", () {
     Int32 n1 = new Int32(1234);
     Int32 n2 = new Int32(9876);
     Int32 n3 = new Int32(-1234);
     Int32 n4 = new Int32(-9876);
     Int32 n5 = new Int32(0x12345678);
     Int32 n6 = new Int32(0x22222222);
 
     test("+", () {
       expect(n1 + n2, new Int32(11110));
@@ skipping 58 matching lines @@
       expect(new Int32(0x12345678).remainder(new Int32(-0x22)),
           new Int32(0x12345678.remainder(-0x22)));
       expect(new Int32(-0x12345678).remainder(new Int32(-0x22)),
           new Int32(-0x12345678.remainder(-0x22)));
       expect(new Int32(-0x12345678).remainder(new Int32(0x22)),
           new Int32(-0x12345678.remainder(0x22)));
       expect(new Int32(0x12345678).remainder(new Int64(0x22)),
           new Int32(0x12345678.remainder(0x22)));
       expect(() => new Int32(17).remainder(null), throws);
     });
+
+    test("clamp", () {
+      Int32 val = new Int32(17);
+      expect(val.clamp(20, 30), new Int32(20));
+      expect(val.clamp(10, 20), new Int32(17));
+      expect(val.clamp(10, 15), new Int32(15));
+
+      expect(val.clamp(new Int32(20), new Int32(30)), new Int32(20));
+      expect(val.clamp(new Int32(10), new Int32(20)), new Int32(17));
+      expect(val.clamp(new Int32(10), new Int32(15)), new Int32(15));
+
+      expect(val.clamp(new Int64(20), new Int64(30)), new Int32(20));
+      expect(val.clamp(new Int64(10), new Int64(20)), new Int32(17));
+      expect(val.clamp(new Int64(10), new Int64(15)), new Int32(15));
+      expect(val.clamp(Int64.MIN_VALUE, new Int64(30)), new Int32(17));
+      expect(val.clamp(new Int64(10), Int64.MAX_VALUE), new Int32(17));
+
+      expect(() => val.clamp(1, 'b'), throwsA(isArgumentError));
+      expect(() => val.clamp('a', 1), throwsA(isArgumentError));
+    });
   });
 
   group("comparison operators", () {
     test("<", () {
       expect(new Int32(17) < new Int32(18), true);
       expect(new Int32(17) < new Int32(17), false);
       expect(new Int32(17) < new Int32(16), false);
       expect(new Int32(17) < new Int64(18), true);
       expect(new Int32(17) < new Int64(17), false);
       expect(new Int32(17) < new Int64(16), false);
@@ skipping 96 matching lines @@
     });
 
     test("shiftRightUnsigned", () {
       expect(new Int32(0x12345678).shiftRightUnsigned(7),
           new Int32(0x12345678 >> 7));
       expect(() => (new Int32(17).shiftRightUnsigned(-1)), throwsArgumentError);
       expect(() => (new Int32(17).shiftRightUnsigned(null)), throws);
     });
   });
 
-  group("type conversions", () {
-    expect(new Int32(17).toInt(), 17);
-    expect(new Int32(-17).toInt(), -17);
-    expect(new Int32(17).toInt32(), new Int32(17));
-    expect(new Int32(-17).toInt32(), new Int32(-17));
-    expect(new Int32(17).toInt64(), new Int64(17));
-    expect(new Int32(-17).toInt64(), new Int64(-17));
+  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);
+      expect(Int32.MIN_VALUE.toSigned(32), Int32.MIN_VALUE);
+      expect(Int32.MAX_VALUE.toSigned(31), -Int32.ONE);
+      expect(Int32.MIN_VALUE.toSigned(31), Int32.ZERO);
+      expect(() => Int32.ONE.toSigned(0), throws);
+      expect(() => Int32.ONE.toSigned(33), throws);
+    });
+    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);
+      expect(Int32.MIN_VALUE.toUnsigned(32), Int32.MIN_VALUE);
+      expect(Int32.MAX_VALUE.toUnsigned(31), Int32.MAX_VALUE);
+      expect(Int32.MIN_VALUE.toUnsigned(31), Int32.ZERO);
+      expect(() => Int32.ONE.toUnsigned(-1), throws);
+      expect(() => Int32.ONE.toUnsigned(33), throws);
+    });
+    test("toDouble", () {
+      expect(new Int32(17).toDouble(), same(17.0));
+      expect(new Int32(-17).toDouble(), same(-17.0));
+    });
+    test("toInt", () {
+      expect(new Int32(17).toInt(), 17);
+      expect(new Int32(-17).toInt(), -17);
+    });
+    test("toInt32", () {
+      expect(new Int32(17).toInt32(), new Int32(17));
+      expect(new Int32(-17).toInt32(), new Int32(-17));
+    });
+    test("toInt64", () {
+      expect(new Int32(17).toInt64(), new Int64(17));
+      expect(new Int32(-17).toInt64(), new Int64(-17));
+    });
   });
 
   group("string representation", () {
     test("toString", () {
       expect(new Int32(0).toString(), "0");
       expect(new Int32(1).toString(), "1");
       expect(new Int32(-1).toString(), "-1");
       expect(new Int32(1000).toString(), "1000");
       expect(new Int32(-1000).toString(), "-1000");
       expect(new Int32(123456789).toString(), "123456789");
@@ skipping 16 matching lines @@
       expect(new Int32(-1).shiftRightUnsigned(8).toHexString(), "ffffff");
     });
   });
 
   group("toRadixString", () {
     test("returns base n string representation", () {
       expect(new Int32(123456789).toRadixString(5), "223101104124");
     });
   });
 }