foreign/go/internal/codec/reader_test.go

// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.

package codec

import (
	"bytes"
	"encoding/binary"
	"errors"
	"fmt"
	"math"
	"runtime"
	"strings"
	"testing"
)

// --- byte-construction helpers ---

func u16le(v uint16) []byte {
	b := make([]byte, 2)
	binary.LittleEndian.PutUint16(b, v)
	return b
}

func u32le(v uint32) []byte {
	b := make([]byte, 4)
	binary.LittleEndian.PutUint32(b, v)
	return b
}

func u64le(v uint64) []byte {
	b := make([]byte, 8)
	binary.LittleEndian.PutUint64(b, v)
	return b
}

func cat(slices ...[]byte) []byte {
	var out []byte
	for _, s := range slices {
		out = append(out, s...)
	}
	return out
}

// testPoint is a simple type that implements BinaryMarshaler/BinaryUnmarshaler
// as [x, y] two-byte encoding.
type testPoint struct {
	x, y uint8
}

func (p *testPoint) MarshalBinary() ([]byte, error) {
	return []byte{p.x, p.y}, nil
}

func (p *testPoint) UnmarshalBinary(b []byte) error {
	if len(b) < 2 {
		return fmt.Errorf("testPoint: need 2 bytes, got %d", len(b))
	}
	p.x = b[0]
	p.y = b[1]
	return nil
}

// errMarshaler always returns an error from MarshalBinary.
type errMarshaler struct{}

func (errMarshaler) MarshalBinary() ([]byte, error) {
	return nil, errors.New("marshal error")
}

// errUnmarshaler always returns an error from UnmarshalBinary.
type errUnmarshaler struct{}

func (e *errUnmarshaler) UnmarshalBinary(_ []byte) error {
	return errors.New("unmarshal error")
}

// TestReader_reads exercises every read method in sequence.
func TestReader_reads(t *testing.T) {
	const wantU8 uint8 = math.MaxUint8
	const wantU16 uint16 = math.MaxUint16
	const wantU32 uint32 = math.MaxUint32
	const wantU64 uint64 = math.MaxUint64
	const wantF32 float32 = math.Pi
	const wantRem = 1

	wantStr := "str"
	wantU32LenStr := "uint32"
	wantU8LenStr := "uint8"
	wantRaw := []byte{0xDE, 0xAD}
	wantObj := testPoint{1, 2}

	payload := cat(
		[]byte{wantU8},                                           // U8
		u16le(wantU16),                                           // U16
		u32le(wantU32),                                           // U32
		u64le(wantU64),                                           // U64
		u32le(math.Float32bits(wantF32)),                         // F32
		[]byte(wantStr),                                          // Str(len(wantStr))
		u32le(uint32(len(wantU32LenStr))), []byte(wantU32LenStr), // U32LenStr
		[]byte{uint8(len(wantU8LenStr))}, []byte(wantU8LenStr), // U8LenStr
		wantRaw,      // Raw(len(wantRaw))
		[]byte{1, 2}, // Obj(testPoint{1, 2})
		[]byte{0xFF}, // wantRem trailing bytes for Remaining()
	)

	r := NewReader(payload)
	u8 := r.U8()
	u16 := r.U16()
	u32 := r.U32()
	u64 := r.U64()
	f32 := r.F32()
	str := r.Str(len(wantStr))
	u32LenStr := r.U32LenStr()
	u8LenStr := r.U8LenStr()
	raw := r.Raw(len(wantRaw))
	var obj testPoint
	r.Obj(2, &obj)
	rem := r.Remaining()
	if err := r.Err(); err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	if u8 != wantU8 {
		t.Errorf("U8: got %#x, want %#x", u8, wantU8)
	}
	if u16 != wantU16 {
		t.Errorf("U16: got %#x, want %#x", u16, wantU16)
	}
	if u32 != wantU32 {
		t.Errorf("U32: got %#x, want %#x", u32, wantU32)
	}
	if u64 != wantU64 {
		t.Errorf("U64: got %#x, want %#x", u64, wantU64)
	}
	if f32 != wantF32 {
		t.Errorf("F32: got %v, want %v", f32, wantF32)
	}
	if str != wantStr {
		t.Errorf("Str: got %q, want %q", str, wantStr)
	}
	if u32LenStr != wantU32LenStr {
		t.Errorf("U32LenStr: got %q, want %q", u32LenStr, wantU32LenStr)
	}
	if u8LenStr != wantU8LenStr {
		t.Errorf("U8LenStr: got %q, want %q", u8LenStr, wantU8LenStr)
	}
	if !bytes.Equal(raw, wantRaw) {
		t.Errorf("Raw: got %v, want %v", raw, wantRaw)
	}
	if obj != wantObj {
		t.Errorf("Obj: got %v, want %v", obj, wantObj)
	}
	if rem != wantRem {
		t.Errorf("Remaining: got %d, want %d", rem, wantRem)
	}
}

