Update tests for oriented_cube_t

5 files changed, 75 insertions, 54 deletions

diff --git a/src/core/core.h b/src/core/core.h
index fce1751..c211788 100644
--- a/src/core/core.h
+++ b/src/core/core.h
@@ -1,3 +1,4 @@
+#include "core_types.h"
 #include "constant_cubes.h"
 #include "cube.h"
 #include "moves.h"
diff --git a/src/core/core_types.h b/src/core/core_types.h
new file mode 100644
index 0000000..2ad8938
--- /dev/null
+++ b/src/core/core_types.h
@@ -0,0 +1,4 @@
+typedef struct {
+        cube_t cube;
+        uint8_t orientation;
+} oriented_cube_t;
diff --git a/src/core/cube.h b/src/core/cube.h
index a045e55..76c3ff1 100644
--- a/src/core/cube.h
+++ b/src/core/cube.h
@@ -1,17 +1,33 @@
-STATIC cube_t solvedcube(void);
+#define ZERO_ORIENTED_CUBE ((oriented_cube_t) {0})
+#define SOLVED_ORIENTED_CUBE \
+    ((oriented_cube_t) { .cube = SOLVED_CUBE, .orientation = 0 })
+
+STATIC oriented_cube_t solvedcube(void);
 STATIC cube_t cubefromarray(uint8_t [static 8], uint8_t [static 12]);
-STATIC bool isconsistent(cube_t);
-STATIC bool issolvable(cube_t);
-STATIC bool issolved(cube_t);
-STATIC bool iserror(cube_t);
+STATIC bool isconsistent(oriented_cube_t);
+STATIC bool issolvable(oriented_cube_t);
+STATIC bool issolved(oriented_cube_t);
+STATIC bool iserror(oriented_cube_t);
 STATIC void getcube_fix(long long *, long long *, long long *, long long *);
 STATIC cube_t getcube(int64_t, int64_t, int64_t, int64_t);
 
-/* This is used only in tests, use SOLVED_CUBE directly everywhere else */
-STATIC cube_t
+STATIC oriented_cube_t readcube(const char *);
+STATIC int64_t writecube(oriented_cube_t, size_t n, char [n]);
+STATIC uint8_t readco(const char *);
+STATIC uint8_t readcp(const char *);
+STATIC uint8_t readeo(const char *);
+STATIC uint8_t readep(const char *);
+
+STATIC uint8_t b32toedge(char);
+STATIC uint8_t b32tocorner(char);
+STATIC char edgetob32(uint8_t);
+STATIC char cornertob32(uint8_t);
+
+/* This is used only in tests, use SOLVED_ORIENTED_CUBE everywhere else */
+STATIC oriented_cube_t
 solvedcube(void)
 {
-        return SOLVED_CUBE;
+        return SOLVED_ORIENTED_CUBE;
 }
 
 STATIC cube_t
@@ -24,12 +40,12 @@ cubefromarray(uint8_t c[static 8], uint8_t e[static 12])
 }
 
 STATIC bool
-isconsistent(cube_t cube)
+isconsistent(oriented_cube_t cube)
 {
         uint8_t i, p, e, piece, corner[8], edge[12];
         bool found[12];
 
-        pieces(&cube, corner, edge);
+        pieces(&cube.cube, corner, edge);
 
         for (i = 0; i < 12; i++)
                 found[i] = false;
@@ -63,25 +79,29 @@ isconsistent(cube_t cube)
                 if (!found[i])
                         goto inconsistent_cp;
 
+        if (cube.orientation >= 24)
+                goto inconsistent_orientation;
+
         return true;
 
 inconsistent_ep:
 inconsistent_cp:
 inconsistent_eo:
 inconsistent_co:
-        /* We used to do more logging here, hence the 4 different labels */
+inconsistent_orientation:
+        /* We used to do more logging here, hence the different labels */
         return false;
 }
 
 STATIC bool
