Dan Buch
f86855d22d
mostly to ease editing, but also for practice with file manipulation, gzipping, base64'ing, etc.
594 lines
10 KiB
Go
594 lines
10 KiB
Go
package conway_test
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/base64"
|
|
"encoding/json"
|
|
"fmt"
|
|
"image/png"
|
|
"math/rand"
|
|
"net/http"
|
|
"regexp"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
import (
|
|
. "github.com/meatballhat/box-o-sand/conway"
|
|
)
|
|
|
|
var TEST_SIMPLE_INITIAL_STATE = NewGameState(16, 16)
|
|
|
|
func init() {
|
|
s := TEST_SIMPLE_INITIAL_STATE
|
|
s.Set(0, 0, 1)
|
|
s.Set(0, 1, 1)
|
|
s.Set(0, 2, 1)
|
|
s.Set(1, 0, 1)
|
|
s.Set(1, 1, 1)
|
|
s.Set(2, 2, 1)
|
|
s.Set(3, 0, 1)
|
|
s.Set(3, 2, 1)
|
|
s.Set(13, 13, 1)
|
|
s.Set(13, 14, 1)
|
|
s.Set(14, 14, 1)
|
|
s.Set(14, 15, 1)
|
|
s.Set(15, 13, 1)
|
|
s.Set(15, 15, 1)
|
|
}
|
|
|
|
func newTestGameState() *GameState {
|
|
state := NewGameState(16, 16)
|
|
state.Import(TEST_SIMPLE_INITIAL_STATE)
|
|
return state
|
|
}
|
|
|
|
func newTestGameOfLife() *GameOfLife {
|
|
game := NewGameOfLife(16, 16)
|
|
game.State.Import(TEST_SIMPLE_INITIAL_STATE)
|
|
return game
|
|
}
|
|
|
|
func TestLiveCellWithFewerThanTwoLiveNeighborsDies(t *testing.T) {
|
|
game := newTestGameOfLife()
|
|
|
|
game.EvaluateGeneration()
|
|
|
|
cell := game.State.Get(3, 2)
|
|
if cell.Value != 0 {
|
|
t.Errorf("%v != 0", cell.Value)
|
|
return
|
|
}
|
|
}
|
|
|
|
func TestLiveCellWithTwoOrThreeLiveNeighborsLivesOn(t *testing.T) {
|
|
game := newTestGameOfLife()
|
|
|
|
game.EvaluateGeneration()
|
|
|
|
cell := game.State.Get(0, 2)
|
|
if cell.Value != 1 {
|
|
t.Errorf("%v != 1", cell.Value)
|
|
return
|
|
}
|
|
}
|
|
|
|
func TestLiveCellWithMoreThanThreeLiveNeighborsDies(t *testing.T) {
|
|
game := newTestGameOfLife()
|
|
|
|
game.EvaluateGeneration()
|
|
|
|
cell := game.State.Get(0, 1)
|
|
if cell.Value != 0 {
|
|
t.Errorf("%v != 0", cell.Value)
|
|
return
|
|
}
|
|
}
|
|
|
|
func TestDeadCellWithExactlyThreeLiveNeighborsBecomesAlive(t *testing.T) {
|
|
game := newTestGameOfLife()
|
|
|
|
game.EvaluateGeneration()
|
|
|
|
cell := game.State.Get(3, 1)
|
|
if cell.Value != 1 {
|
|
t.Errorf("%v != 1", cell.Value)
|
|
return
|
|
}
|
|
}
|
|
|
|
func TestGameOfLifeCanDisplayItselfAsAString(t *testing.T) {
|
|
game := newTestGameOfLife()
|
|
|
|
grid := fmt.Sprintf("%s\n", game)
|
|
|
|
gridLen := len(grid)
|
|
if gridLen < 256 {
|
|
t.Errorf("%v < 256", gridLen)
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestGameOfLifeCanDisplayItselfAsAnImage(t *testing.T) {
|
|
game := newTestGameOfLife()
|
|
|
|
img, err := game.Image(1, 1)
|
|
if err != nil {
|
|
t.Error(err)
|
|
return
|
|
}
|
|
|
|
bounds := img.Bounds()
|
|
if bounds.Max.Y < 16 {
|
|
t.Errorf("image.Max.Y < 16!: %d", bounds.Max.Y)
|
|
return
|
|
}
|
|
|
|
if bounds.Max.X < 16 {
|
|
t.Errorf("image.Max.X < 16!: %d", bounds.Max.X)
|
|
return
|
|
}
|
|
}
|
|
|
|
func TestNewGameOfLifeHasCorrectDimensions(t *testing.T) {
|
|
game := newTestGameOfLife()
|
|
|
|
if game.State.Height() != 16 || game.State.Width() != 16 {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNewGameOfLifeHasGameStateOfSameDimensions(t *testing.T) {
|
|
game := newTestGameOfLife()
|
|
|
|
if len(game.State.Rows) < 16 {
|
|
t.Fail()
|
|
}
|
|
|
|
if len(game.State.Rows[0].Cells) < 16 {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestGameStateCanImportState(t *testing.T) {
|
|
game := newTestGameOfLife()
|
|
|
|
if game.State.Get(0, 0).Value != 1 {
|
|
t.Fail()
|
|
}
|
|
|
|
if game.State.Get(1, 0).Value != 1 {
|
|
t.Fail()
|
|
}
|
|
|
|
if game.State.Get(0, 1).Value != 1 {
|
|
t.Fail()
|
|
}
|
|
|
|
if game.State.Get(1, 1).Value != 1 {
|
|
t.Fail()
|
|
}
|
|
|
|
if game.State.Get(2, 2).Value != 1 {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestGameOfLifeCanImportRandomState(t *testing.T) {
|
|
game := newTestGameOfLife()
|
|
|
|
err := game.ImportRandomState()
|
|
if err != nil {
|
|
t.Error(err)
|
|
return
|
|
}
|
|
|
|
zeroCount := 0
|
|
|
|
for y := 0; y < 16; y++ {
|
|
for x := 0; x < 16; x++ {
|
|
cell := game.State.Get(x, y)
|
|
if cell.Value == 0 {
|
|
zeroCount++
|
|
}
|
|
}
|
|
}
|
|
|
|
if zeroCount == 256 {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestGameStateCanDisplayItselfAsAString(t *testing.T) {
|
|
state := newTestGameState()
|
|
|
|
grid := fmt.Sprintf("%s\n", state)
|
|
lenGrid := len(grid)
|
|
|
|
if lenGrid < 256 {
|
|
t.Errorf("%v < 256", lenGrid)
|
|
return
|
|
}
|
|
|
|
nLines := strings.Count(grid, "\n")
|
|
if nLines < 16 {
|
|
t.Errorf("%v < 16 (lines)", nLines)
|
|
return
|
|
}
|
|
}
|
|
|
|
func TestGameStateCanDisplayItselfAsAnImage(t *testing.T) {
|
|
state := newTestGameState()
|
|
|
|
img, err := state.Image(1, 1)
|
|
if err != nil {
|
|
t.Error(err)
|
|
return
|
|
}
|
|
|
|
bounds := img.Bounds()
|
|
if bounds.Max.Y < 16 {
|
|
t.Errorf("image.Max.Y < 16!: %d", bounds.Max.Y)
|
|
return
|
|
}
|
|
|
|
if bounds.Max.X < 16 {
|
|
t.Errorf("image.Max.X < 16!: %d", bounds.Max.X)
|
|
return
|
|
}
|
|
}
|
|
|
|
func TestNewGameStatesAreAllDead(t *testing.T) {
|
|
state := NewGameState(4, 4)
|
|
for x := 0; x < 3; x++ {
|
|
for y := 0; y < 3; y++ {
|
|
if state.Get(x, y).Value != 0 {
|
|
t.Fail()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestGameStateCanGetCellValueByCoords(t *testing.T) {
|
|
state := NewGameState(8, 8)
|
|
if state.Get(2, 2).Value != 0 {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestGameStateCanSetCellValueByCoords(t *testing.T) {
|
|
state := NewGameState(8, 8)
|
|
state.Set(2, 5, 1)
|
|
|
|
if state.Get(2, 5).Value != 1 {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestGameStateCanEnlivenCellsByCoords(t *testing.T) {
|
|
state := NewGameState(8, 8)
|
|
state.Enliven(0, 1)
|
|
|
|
if state.Get(0, 1).Value != 1 {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestGameStateCanDeadenCellsByCoords(t *testing.T) {
|
|
state := NewGameState(8, 8)
|
|
|
|
state.Enliven(0, 1)
|
|
|
|
if state.Get(0, 1).Value != 1 {
|
|
t.Fail()
|
|
}
|
|
|
|
state.Deaden(0, 1)
|
|
|
|
if state.Get(0, 1).Value != 0 {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNewGenerationScoreCardIsAllZeros(t *testing.T) {
|
|
gen := NewGenerationScoreCard(4, 4)
|
|
|
|
for y := 0; y < gen.Height(); y++ {
|
|
for x := 0; x < gen.Width(); x++ {
|
|
if gen.Get(x, y).Value != 0 {
|
|
t.Fail()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestGenerationScoreCardCalculateResultsInCorrectNeighborCounts(t *testing.T) {
|
|
genScore := NewGenerationScoreCard(16, 16)
|
|
|
|
state := newTestGameState()
|
|
|
|
genScore.Calculate(state)
|
|
|
|
cell := genScore.Get(0, 0)
|
|
if cell.Value != 4 {
|
|
t.Errorf("[0, 0] value %v != 4", cell.Value)
|
|
return
|
|
}
|
|
|
|
cell = genScore.Get(3, 2)
|
|
if cell.Value != 1 {
|
|
t.Errorf("[3, 2] value %d != 1", cell.Value)
|
|
return
|
|
}
|
|
}
|
|
|
|
func TestStateCanMutate(t *testing.T) {
|
|
state := newTestGameState()
|
|
|
|
curCksum, err := state.Checksum()
|
|
if err != nil {
|
|
t.Error(err)
|
|
return
|
|
}
|
|
|
|
state.Mutate()
|
|
|
|
newCksum, err := state.Checksum()
|
|
if err != nil {
|
|
t.Error(err)
|
|
return
|
|
}
|
|
|
|
if curCksum == newCksum {
|
|
t.Errorf("Checksum did not change! %v", newCksum)
|
|
}
|
|
}
|
|
|
|
func TestStateProvidesCellIteratorChannel(t *testing.T) {
|
|
state := newTestGameState()
|
|
|
|
cells, err := state.Cells()
|
|
if err != nil {
|
|
t.Error(err)
|
|
return
|
|
}
|
|
|
|
cellCount := 0
|
|
for _ = range cells {
|
|
cellCount++
|
|
}
|
|
|
|
if cellCount != 256 {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestGameStateCellsCanHaveTheirValueSet(t *testing.T) {
|
|
state := newTestGameState()
|
|
|
|
cells, err := state.Cells()
|
|
if err != nil {
|
|
t.Error(err)
|
|
return
|
|
}
|
|
|
|
for cell := range cells {
|
|
cell.Value = 1
|
|
}
|
|
|
|
cells, err = state.Cells()
|
|
if err != nil {
|
|
t.Error(err)
|
|
return
|
|
}
|
|
|
|
for cell := range cells {
|
|
if cell.Value != 1 {
|
|
t.Fail()
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestGameStateCellsCanBeFetchedByXAndYCoords(t *testing.T) {
|
|
state := newTestGameState()
|
|
|
|
if state.Get(3, 4) == nil {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestGameOfLifeEmitsGenerationTicksUntilStasis(t *testing.T) {
|
|
game := newTestGameOfLife()
|
|
|
|
genTicks, err := game.Generations()
|
|
if err != nil {
|
|
t.Error(err)
|
|
return
|
|
}
|
|
|
|
nGens := 0
|
|
|
|
for gen := range genTicks {
|
|
if gen.N > 3000 {
|
|
t.Errorf("%v is too many generations!", gen.N)
|
|
return
|
|
}
|
|
nGens = gen.N
|
|
}
|
|
|
|
if nGens < 3 {
|
|
t.Errorf("%v is too few generations!", nGens)
|
|
}
|
|
}
|
|
|
|
func TestGameStateCoordsAreNeverOutOfBounds(t *testing.T) {
|
|
state := newTestGameState()
|
|
|
|
oobX, oobY := state.Width()+rand.Intn(99), state.Height()+rand.Intn(99)
|
|
|
|
newVal := rand.Intn(9999)
|
|
|
|
state.Set(oobX, oobY, newVal)
|
|
cell := state.Get(oobX, oobY)
|
|
|
|
if cell == nil {
|
|
t.Fail()
|
|
}
|
|
|
|
if cell.Value != newVal {
|
|
t.Errorf("(%d, %d) != %d: %d", oobX, oobY, newVal, cell.Value)
|
|
}
|
|
}
|
|
|
|
type testResponseWriter struct {
|
|
Status int
|
|
Headers http.Header
|
|
Body []byte
|
|
}
|
|
|
|
func (w *testResponseWriter) WriteHeader(status int) {
|
|
w.Status = status
|
|
}
|
|
|
|
func (w *testResponseWriter) Header() http.Header {
|
|
return w.Headers
|
|
}
|
|
|
|
func (w *testResponseWriter) Write(bytes []byte) (int, error) {
|
|
w.Body = append(w.Body, bytes[:]...)
|
|
return len(bytes), nil
|
|
}
|
|
|
|
func newTestResponseWriter() *testResponseWriter {
|
|
return &testResponseWriter{
|
|
Body: []byte(""),
|
|
Headers: make(map[string][]string),
|
|
}
|
|
}
|
|
|
|
func TestHandleWebGameRootReturnsIndexPageForGET(t *testing.T) {
|
|
req, err := http.NewRequest("GET", "http://localhost:9775/", nil)
|
|
if err != nil {
|
|
t.Error(err)
|
|
return
|
|
}
|
|
|
|
w := newTestResponseWriter()
|
|
HandleWebGameRoot(w, req)
|
|
|
|
if w.Status != http.StatusOK {
|
|
t.Errorf("response status != %d: %d", http.StatusOK, w.Status)
|
|
return
|
|
}
|
|
|
|
matched, err := regexp.MatchString("<h1>Conway's Game of Life</h1>", string(w.Body))
|
|
if err != nil {
|
|
t.Error(err)
|
|
return
|
|
}
|
|
|
|
if !matched {
|
|
t.Errorf("Body did not match expected <h1> element")
|
|
return
|
|
}
|
|
}
|
|
|
|
func TestHandleWebGameRootReturns405ForNonGET(t *testing.T) {
|
|
req, err := http.NewRequest("OPTIONS", "http://localhost:9775/", nil)
|
|
if err != nil {
|
|
t.Error(err)
|
|
return
|
|
}
|
|
|
|
w := newTestResponseWriter()
|
|
HandleWebGameRoot(w, req)
|
|
|
|
if w.Status != http.StatusMethodNotAllowed {
|
|
t.Fail()
|
|
return
|
|
}
|
|
|
|
matched, err := regexp.MatchString("Nope", string(w.Body))
|
|
if err != nil {
|
|
t.Error(err)
|
|
return
|
|
}
|
|
|
|
if !matched {
|
|
t.Fail()
|
|
return
|
|
}
|
|
}
|
|
|
|
func TestHandleWebGameStateGETReturnsRandomImage(t *testing.T) {
|
|
req, err := http.NewRequest("GET", "http://localhost:9775/state", nil)
|
|
if err != nil {
|
|
t.Error(err)
|
|
return
|
|
}
|
|
|
|
w := newTestResponseWriter()
|
|
HandleWebGameState(w, req)
|
|
|
|
if w.Status != http.StatusOK {
|
|
t.Errorf("status != %d: %d", http.StatusOK, w.Status)
|
|
return
|
|
}
|
|
|
|
webState := &WebGameState{}
|
|
err = json.Unmarshal(w.Body, webState)
|
|
if err != nil {
|
|
t.Error(err)
|
|
return
|
|
}
|
|
|
|
imgB64 := []byte(webState.Img)
|
|
imgBytes := make([]byte, len(imgB64))
|
|
|
|
_, err = base64.StdEncoding.Decode(imgBytes, imgB64)
|
|
if err != nil {
|
|
t.Error(err)
|
|
return
|
|
}
|
|
|
|
img, err := png.Decode(bytes.NewBuffer(imgBytes))
|
|
if err != nil {
|
|
t.Error(err)
|
|
return
|
|
}
|
|
|
|
bounds := img.Bounds()
|
|
|
|
if bounds.Max.Y < 80 || bounds.Max.X < 80 {
|
|
t.Errorf("Image has incorrect bounds: %+v", bounds)
|
|
return
|
|
}
|
|
}
|
|
|
|
func TestHandleWebGameStatePOSTWithStateReturnsNextGeneration(t *testing.T) {
|
|
state := newTestGameState()
|
|
webGameState := &WebGameState{State: state, Img: ""}
|
|
|
|
stateJson, err := json.Marshal(webGameState)
|
|
if err != nil {
|
|
t.Error(err)
|
|
return
|
|
}
|
|
|
|
reqBuf := bytes.NewBuffer(stateJson)
|
|
|
|
req, err := http.NewRequest("POST", "http://localhost:9975/state", reqBuf)
|
|
if err != nil {
|
|
t.Errorf("err != nil: %+v", err)
|
|
return
|
|
}
|
|
|
|
w := newTestResponseWriter()
|
|
HandleWebGameState(w, req)
|
|
|
|
if w.Status != http.StatusCreated {
|
|
t.Errorf("response status != %d: %d", http.StatusCreated, w.Status)
|
|
return
|
|
}
|
|
}
|