// TestReader_truncation verifies that every read method returns a descriptive error
// when the buffer is too short, including mid-sequence truncation.
func TestReader_truncation(t *testing.T) {
	cases := []struct {
		name    string
		payload []byte
		read    func(*Reader)
	}{
		{"U8", []byte{}, func(r *Reader) { r.U8() }},
		{"U16", []byte{0x01}, func(r *Reader) { r.U16() }},                   // 1 byte, need 2
		{"U32", []byte{0x01, 0x02, 0x03}, func(r *Reader) { r.U32() }},       // 3 bytes, need 4
		{"U64", []byte{0x01, 0x02, 0x03, 0x04}, func(r *Reader) { r.U64() }}, // 4 bytes, need 8
		{"F32", []byte{0x01, 0x02, 0x03}, func(r *Reader) { r.F32() }},       // 3 bytes, need 4
		{"Str", []byte("hi"), func(r *Reader) { r.Str(5) }},                  // claims 5, has 2
		{"Raw", []byte("hi"), func(r *Reader) { r.Raw(5) }},                  // claims 5, has 2
		{"Obj", []byte{1}, func(r *Reader) {
			var p testPoint
			r.Obj(2, &p)
		}},
		{"U32LenStr/short-len-prefix", []byte{0x05, 0x00}, func(r *Reader) { r.U32LenStr() }},        // len prefix needs 4 bytes, got 2
		{"U32LenStr/short-body", cat(u32le(10), []byte("short")), func(r *Reader) { r.U32LenStr() }}, // claims 10, has 5
		{"U8LenStr/short-len-prefix", []byte{}, func(r *Reader) { r.U8LenStr() }},                    // len prefix needs 1 byte, got 0
		{"U8LenStr/short-body", cat([]byte{10}, []byte("short")), func(r *Reader) { r.U8LenStr() }},  // claims 10, has 5
		{"mid-sequence", cat(u32le(1), []byte{0xFF}), func(r *Reader) { r.U32(); r.U32() }},
	}

	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			r := NewReader(tc.payload)
			tc.read(r)
			err := r.Err()
			if err == nil || !strings.HasPrefix(err.Error(), "reader: need ") {
				t.Fatalf("got %v, want overrun error", err)
			}
		})
	}
}

// TestReader_errSentinel verifies that once an error is set, all subsequent
// read methods are no-ops and return zero values without overwriting the error.
func TestReader_errSentinel(t *testing.T) {
	r := NewReader([]byte{})
	r.U8() // triggers overrun, sets r.err
	if r.Err() == nil {
		t.Fatal("expected error after overrun, got nil")
	}
	err := r.Err()

	if v := r.U8(); v != 0 {
		t.Errorf("U8: got %v, want 0", v)
	}
	if v := r.U16(); v != 0 {
		t.Errorf("U16: got %v, want 0", v)
	}
	if v := r.U32(); v != 0 {
		t.Errorf("U32: got %v, want 0", v)
	}
	if v := r.U64(); v != 0 {
		t.Errorf("U64: got %v, want 0", v)
	}
	if v := r.F32(); v != 0 {
		t.Errorf("F32: got %v, want 0", v)
	}
	if v := r.Str(1); v != "" {
		t.Errorf("Str: got %q, want empty", v)
	}
	if v := r.Raw(1); v != nil {
		t.Errorf("Raw: got %v, want nil", v)
	}
	if v := r.U32LenStr(); v != "" {
		t.Errorf("U32LenStr: got %q, want empty", v)
	}
	if v := r.U8LenStr(); v != "" {
		t.Errorf("U8LenStr: got %q, want empty", v)
	}
	var p testPoint
	r.Obj(2, &p)
	if p != (testPoint{}) {
		t.Errorf("Obj: got %v, want zero value", p)
	}
	if r.Err() != err {
		t.Errorf("error was overwritten: got %v, want %v", r.Err(), err)
	}
}