-issolvable(cube_t cube)
+issolvable(oriented_cube_t cube)
 {
         uint8_t i, eo, co, piece, edge[12], corner[8], ep[12], cp[8];
 
         DBG_ASSERT(isconsistent(cube), false,
             "issolvable: cube is inconsistent\n");
 
-        pieces(&cube, corner, edge);
+        pieces(&cube.cube, corner, edge);
         for (i = 0; i < 12; i++)
                 ep[i] = edge[i] & PBITS;
         for (i = 0; i < 8; i++)
@@ -120,15 +140,15 @@ issolvable_co:
 }
 
 bool
-issolved(cube_t cube)
+issolved(oriented_cube_t cube)
 {
-        return equal(cube, SOLVED_CUBE);
+        return equal(cube.cube, SOLVED_CUBE);
 }
 
 bool
-iserror(cube_t cube)
+iserror(oriented_cube_t cube)
 {
-        return equal(cube, ZERO_CUBE);
+        return equal(cube.cube, ZERO_CUBE);
 }
 
 STATIC void
@@ -175,21 +195,6 @@ getcube(int64_t ep, int64_t eo, int64_t cp, int64_t co)
         return cubefromarray(carr, earr);
 }
 
-
-/******************************************************************************/
-
-STATIC cube_t readcube(const char *);
-STATIC int64_t writecube(cube_t, size_t n, char [n]);
-STATIC uint8_t readco(const char *);
-STATIC uint8_t readcp(const char *);
-STATIC uint8_t readeo(const char *);
-STATIC uint8_t readep(const char *);
-
-STATIC uint8_t b32toedge(char);
-STATIC uint8_t b32tocorner(char);
-STATIC char edgetob32(uint8_t);
-STATIC char cornertob32(uint8_t);
-
 STATIC uint8_t
 readco(const char *str)
 {
@@ -243,11 +248,11 @@ readep(const char *str)
         return UINT8_ERROR;
 }
 
-STATIC cube_t
+STATIC oriented_cube_t
 readcube(const char *buf)
 {
         int i;
-        uint8_t c[8], e[12];
+        uint8_t c[8], e[12], orientation;
 
         for (i = 0; i < 8; i++) {
                 c[i] = b32tocorner(buf[i]);
@@ -258,14 +263,14 @@ readcube(const char *buf)
                         } else {
                                 LOG("(char '%c')\n", buf[i]);
                         }
-                        return ZERO_CUBE;
+                        return ZERO_ORIENTED_CUBE;
                 }
         }
 
         if (buf[8] != '=') {
                 LOG("Error reading separator: a single '=' "
                     "must be used to separate edges and corners\n");
-                return ZERO_CUBE;
+                return ZERO_ORIENTED_CUBE;
         }
 
         for (i = 0; i < 12; i++) {
@@ -277,15 +282,25 @@ readcube(const char *buf)
                         } else {
                                 LOG("(char '%c')\n", buf[i+9]);
                         }
-                        return ZERO_CUBE;
+                        return ZERO_ORIENTED_CUBE;
                 }
         }
 
-        return cubefromarray(c, e);
+        orientation = (uint8_t)(buf[22] - 'A');
+        if (orientation >= 24) {
+                LOG("Error reading orientation: impossible value %" PRIu8
+                    " (%c)\n", orientation, buf[22]);
+                return ZERO_ORIENTED_CUBE;
+        }
+
+        return (oriented_cube_t) {
+                .cube = cubefromarray(c, e),
+                .orientation = orientation
+        };
 }
 
 STATIC int64_t
-writecube(cube_t cube, size_t buf_size, char buf[buf_size])
+writecube(oriented_cube_t cube, size_t buf_size, char buf[buf_size])
 {
         int i;
         uint8_t corner[8], edge[12];
@@ -297,7 +312,7 @@ writecube(cube_t cube, size_t buf_size, char buf[buf_size])
                 return NISSY_ERROR_BUFFER_SIZE;
         }
 
-        pieces(&cube, corner, edge);
+        pieces(&cube.cube, corner, edge);
 
         for (i = 0; i < 8; i++)
                 buf[i] = cornertob32(corner[i]);
