tabula/board_test.go

258 lines
6.3 KiB
Go

package tabula
import (
"fmt"
"testing"
)
func TestMove(t *testing.T) {
b := NewBoard(false)
b[SpaceRoll1] = 1
b[SpaceRoll2] = 2
got, expected := b[24], int8(2)
if got != expected {
t.Errorf("unexpected space %d value: expected %d: got %d", 24, expected, got)
}
got, expected = b[22], 0
if got != expected {
t.Errorf("unexpected space %d value: expected %d: got %d", 22, expected, got)
}
bc := b.Move(24, 23, 1)
got, expected = b[24], int8(2)
if got != expected {
t.Errorf("unexpected space %d value: expected %d: got %d", 24, expected, got)
}
got, expected = bc[23], int8(1)
if got != expected {
t.Errorf("unexpected space %d value: expected %d: got %d", 23, expected, got)
}
got, expected = bc[24], 1
if got != expected {
t.Errorf("unexpected space %d value: expected %d: got %d", 24, expected, got)
}
got, expected = bc[22], 0
if got != expected {
t.Errorf("unexpected space %d value: expected %d: got %d", 22, expected, got)
}
}
func TestPast(t *testing.T) {
b := NewBoard(false)
got, expected := b.Past(), false
if got != expected {
t.Errorf("unexpected past value: expected %v: got %v", expected, got)
}
b = Board{0, 1, 3, -1, 0, -1, 0, -2, 0, 0, -1, 0, -3, 3, 0, 0, 0, -2, 0, -5, 4, 0, 2, 2, 0, 0, 0, 0, 5, 5, 5, 5}
got, expected = b.Past(), false
if got != expected {
t.Errorf("unexpected past value: expected %v: got %v", expected, got)
}
b = Board{0, -1, 1, -2, -1, 2, 4, 0, 0, 0, 0, 0, -1, 2, -1, 0, 0, -1, 3, -3, 0, 3, -1, -3, -1, 0, 0, 0, 4, 3, 0, 0}
got, expected = b.Past(), false
if got != expected {
t.Errorf("unexpected past value: expected %v: got %v", expected, got)
}
b = Board{7, 2, 2, 4, 0, -2, 0, 0, -1, 0, -1, 0, 0, 0, 0, 0, -1, -1, 0, -4, 0, -2, -1, -1, -1, 0, 0, 0, 6, 2, 0, 0}
got, expected = b.Past(), true
if got != expected {
t.Errorf("unexpected past value: expected %v: got %v", expected, got)
}
}
func TestBlots(t *testing.T) {
b := NewBoard(false)
got, expected := b.Blots(1), 0
if got != expected {
t.Errorf("unexpected blots value: expected %v: got %v", expected, got)
}
got, expected = b.Blots(2), 0
if got != expected {
t.Errorf("unexpected blots value: expected %v: got %v", expected, got)
}
b = b.Move(24, 23, 1)
got, expected = b.Blots(1), 19
if got != expected {
t.Errorf("unexpected blots value: expected %v: got %v", expected, got)
}
got, expected = b.Blots(2), 0
if got != expected {
t.Errorf("unexpected blots value: expected %v: got %v", expected, got)
}
b = b.Move(1, 2, 2)
got, expected = b.Blots(1), 19
if got != expected {
t.Errorf("unexpected blots value: expected %v: got %v", expected, got)
}
got, expected = b.Blots(2), 19
if got != expected {
t.Errorf("unexpected blots value: expected %v: got %v", expected, got)
}
}
func TestHitScore(t *testing.T) {
b := Board{0, 0, -2, -2, -2, 4, 0, -1, 0, 0, -2, 4, 0, -2, -1, 0, -2, 4, 0, 2, 0, 0, 0, 0, -1, 0, 1, 0, 4, 1, 0, 0, 1, 1, 1}
available, _ := b.Available(1)
analysis := make([]*Analysis, 0, AnalysisBufferSize)
b.Analyze(available, &analysis)
expectedHits := []int{296, 341, 0, 296, 0, 296}
if len(analysis) != len(expectedHits) {
t.Errorf("unexpected analysis length: expected %d, got %d", len(expectedHits), len(analysis))
}
for i, a := range analysis {
if a.hitScore != expectedHits[i] {
t.Errorf("unexpected hit score for analysis %d: expected %d, got %d", i, expectedHits[i], a.hitScore)
}
}
}
func TestAnalyze(t *testing.T) {
b := NewBoard(false)
b = b.Move(24, 23, 1)
b = b.Move(1, 2, 2)
b[SpaceRoll1], b[SpaceRoll2] = 1, 2
available, _ := b.Available(1)
analysis := make([]*Analysis, 0, AnalysisBufferSize)
b.Analyze(available, &analysis)
var blots int
for _, r := range analysis {
blots += r.Blots
}
if blots <= 0 {
t.Errorf("expected >0 blots in results, got %d", blots)
}
type testCase struct {
roll1, roll2, roll3, roll4 int8
}
cases := []*testCase{
{1, 1, 1, 1},
{2, 2, 2, 2},
{3, 3, 3, 3},
{4, 4, 4, 4},
{5, 5, 5, 5},
{6, 6, 6, 6},
{1, 2, 0, 0},
{2, 3, 0, 0},
{3, 4, 0, 0},
{4, 5, 0, 0},
{5, 6, 0, 0},
}
for _, c := range cases {
t.Run(fmt.Sprintf("%d-%d", c.roll1, c.roll2), func(t *testing.T) {
board := NewBoard(false)
board[SpaceRoll1] = c.roll1
board[SpaceRoll2] = c.roll2
board[SpaceRoll3] = c.roll3
board[SpaceRoll4] = c.roll4
available, _ := board.Available(1)
board.Analyze(available, &analysis)
})
}
}
func BenchmarkAvailable(b *testing.B) {
type testCase struct {
roll1, roll2, roll3, roll4 int8
}
cases := []*testCase{
{1, 1, 1, 1},
{2, 2, 2, 2},
{3, 3, 3, 3},
{4, 4, 4, 4},
{5, 5, 5, 5},
{6, 6, 6, 6},
{1, 2, 0, 0},
{2, 3, 0, 0},
{3, 4, 0, 0},
{4, 5, 0, 0},
{5, 6, 0, 0},
}
for _, c := range cases {
b.Run(fmt.Sprintf("%d-%d", c.roll1, c.roll2), func(b *testing.B) {
board := NewBoard(false)
board[SpaceRoll1] = c.roll1
board[SpaceRoll2] = c.roll2
board[SpaceRoll3] = c.roll3
board[SpaceRoll4] = c.roll4
var available [][4][2]int
b.ResetTimer()
for i := 0; i < b.N; i++ {
available, _ = board.Available(1)
}
_ = available
})
}
}
func BenchmarkAnalyze(b *testing.B) {
type testCase struct {
roll1, roll2, roll3, roll4 int8
}
cases := []*testCase{
{1, 1, 1, 1},
{2, 2, 2, 2},
{3, 3, 3, 3},
{4, 4, 4, 4},
{5, 5, 5, 5},
{6, 6, 6, 6},
{1, 2, 0, 0},
{2, 3, 0, 0},
{3, 4, 0, 0},
{4, 5, 0, 0},
{5, 6, 0, 0},
}
for _, c := range cases {
b.Run(fmt.Sprintf("%d-%d", c.roll1, c.roll2), func(b *testing.B) {
board := NewBoard(false)
board[SpaceRoll1] = c.roll1
board[SpaceRoll2] = c.roll2
board[SpaceRoll3] = c.roll3
board[SpaceRoll4] = c.roll4
available, _ := board.Available(1)
analysis := make([]*Analysis, 0, AnalysisBufferSize)
b.ResetTimer()
for i := 0; i < b.N; i++ {
board.Analyze(available, &analysis)
}
_ = analysis
})
}
}
func BenchmarkChooseDoubles(b *testing.B) {
board := Board{0, -2, -2, -3, -1, -2, -3, 0, -2, 0, 0, 0, 0, 0, 0, 0, 2, 4, 0, 2, 2, 5, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0, 1, 1, 1}
analysis := make([]*Analysis, 0, AnalysisBufferSize)
var doubles int
b.ResetTimer()
for i := 0; i < b.N; i++ {
doubles = board.ChooseDoubles(&analysis)
}
_ = doubles
}
func BenchmarkMayBearOff(b *testing.B) {
board := NewBoard(false)
var allowed bool
b.ResetTimer()
for i := 0; i < b.N; i++ {
allowed = board.MayBearOff(1)
}
_ = allowed
}