test: add more unit tests

test/bit/add_test.dart

@@ -8,10 +8,10 @@ void main() {
     test('Default overflow semantics', () {
       const add = Add();
       // overflow
-      expect(add(ones, 1), 0);
+      expect(add.value(ones, 1), 0);
       expect(add(0, -1), ones);
 
-      expect(add(zeroes, zeroes), zeroes);
+      expect(add.value(zeroes, zeroes), zeroes);
       expect(add(zeroes, ones), ones);
       expect(add(ones, zeroes), ones);
       expect(add(0xaaaa, 0x4444), 0xeeee);
@@ -21,10 +21,10 @@ void main() {
       // 8 bits set to '1'
       const ones8 = 0xff;
       // overflow
-      expect(add8(ones8, 1), 0);
+      expect(add8.value(ones8, 1), 0);
       expect(add8(0, -1), ones8);
 
-      expect(add8(zeroes, zeroes), zeroes);
+      expect(add8.value(zeroes, zeroes), zeroes);
       expect(add8(zeroes, ones), 0xff);
       expect(add8(ones, zeroes), 0xff);
       expect(add8(0xaaaa, 0x4444), 0xee);
@@ -35,10 +35,10 @@ void main() {
       const ones16 = 0xffff;
 
       // overflow
-      expect(add16(ones16, 1), 0);
+      expect(add16.value(ones16, 1), 0);
       expect(add16(0, -1), ones16);
 
-      expect(add16(zeroes, zeroes), zeroes);
+      expect(add16.value(zeroes, zeroes), zeroes);
       expect(add16(zeroes, ones), 0xffff);
       expect(add16(ones, zeroes), 0xffff);
       expect(add16(0xaaaaaaaa, 0x44444444), 0xeeee);
@@ -48,21 +48,21 @@ void main() {
       // 32 bits set to 1.
       const ones32 = 0xffffffff;
       // overflow
-      expect(add32(ones32, 1), 0);
+      expect(add32.value(ones32, 1), 0);
       expect(add32(0, -1), ones32);
 
-      expect(add32(zeroes, zeroes), zeroes);
+      expect(add32.value(zeroes, zeroes), zeroes);
       expect(add32(zeroes, ones), 0xffffffff);
       expect(add32(ones, zeroes), 0xffffffff);
       expect(add32(0xaaaaaaaaaaaaaaaa, 0x4444444444444444), 0xeeeeeeee);
     });
     test('64 bits overflow semantics', () {
       const add64 = Add.w64();
       // overflow
-      expect(add64(ones, 1), 0);
+      expect(add64.value(ones, 1), 0);
       expect(add64(0, -1), ones);
 
-      expect(add64(zeroes, zeroes), zeroes);
+      expect(add64.value(zeroes, zeroes), zeroes);
       expect(add64(zeroes, ones), 0xffffffffffffffff);
       expect(add64(ones, zeroes), 0xffffffffffffffff);
       expect(add64(0xaaaaaaaaaaaaaaaa, 0x4444444444444444), 0xeeeeeeeeeeeeeeee);

test/bit/nshl_test.dart

@@ -18,5 +18,8 @@ void main() {
       expect(shift1000(99), 0);
       expect(shift1000(1000), 0);
     });
+    test('negative position', () {
+      expect(() => NShl(-1), throwsA(isA<AssertionError>()));
+    });
   });
 }

test/bit/nshr_test.dart

@@ -10,5 +10,8 @@ void main() {
       expect(shift1(-105), 9223372036854775755);
       expect(shift1(-105), 9223372036854775755);
     });
+    test('negative position', () {
+      expect(() => NShr(-1), throwsA(isA<AssertionError>()));
+    });
   });
 }

test/bit/nshrs_test.dart

@@ -8,5 +8,8 @@ void main() {
       expect(shift1(105), 52);
       expect(shift1(-105), -53);
     });
+    test('negative position', () {
+      expect(() => NShrs(-1), throwsA(isA<AssertionError>()));
+    });
   });
 }