@@ -307,9 +322,8 @@ writecube(cube_t cube, size_t buf_size, char buf[buf_size])
         for (i = 0; i < 12; i++)
                 buf[i+9] = edgetob32(edge[i]);
 
-/* TODO */
         buf[21] = '=';
-        buf[22] = 'A';
+        buf[22] = (char)cube.orientation + 'A';
         buf[23] = '\0';
 
         return NISSY_OK;
@@ -351,4 +365,3 @@ cornertob32(uint8_t corner)
 
         return val < 26 ? 'A' + (char)val : 'a' + (char)(val - 26);
 }
-/******************************************************************************/
diff --git a/src/core/moves.h b/src/core/moves.h
index 8f91167..7e80946 100644
--- a/src/core/moves.h
+++ b/src/core/moves.h
@@ -21,7 +21,7 @@ STATIC uint8_t inverse_move(uint8_t);
 STATIC void sortparallel_moves(size_t n, uint8_t [n]);
 STATIC bool are_lastmoves_singlecw(size_t n, const uint8_t [n]);
 
-STATIC cube_t applymoves(cube_t, const char *);
+STATIC oriented_cube_t applymoves(oriented_cube_t, const char *);
 
 #define FOREACH_READMOVE(ARG_BUF, ARG_MOVE, ARG_C, ARG_MAX, \
         RET_ERROR, ARG_ACTION) \
@@ -319,17 +319,17 @@ are_lastmoves_singlecw(size_t n, const uint8_t moves[n])
         return isbase(moves[n-1]) && (!two || isbase(moves[n-2]));
 }
 
-STATIC cube_t
-applymoves(cube_t cube, const char *buf)
+STATIC oriented_cube_t
+applymoves(oriented_cube_t cube, const char *buf)
 {
         int c;
         uint8_t m;
 
-        DBG_ASSERT(isconsistent(cube), ZERO_CUBE,
+        DBG_ASSERT(isconsistent(cube), ZERO_ORIENTED_CUBE,
             "move error: inconsistent cube\n");
 
-        FOREACH_READMOVE(buf, m, c, -1, ZERO_CUBE,
-                cube = move(cube, m);
+        FOREACH_READMOVE(buf, m, c, -1, ZERO_ORIENTED_CUBE,
+                cube.cube = move(cube.cube, m);
         )
 
         return cube;
diff --git a/src/core/transform.h b/src/core/transform.h
index 28b8d93..763a4ae 100644
--- a/src/core/transform.h
+++ b/src/core/transform.h
@@ -23,7 +23,7 @@ STATIC void writetrans(uint8_t, char [static NISSY_SIZE_TRANSFORMATION]);
 STATIC cube_t transform_edges(cube_t, uint8_t);
 STATIC cube_t transform_corners(cube_t, uint8_t);
 STATIC cube_t transform(cube_t, uint8_t);
-STATIC cube_t applytrans(cube_t, const char *);
+STATIC oriented_cube_t applytrans(oriented_cube_t, const char *);
 STATIC_INLINE uint8_t inverse_trans(uint8_t);
 STATIC uint8_t transform_move(uint8_t, uint8_t);
 STATIC uint64_t symmetry_mask(cube_t);
@@ -367,12 +367,12 @@ transform(cube_t c, uint8_t t)
         }
 }
 
-STATIC cube_t
-applytrans(cube_t cube, const char *buf)
+STATIC oriented_cube_t
+applytrans(oriented_cube_t cube, const char *buf)
 {
         uint8_t t;
 
-        DBG_ASSERT(isconsistent(cube), ZERO_CUBE,
+        DBG_ASSERT(isconsistent(cube), ZERO_ORIENTED_CUBE,
             "transformation error: inconsistent cube\n");
 
         t = readtrans(buf);
@@ -380,7 +380,10 @@ applytrans(cube_t cube, const char *buf)
         if (t == UINT8_ERROR)
                 LOG("Unknown transformation: %s\n", buf);
 
-        return transform(cube, t);
+        return (oriented_cube_t){
+                .cube = transform(cube.cube, t),
+                .orientation = cube.orientation
+        };
 }
 
 STATIC_INLINE uint8_t