Function TestPrefixEncodeCode

writer_test.go:2453–2520

(t *testing.T)

}

func TestPrefixEncodeCode(t *testing.T) {
    tests := []struct {
        n                 int  // input value
        expectedCode      int  // expected prefix code
        expectedRemainder int  // expected remainder value
    }{
        // n <= 5: code should be max(0, n-1) and remainder 0.
        {-1, 0, 0}, // even negative numbers fall in this branch
        {0, 0, 0},
        {1, 0, 0},
        {2, 1, 0},
        {3, 2, 0},
        {4, 3, 0},
        {5, 4, 0},

        // n > 5: calculations using shifts.
        // For n = 6: n-1 = 5, loop runs once (5 >> 1 = 2) → shift=1, rem=2,
        // so returns (2 + 2*1, 6 - (2<<1) - 1) = (4, 1).
        {6, 4, 1},

        // For n = 7: n-1 = 6, loop: 6 >> 1 = 3 → shift=1, rem=3,
        // so returns (3 + 2*1, 7 - (3<<1) - 1) = (5, 0).
        {7, 5, 0},

        // For n = 8: n-1 = 7, loop: 7 >> 1 = 3 → shift=1, rem=3,
        // returns (3 + 2*1, 8 - (3<<1) - 1) = (5, 1).
        {8, 5, 1},

        // For n = 9: n-1 = 8, loop:
        // 8 >> 1 = 4, shift becomes 1; then 4 >> 1 = 2, shift becomes 2;
        // rem == 2 so returns (2 + 2*2, 9 - (2<<2) - 1) = (6, 0).
        {9, 6, 0},

        // For n = 10: returns (6, 1)
        {10, 6, 1},

        // For n = 11: returns (6, 2)
        {11, 6, 2},

        // For n = 12: returns (6, 3)
        {12, 6, 3},

        // For n = 13: n-1 = 12, loop: 12 >> 1 = 6 (shift=1),
        // then 6 >> 1 = 3 (shift=2), rem becomes 3 so returns (3+2*2, 13 - (3<<2) -1) = (7, 0).
        {13, 7, 0},

        // For n = 14: returns (7, 1)
        {14, 7, 1},

        // For n = 15: returns (7, 2)
        {15, 7, 2},

        // For n = 16: returns (7, 3)
        {16, 7, 3},
    }
    for idx, tt := range tests {
        code, remainder := prefixEncodeCode(tt.n)