86 lines
2.4 KiB
Go
86 lines
2.4 KiB
Go
// Copyright (c) 2026 Petr Balvín <opensource@petrbalvin.org> (https://petrbalvin.org)
|
|
// SPDX-License-Identifier: BSD-3-Clause
|
|
|
|
package verify
|
|
|
|
import (
|
|
"testing"
|
|
"unsafe"
|
|
)
|
|
|
|
func TestBlocks(t *testing.T) {
|
|
k := loadBasic(t)
|
|
|
|
// The "sum" function has labels: sum_done, sum_loop.
|
|
blocks, err := k.Blocks("sum")
|
|
if err != nil {
|
|
t.Fatalf("Blocks(sum): %v", err)
|
|
}
|
|
if len(blocks) < 3 {
|
|
t.Errorf("sum: expected at least 3 blocks (entry + 2 labels), got %d", len(blocks))
|
|
}
|
|
if blocks[0].Offset != 0 {
|
|
t.Errorf("first block offset = %d, want 0", blocks[0].Offset)
|
|
}
|
|
t.Logf("sum blocks: %v", blocks)
|
|
}
|
|
|
|
func TestBlockCount(t *testing.T) {
|
|
k := loadLZ4Kernel(t)
|
|
|
|
n, err := k.BlockCount("decodeBlockAVX2")
|
|
if err != nil {
|
|
t.Fatalf("BlockCount: %v", err)
|
|
}
|
|
// The decoder has many labels (dec_loop, dec_malformed, etc.).
|
|
if n < 10 {
|
|
t.Errorf("decodeBlockAVX2: expected at least 10 blocks, got %d", n)
|
|
}
|
|
t.Logf("decodeBlockAVX2: %d basic blocks", n)
|
|
}
|
|
|
|
func TestProfilePaths(t *testing.T) {
|
|
k := loadLZ4Kernel(t)
|
|
|
|
// Build a corpus of varied LZ4 blocks.
|
|
var argSets [][]byte
|
|
blocks := []struct {
|
|
src []byte
|
|
dstSize int
|
|
}{
|
|
{[]byte{0x00}, 16}, // empty
|
|
{[]byte{0x50, 'H', 'e', 'l', 'l', 'o'}, 16}, // literals only
|
|
{[]byte{0x54, 'A', 'A', 'A', 'A', 'A', 5, 0, 0x30, 'B', 'B', 'B'}, 32}, // match
|
|
{[]byte{0x14, 'X', 1, 0, 0x10, 'Y'}, 16}, // overlapping
|
|
{[]byte{0x50, 'H'}, 16}, // malformed
|
|
{[]byte{0x14, 'X', 0, 0}, 16}, // zero offset
|
|
}
|
|
for _, b := range blocks {
|
|
args := make([]byte, 64)
|
|
if len(b.src) > 0 {
|
|
PutPtr(args, 0, unsafe.Pointer(&b.src[0]))
|
|
}
|
|
PutUint64(args, 8, uint64(len(b.src)))
|
|
PutUint64(args, 16, uint64(cap(b.src)))
|
|
dst := make([]byte, b.dstSize)
|
|
if len(dst) > 0 {
|
|
PutPtr(args, 24, unsafe.Pointer(&dst[0]))
|
|
}
|
|
PutUint64(args, 32, uint64(len(dst)))
|
|
PutUint64(args, 40, uint64(cap(dst)))
|
|
argSets = append(argSets, args)
|
|
}
|
|
|
|
// Result offsets: n+48 and code+56.
|
|
paths, err := k.ProfilePaths("decodeBlockAVX2", argSets, []int{48, 56})
|
|
if err != nil {
|
|
t.Fatalf("ProfilePaths: %v", err)
|
|
}
|
|
|
|
// We expect at least 3 distinct paths: success (various n), malformed, zero offset.
|
|
if len(paths) < 3 {
|
|
t.Errorf("expected at least 3 distinct paths, got %d", len(paths))
|
|
}
|
|
t.Logf("decodeBlockAVX2: %d distinct output paths from %d inputs", len(paths), len(argSets))
|
|
}
|