test/bit/sub_test.dart

@@ -2,14 +2,67 @@ import 'package:dartoos/src/bit/sub.dart';
 import 'package:test/test.dart';
 
 void main() {
-  test('Subtraction Operation', () {
+  group('Subtraction Operation', () {
     const ones = 0xFFFFFFFFFFFFFFFF;
     const zeroes = 0x000000000000000;
-    const sub = Sub();
-    expect(sub(zeroes, zeroes), zeroes);
-    expect(sub(ones, zeroes), ones);
-    expect(sub(0, 1), ones); // -1
-    expect(sub(0xaaaa, 0x4444), 0x6666);
-    expect(sub(0, -1), 1);
+    test('Default overflow semantics', () {
+      const sub = Sub();
+      expect(sub.value(zeroes, zeroes), zeroes);
+      expect(sub(ones, zeroes), ones);
+      expect(sub(0, 1), ones); // -1
+      expect(sub(0xaaaa, 0x4444), 0x6666);
+      expect(sub(0, -1), 1);
+    });
+    test('8 bits overflow semantics', () {
+      const sub8 = Sub.w8();
+      // 8 bits set to '1'
+      const ones8 = 0xff;
+      // overflow
+      expect(sub8.value(ones8, 1), 0xfe);
+      expect(sub8(0, -1), 1);
+
+      expect(sub8.value(zeroes, zeroes), zeroes);
+      expect(sub8(zeroes, ones), 1);
+      expect(sub8(ones, zeroes), 0xff);
+      expect(sub8(0xaaaa, 0x4444), 0x66);
+    });
+    test('16 bits overflow semantics', () {
+      const sub16 = Sub.w16();
+      // 16 bits set to 1.
+      const ones16 = 0xffff;
+
+      // overflow
+      expect(sub16.value(ones16, 1), 0xfffe);
+      expect(sub16(0, -1), 1);
+
+      expect(sub16(zeroes, zeroes), zeroes);
+      expect(sub16(zeroes, ones), 1);
+      expect(sub16(ones, zeroes), 0xffff);
+      expect(sub16(0xaaaaaaaa, 0x44444444), 0x6666);
+    });
+    test('32 bits overflow semantics', () {
+      const sub32 = Sub.w32();
+      // 32 bits set to 1.
+      const ones32 = 0xffffffff;
+      // overflow
+      expect(sub32.value(ones32, 1), 0xfffffffe);
+      expect(sub32(0, -1), 1);
+
+      expect(sub32.value(zeroes, zeroes), zeroes);
+      expect(sub32(zeroes, ones), 1);
+      expect(sub32(ones, zeroes), 0xffffffff);
+      expect(sub32(0xaaaaaaaaaaaaaaaa, 0x4444444444444444), 0x66666666);
+    });
+    test('64 bits overflow semantics', () {
+      const sub64 = Sub.w64();
+      // overflow
+      expect(sub64.value(ones, 1), 0xfffffffffffffffe);
+      expect(sub64(0, -1), 1);
+
+      expect(sub64.value(zeroes, zeroes), zeroes);
+      expect(sub64(zeroes, ones), 1);
+      expect(sub64(ones, zeroes), 0xffffffffffffffff);
+      expect(sub64(0xaaaaaaaaaaaaaaaa, 0x4444444444444444), 0x6666666666666666);
+    });
   });
 }

test/byte_test.dart

@@ -10,13 +10,14 @@ void main() {
     const data = [0x30, 0x31, 0x32];
     test('from list', () {
       expect(BytesOf.list(data).value, data);
+      expect(BytesOf.list(data).call(), data);
     });
     test('from filled list', () {
       expect(BytesOf.filled(3, 0x00).value, [0x00, 0x00, 0x00]);
     });
     test('from utf8', () {
       final String str = utf8.decode(data);
-      expect(BytesOf.utf8(str).value, data);
+      expect(BytesOf.utf8(str)(), data);
       expect(BytesOf.utf8('abc').value, utf8.encode('abc'));
     });
     test('from string', () {