diff --git a/tape/types_test.go b/tape/types_test.go
index 5cf16b6..39b623d 100644
--- a/tape/types_test.go
+++ b/tape/types_test.go
@@ -21,10 +21,16 @@ func TestI8(test *testing.T) {
 	if err.Error() != "decoding int8: wrong buffer length" { test.Fatal(err) }
 	
 	for number := range uint8(255) {
-		_, err := EncodeI8[uint8](buffer[:1], number)
+		n, err := EncodeI8[uint8](buffer[:1], number)
 		if err != nil { test.Fatal(err) }
-		decoded, _, err := DecodeI8[uint8](buffer[:1])
+		if correct, got := 1, n; correct != got {
+			test.Fatal("not equal:", got)
+		}
+		decoded, n, err := DecodeI8[uint8](buffer[:1])
 		if err != nil { test.Fatal(err) }
+		if correct, got := 1, n; correct != got {
+			test.Fatal("not equal:", got)
+		}
 		if decoded != number {
 			test.Fatalf("%d != %d", decoded, number)
 		}
@@ -44,10 +50,16 @@ func TestI16(test *testing.T) {
 	
 	for _ = range largeNumberNTestRounds {
 		number := uint16(rand.Int())
-		_, err := EncodeI16[uint16](buffer[:2], number)
+		n, err := EncodeI16[uint16](buffer[:2], number)
 		if err != nil { test.Fatal(err) }
-		decoded, _, err := DecodeI16[uint16](buffer[:2])
+		if correct, got := 2, n; correct != got {
+			test.Fatal("not equal:", got)
+		}
+		decoded, n, err := DecodeI16[uint16](buffer[:2])
 		if err != nil { test.Fatal(err) }
+		if correct, got := 2, n; correct != got {
+			test.Fatal("not equal:", got)
+		}
 		if decoded != number {
 			test.Fatalf("%d != %d", decoded, number)
 		}
@@ -67,10 +79,16 @@ func TestI32(test *testing.T) {
 	
 	for _ = range largeNumberNTestRounds {
 		number := uint32(rand.Int())
-		_, err := EncodeI32[uint32](buffer[:4], number)
+		n, err := EncodeI32[uint32](buffer[:4], number)
 		if err != nil { test.Fatal(err) }
-		decoded, _, err := DecodeI32[uint32](buffer[:4])
+		if correct, got := 4, n; correct != got {
+			test.Fatal("not equal:", got)
+		}
+		decoded, n, err := DecodeI32[uint32](buffer[:4])
 		if err != nil { test.Fatal(err) }
+		if correct, got := 4, n; correct != got {
+			test.Fatal("not equal:", got)
+		}
 		if decoded != number {
 			test.Fatalf("%d != %d", decoded, number)
 		}
@@ -90,10 +108,16 @@ func TestI64(test *testing.T) {
 	
 	for _ = range largeNumberNTestRounds {
 		number := uint64(rand.Int())
-		_, err := EncodeI64[uint64](buffer[:8], number)
+		n, err := EncodeI64[uint64](buffer[:8], number)
 		if err != nil { test.Fatal(err) }
-		decoded, _, err := DecodeI64[uint64](buffer[:8])
+		if correct, got := 8, n; correct != got {
+			test.Fatal("not equal:", got)
+		}
+		decoded, n, err := DecodeI64[uint64](buffer[:8])
 		if err != nil { test.Fatal(err) }
+		if correct, got := 8, n; correct != got {
+			test.Fatal("not equal:", got)
+		}
 		if decoded != number {
 			test.Fatalf("%d != %d", decoded, number)
 		}
@@ -117,8 +141,11 @@ func TestGBEU(test *testing.T) {
 	if err == nil { test.Fatal("no error") }
 	if err.Error() != "decoding GBEU: GBEU not terminated" { test.Fatal(err) }
 
-	_, err = EncodeGBEU[uint64](buffer[:], 0x97)
+	n, err := EncodeGBEU[uint64](buffer[:], 0x97)
 	if err != nil { test.Fatal(err) }
+	if correct, got := 2, n; correct != got {
+		test.Fatal("not equal:", got)
+	}
 	if correct, got := []byte { 0x81, 0x17 }, buffer[:2]; !slices.Equal(correct, got) {
 		message := "not equal:"
 		for _, item := range got {
@@ -126,14 +153,20 @@ func TestGBEU(test *testing.T) {
 		}
 		test.Fatal(message)
 	}
-	decoded, _, err := DecodeGBEU[uint64](buffer[:])
+	decoded, n, err := DecodeGBEU[uint64](buffer[:])
 	if err != nil { test.Fatal(err) }
+	if correct, got := 2, n; correct != got {
+		test.Fatal("not equal:", got)
+	}
 	if correct, got := uint64(0x97), decoded; correct != got {
 		test.Fatalf("not equal: %x", got)
 	}
 
-	_, err = EncodeGBEU[uint64](buffer[:], 0x123456)
+	n, err = EncodeGBEU[uint64](buffer[:], 0x123456)
 	if err != nil { test.Fatal(err) }
+	if correct, got := 3, n; correct != got {
+		test.Fatal("not equal:", got)
+	}
 	if correct, got := []byte { 0xc8, 0xe8, 0x56 }, buffer[:3]; !slices.Equal(correct, got) {
 		message := "not equal:"
 		for _, item := range got {
@@ -143,6 +176,9 @@ func TestGBEU(test *testing.T) {
 	}
 	decoded, _, err = DecodeGBEU[uint64](buffer[:])
 	if err != nil { test.Fatal(err) }
+	if correct, got := 3, n; correct != got {
+		test.Fatal("not equal:", got)
+	}
 	if correct, got := uint64(0x123456), decoded; correct != got {
 		test.Fatalf("not equal: %x", got)
 	}
@@ -150,6 +186,9 @@ func TestGBEU(test *testing.T) {
 	maxGBEU64 := []byte { 0x81, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F }
 	_, err = EncodeGBEU[uint64](buffer[:], 0xFFFFFFFFFFFFFFFF)
 	if err != nil { test.Fatal(err) }
+	if correct, got := 10, n; correct != got {
+		test.Fatal("not equal:", got)
+	}
 	if correct, got := maxGBEU64, buffer[:10]; !slices.Equal(correct, got) {
 		message := "not equal:"
 		for _, item := range got {
@@ -159,17 +198,26 @@ func TestGBEU(test *testing.T) {
 	}
 	decoded, _, err = DecodeGBEU[uint64](buffer[:])
 	if err != nil { test.Fatal(err) }
+	if correct, got := 10, n; correct != got {
+		test.Fatal("not equal:", got)
+	}
 	if correct, got := uint64(0xFFFFFFFFFFFFFFFF), decoded; correct != got {
 		test.Fatalf("not equal: %x", got)
 	}
 
 	_, err = EncodeGBEU[uint64](buffer[:], 11)
 	if err != nil { test.Fatal(err) }
+	if correct, got := 1, n; correct != got {
+		test.Fatal("not equal:", got)
+	}
 	if correct, got := byte(0xb), buffer[0]; correct != got {
 		test.Fatal("not equal:", got)
 	}
 	decoded, _, err = DecodeGBEU[uint64](buffer[:])
 	if err != nil { test.Fatal(err) }
+	if correct, got := 1, n; correct != got {
+		test.Fatal("not equal:", got)
+	}
 	if correct, got := uint64(0xb), decoded; correct != got {
 		test.Fatalf("not equal: %x", got)
 	}