package level_test import ( "fmt" "testing" "git.kirsle.net/apps/doodle/lib/render" "git.kirsle.net/apps/doodle/pkg/level" ) // Test the high level Chunker. func TestChunker(t *testing.T) { c := level.NewChunker(1000) // Test swatches. var ( grey = &level.Swatch{ Name: "solid", Color: render.Grey, } ) type testCase struct { name string run func() error } tests := []testCase{ testCase{ name: "Access a pixel on the blank map and expect an error", run: func() error { p := render.NewPoint(65535, -214564545) _, err := c.Get(p) if err == nil { return fmt.Errorf("unexpected success getting point %s", p) } return nil }, }, testCase{ name: "Set a pixel", run: func() error { // Set a point. p := render.NewPoint(100, 200) err := c.Set(p, grey) if err != nil { return fmt.Errorf("unexpected error getting point %s: %s", p, err) } return nil }, }, testCase{ name: "Verify the set pixel", run: func() error { p := render.NewPoint(100, 200) px, err := c.Get(p) if err != nil { return err } if px != grey { return fmt.Errorf("pixel at %s not the expected color:\n"+ "Expected: %s\n"+ " Got: %s", p, grey, px, ) } return nil }, }, testCase{ name: "Verify the neighboring pixel is unset", run: func() error { p := render.NewPoint(101, 200) _, err := c.Get(p) if err == nil { return fmt.Errorf("unexpected success getting point %s", p) } return nil }, }, testCase{ name: "Delete the set pixel", run: func() error { p := render.NewPoint(100, 200) err := c.Delete(p) if err != nil { return err } return nil }, }, testCase{ name: "Verify the deleted pixel is unset", run: func() error { p := render.NewPoint(100, 200) _, err := c.Get(p) if err == nil { return fmt.Errorf("unexpected success getting point %s", p) } return nil }, }, testCase{ name: "Delete a pixel that didn't exist", run: func() error { p := render.NewPoint(-100, -100) err := c.Delete(p) if err == nil { return fmt.Errorf("unexpected success deleting point %s", p) } return nil }, }, } for _, test := range tests { if err := test.run(); err != nil { t.Errorf("Failed: %s\n%s", test.name, err) } } } // Test the map chunk accessor. func TestMapAccessor(t *testing.T) { a := level.NewMapAccessor() _ = a // Test action types var ( Get = "Get" Set = "Set" Delete = "Delete" ) // Test swatches. var ( red = &level.Swatch{ Name: "fire", Color: render.Red, } ) type testCase struct { Action string P render.Point S *level.Swatch Expect *level.Swatch Err bool // expect error } tests := []testCase{ // Get a random point and expect to fail. testCase{ Action: Get, P: render.NewPoint(128, 128), Err: true, }, // Set a point. testCase{ Action: Set, S: red, P: render.NewPoint(1024, 2048), }, // Verify it exists. testCase{ Action: Get, P: render.NewPoint(1024, 2048), Expect: red, }, // A neighboring point does not exist. testCase{ Action: Get, P: render.NewPoint(1025, 2050), Err: true, }, // Delete a pixel that doesn't exist. testCase{ Action: Delete, P: render.NewPoint(1987, 2006), Err: true, }, // Delete one that does. testCase{ Action: Delete, P: render.NewPoint(1024, 2048), }, // Verify gone testCase{ Action: Get, P: render.NewPoint(1024, 2048), Err: true, }, } for _, test := range tests { var px *level.Swatch var err error switch test.Action { case Get: px, err = a.Get(test.P) case Set: err = a.Set(test.P, test.S) case Delete: err = a.Delete(test.P) } if err != nil && !test.Err { t.Errorf("unexpected error from %s %s: %s", test.Action, test.P, err) continue } else if err == nil && test.Err { t.Errorf("didn't get error when we expected from %s %s", test.Action, test.P) continue } if test.Action == Get { if px != test.Expect { t.Errorf("didn't get expected result\n"+ "Expected: %s\n"+ " Got: %s\n", test.Expect, px, ) } } } } // Test the ChunkCoordinate function. func TestChunkCoordinates(t *testing.T) { c := level.NewChunker(1000) type testCase struct { In render.Point Expect render.Point } tests := []testCase{ testCase{ In: render.NewPoint(0, 0), Expect: render.NewPoint(0, 0), }, testCase{ In: render.NewPoint(128, 128), Expect: render.NewPoint(0, 0), }, testCase{ In: render.NewPoint(1024, 128), Expect: render.NewPoint(1, 0), }, testCase{ In: render.NewPoint(3600, 1228), Expect: render.NewPoint(3, 1), }, testCase{ In: render.NewPoint(-100, -1), Expect: render.NewPoint(-1, -1), }, testCase{ In: render.NewPoint(-950, 100), Expect: render.NewPoint(-1, 0), }, testCase{ In: render.NewPoint(-1001, -856), Expect: render.NewPoint(-2, -1), }, testCase{ In: render.NewPoint(-3600, -4800), Expect: render.NewPoint(-4, -5), }, } for _, test := range tests { actual := c.ChunkCoordinate(test.In) if actual != test.Expect { t.Errorf( "Failed ChunkCoordinate conversion:\n"+ " Input: %s\n"+ "Expected: %s\n"+ " Got: %s", test.In, test.Expect, actual, ) } } } func TestZeroChunkSize(t *testing.T) { c := &level.Chunker{} coord := c.ChunkCoordinate(render.NewPoint(1200, 3600)) if !coord.IsZero() { t.Errorf("ChunkCoordinate didn't fail with a zero chunk size!") } }