+++ /dev/null
-package main
-
-import "flag"
-import "fmt"
-import "os"
-import "reflect"
-import "strconv"
-
-import "github.com/petar/GoLLRB/llrb"
-import "github.com/willf/bloom"
-
-var bloomsize = flag.Int("bloomsize", 2000000, "Size bloomfilter for this many states.")
-
-const HOLE = 0
-const BOARD_DIM = 4
-const BOARD_SIZE = BOARD_DIM * BOARD_DIM
-
-type Space int8
-type Board [BOARD_SIZE]Space
-type Step struct {
- board Board
- prev *Step
- length int
-}
-
-const (
- LEFT = -1
- RIGHT = +1
- UP = -BOARD_DIM
- DOWN = +BOARD_DIM
-)
-
-func read_board_from_strings(in []string) (*Board, error) {
- if len(in) != BOARD_SIZE {
- return nil, fmt.Errorf("Please provide %d values", BOARD_SIZE)
- }
- var b Board
- for i, s := range in {
- num, err := strconv.Atoi(s)
- b[i] = Space(num)
- if err != nil {
- return nil, err
- }
- }
- return &b, nil
-}
-
-func adjacent_spaces(s Space) []Space {
- if s < 0 || s >= BOARD_SIZE {
- panic("Invalid space")
- }
- var adjacent []Space
- if s >= BOARD_DIM {
- adjacent = append(adjacent, s+UP)
- }
- if s < BOARD_SIZE-BOARD_DIM {
- adjacent = append(adjacent, s+DOWN)
- }
- if s%BOARD_DIM != 0 {
- adjacent = append(adjacent, s+LEFT)
- }
- if s%BOARD_DIM != BOARD_DIM-1 {
- adjacent = append(adjacent, s+RIGHT)
- }
- return adjacent
-}
-
-func create_successors(start *Step) {
- for _, adj := adjacent_spaces(start.
-}
-
-func sliding_tile(start *Board) error {
- seen := bloom.NewWithEstimates(uint(*bloomsize), 0.0001)
- seen.Add(reflect.ValueOf(*start).Bytes())
- return nil
-}
-
-func main() {
- flag.Parse()
- start, err := read_board_from_strings(flag.Args())
- if err != nil {
- fmt.Println(err)
- os.Exit(1)
- }
- err = sliding_tile(start)
- if err != nil {
- fmt.Println(err)
- os.Exit(1)
- }
-}
--- /dev/null
+#include "sliding_tile_lib.h"
+
+#include "gtest/gtest.h"
+#include "gmock/gmock.h"
+#include <vector>
+
+TEST(Adjacency, Adjacency) {
+ const signed char LEFT = -1;
+ const signed char RIGHT = +1;
+ const signed char UP = -BOARD_DIM;
+ const signed char DOWN = +BOARD_DIM;
+ for (int i = 0; i < BOARD_SIZE; i++) {
+ SCOPED_TRACE(i);
+ std::vector<signed char> expected;
+ if (i >= BOARD_DIM) {
+ expected.push_back(i + UP);
+ }
+ if (i < BOARD_SIZE - BOARD_DIM) {
+ expected.push_back(i + DOWN);
+ }
+ if (i % BOARD_DIM != 0) {
+ expected.push_back(i + LEFT);
+ }
+ if (i % BOARD_DIM != BOARD_DIM - 1) {
+ expected.push_back(i + RIGHT);
+ }
+
+ std::vector<signed char> actual;
+ for (int j = 0; adjacent[i][j] >= 0; j++) {
+ actual.push_back(adjacent[i][j]);
+ }
+ EXPECT_THAT(actual, testing::UnorderedElementsAreArray(expected));
+ }
+}
+++ /dev/null
-package main
-
-import "reflect"
-import "sort"
-import "testing"
-
-func Test_read_board_from_strings(t *testing.T) {
- b, err := read_board_from_strings([]string{"1", "2", "9", "12", "6", "8", "13", "14", "0", "11", "15", "3", "7", "4", "10", "5"})
- if err != nil || *b != Board([BOARD_SIZE]Space{1, 2, 9, 12, 6, 8, 13, 14, 0, 11, 15, 3, 7, 4, 10, 5}) {
- t.Fail()
- }
-
- // Not enough
- b, err = read_board_from_strings([]string{"1", "2", "9", "12", "6", "8", "13", "14", "0", "11", "15", "3", "7", "4", "10"})
- if err == nil {
- t.Fail()
- }
-
- // Not an integer
- b, err = read_board_from_strings([]string{"1", "foo", "9", "12", "6", "8", "13", "14", "0", "11", "15", "3", "7", "4", "10", "5"})
- if err == nil {
- t.Fail()
- }
-
- // Empty string
- b, err = read_board_from_strings([]string{"1", "", "9", "12", "6", "8", "13", "14", "0", "11", "15", "3", "7", "4", "10", "5"})
- if err == nil {
- t.Fail()
- }
-}
-
-// For sorting, for unordered equality testing
-type Spaces []Space
-
-func (s Spaces) Len() int { return len(s) }
-func (s Spaces) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
-func (s Spaces) Less(i, j int) bool { return s[i] < s[j] }
-
-func Test_adjacent_spaces(t *testing.T) {
- type TestCase struct {
- s Space
- expected Spaces
- }
- cases := []TestCase{
- {0, []Space{1, 4}},
- {1, []Space{0, 2, 5}},
- {2, []Space{1, 3, 6}},
- {3, []Space{2, 7}},
- {4, []Space{0, 5, 8}},
- {5, []Space{1, 4, 6, 9}},
- {6, []Space{2, 5, 7, 10}},
- {7, []Space{3, 6, 11}},
- {8, []Space{4, 9, 12}},
- {9, []Space{5, 8, 10, 13}},
- {10, []Space{6, 9, 11, 14}},
- {11, []Space{7, 10, 15}},
- {12, []Space{8, 13}},
- {13, []Space{9, 12, 14}},
- {14, []Space{10, 13, 15}},
- {15, []Space{11, 14}},
- }
- for i, c := range cases {
- var actual Spaces = adjacent_spaces(c.s)
- sort.Sort(c.expected)
- sort.Sort(actual)
- if !reflect.DeepEqual(c.expected, actual) {
- t.Error(i, c.expected, actual)
- }
- }
-}