// TestReader_Obj_unmarshalError verifies that Reader.Obj propagates an error
// returned by UnmarshalBinary.
func TestReader_Obj_unmarshalError(t *testing.T) {
	r := NewReader([]byte{1, 2})
	_, file, line, _ := runtime.Caller(0)
	r.Obj(2, &errUnmarshaler{})
	checkLoc(t, r.Err(), file, line+1)
}

// TestReader_overrun_error_location verifies that the error message contains
// the file and line of the call site that triggered the overrun, for every
// public read method.
func TestReader_overrun_error_location(t *testing.T) {
	cases := []struct {
		name    string
		payload []byte
		fn      func(r *Reader) (wantFile string, wantLine int)
	}{
		{"U8", []byte{}, func(r *Reader) (string, int) {
			_, file, line, _ := runtime.Caller(0)
			r.U8()
			return file, line + 1
		}},
		{"U16", []byte{}, func(r *Reader) (string, int) {
			_, file, line, _ := runtime.Caller(0)
			r.U16()
			return file, line + 1
		}},
		{"U32", []byte{}, func(r *Reader) (string, int) {
			_, file, line, _ := runtime.Caller(0)
			r.U32()
			return file, line + 1
		}},
		{"U64", []byte{}, func(r *Reader) (string, int) {
			_, file, line, _ := runtime.Caller(0)
			r.U64()
			return file, line + 1
		}},
		{"F32", []byte{}, func(r *Reader) (string, int) {
			_, file, line, _ := runtime.Caller(0)
			r.F32()
			return file, line + 1
		}},
		{"Str", []byte{}, func(r *Reader) (string, int) {
			_, file, line, _ := runtime.Caller(0)
			r.Str(1)
			return file, line + 1
		}},
		{"Raw", []byte{}, func(r *Reader) (string, int) {
			_, file, line, _ := runtime.Caller(0)
			r.Raw(1)
			return file, line + 1
		}},
		{"Obj", []byte{1}, func(r *Reader) (string, int) {
			var p testPoint
			_, file, line, _ := runtime.Caller(0)
			r.Obj(2, &p)
			return file, line + 1
		}},
		{"U32LenStr/prefix", []byte{}, func(r *Reader) (string, int) {
			_, file, line, _ := runtime.Caller(0)
			r.U32LenStr()
			return file, line + 1
		}},
		{"U32LenStr/body", cat(u32le(100), []byte("short")), func(r *Reader) (string, int) {
			_, file, line, _ := runtime.Caller(0)
			r.U32LenStr()
			return file, line + 1
		}},
		{"U8LenStr/prefix", []byte{}, func(r *Reader) (string, int) {
			_, file, line, _ := runtime.Caller(0)
			r.U8LenStr()
			return file, line + 1
		}},
		{"U8LenStr/body", cat([]byte{100}, []byte("short")), func(r *Reader) (string, int) {
			_, file, line, _ := runtime.Caller(0)
			r.U8LenStr()
			return file, line + 1
		}},
	}

	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			r := NewReader(tc.payload)
			wantFile, wantLine := tc.fn(r)
			checkLoc(t, r.Err(), wantFile, wantLine)
		})
	}
}

func checkLoc(t *testing.T, err error, wantFile string, wantLine int) {
	t.Helper()
	if err == nil {
		t.Error("expected error, got nil")
		return
	}
	wantLoc := fmt.Sprintf("%s:%d", wantFile, wantLine)
	if !strings.Contains(err.Error(), wantLoc) {
		t.Errorf("error %q does not contain location %q", err.Error(), wantLoc)
	}
}