Update tests for oriented_cube_t

38 files changed, 196 insertions, 142 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
diff --git a/src/nissy.c b/src/nissy.c
index bf56f40..27f2b35 100644
--- a/src/nissy.c
+++ b/src/nissy.c
@@ -17,7 +17,7 @@ long long parse_h48_solver(
 STATIC bool checkdata(const unsigned char *, const tableinfo_t [static 1]);
 STATIC bool distribution_equal(const uint64_t [static INFO_DISTRIBUTION_LEN],
     const uint64_t [static INFO_DISTRIBUTION_LEN], uint8_t);
-STATIC long long write_result(cube_t, char [static NISSY_SIZE_CUBE]);
+STATIC long long write_result(oriented_cube_t, char [static NISSY_SIZE_CUBE]);
 STATIC size_t my_strnlen(const char *, size_t); 
 STATIC long long nissy_dataid(const char *, char [static NISSY_SIZE_DATAID]);
 STATIC long long nissy_gendata_unsafe(
@@ -117,7 +117,7 @@ distribution_equal(
 }
 
 STATIC long long
-write_result(cube_t cube, char result[static NISSY_SIZE_CUBE])
+write_result(oriented_cube_t cube, char result[static NISSY_SIZE_CUBE])
 {
         writecube(cube, NISSY_SIZE_CUBE, result);
 
@@ -147,7 +147,7 @@ nissy_inverse(
         char result[static NISSY_SIZE_CUBE]
 )
 {
-        cube_t c, res;
+        oriented_cube_t c, res;
         long long err;
 
         c = readcube(cube);
@@ -158,7 +158,10 @@ nissy_inverse(
                 goto nissy_inverse_error;
         }
 
-        res = inverse(c);
+        res = (oriented_cube_t) {
+                .cube = inverse(c.cube),
+                .orientation = c.orientation
+        };
 
         if (!isconsistent(res)) {
                 LOG("[inverse] Unknown error: inverted cube is invalid\n");
@@ -169,7 +172,7 @@ nissy_inverse(
         return write_result(res, result);
 
 nissy_inverse_error:
-        writecube(ZERO_CUBE, NISSY_SIZE_CUBE, result);
+        writecube(ZERO_ORIENTED_CUBE, NISSY_SIZE_CUBE, result);
         return err;
 }
 
@@ -180,7 +183,7 @@ nissy_applymoves(
         char result[static NISSY_SIZE_CUBE]
 )
 {
-        cube_t c, res;
+        oriented_cube_t c, res;
         long long err;
 
         if (moves == NULL) {
@@ -208,7 +211,7 @@ nissy_applymoves(
         return write_result(res, result);
 
 nissy_applymoves_error:
-        writecube(ZERO_CUBE, NISSY_SIZE_CUBE, result);
+        writecube(ZERO_ORIENTED_CUBE, NISSY_SIZE_CUBE, result);
         return err;
 }
 
@@ -219,7 +222,7 @@ nissy_applytrans(
         char result[static NISSY_SIZE_CUBE]
 )
 {
-        cube_t c, res;
+        oriented_cube_t c, res;
         long long err;
 
         c = readcube(cube);
@@ -241,7 +244,7 @@ nissy_applytrans(
         return write_result(res, result);
 
 nissy_applytrans_error:
-        writecube(ZERO_CUBE, NISSY_SIZE_CUBE, result);
+        writecube(ZERO_ORIENTED_CUBE, NISSY_SIZE_CUBE, result);
         return err;
 }
 
@@ -269,13 +272,14 @@ nissy_getcube(
 
         c = getcube(ep, eo, cp, co);
 
-        if (!isconsistent(c)) {
+        if (!isconsistent((oriented_cube_t){ .cube = c, .orientation = 0 })) {
                 LOG("[getcube] Error: could not get cube with ep=%lld, "
                     "eo=%lld, cp=%lld, co=%lld.\n", ep, eo, cp, co);
                 return NISSY_ERROR_OPTIONS;
         }
 
-        return write_result(c, result);
+/* TODO: should support orientation */
+        return write_result((oriented_cube_t){.cube = c, .orientation = 0}, result);
 }
 
 long long
@@ -456,6 +460,7 @@ nissy_solve(
         long long stats[static NISSY_SIZE_SOLVE_STATS]
 )
 {
+        oriented_cube_t oc;
         cube_t c;
         long long parse_ret;
         uint8_t h, k;
@@ -466,14 +471,17 @@ nissy_solve(
                 return NISSY_ERROR_NULL_POINTER;
         }
 
-        c = readcube(cube);
+        oc = readcube(cube);
+        c = oc.cube;
 
-        if (!isconsistent(c)) {
+/* TODO: solve should handle oriented cubes */
+
+        if (!isconsistent(oc)) {
                 LOG("[solve] Error: cube is invalid\n");
                 return NISSY_ERROR_INVALID_CUBE;
         }
 
-        if (!issolvable(c)) {
+        if (!issolvable((oriented_cube_t){ .cube = c, .orientation = 0})) {
 /* TODO: this is step-dependent */
                 LOG("[solve] Error: cube is not solvable\n");
                 return NISSY_ERROR_UNSOLVABLE_CUBE;
diff --git a/src/solvers/h48/solve.h b/src/solvers/h48/solve.h
index cf7095c..d19309b 100644
--- a/src/solvers/h48/solve.h
+++ b/src/solvers/h48/solve.h
@@ -155,7 +155,7 @@ solve_h48_dfs(dfsarg_solve_h48_t arg[static 1])
         bool ulbi, ulbn;
         cube_t backup_cube, backup_inverse;
 
-        if (issolved(arg->cube)) {
+        if (equal(arg->cube, SOLVED_CUBE)) {
                 nm = arg->solution_moves->nmoves
                     + arg->solution_moves->npremoves;
                 if (arg->target_depth != nm)
@@ -282,7 +282,7 @@ solve_h48_maketasks(
         cube_t backup_cube;
         solution_moves_t moves;
 
-        if (issolved(maketasks_arg->cube)) {
+        if (equal(maketasks_arg->cube, SOLVED_CUBE)) {
                 if (maketasks_arg->nmoves > maketasks_arg->maxmoves ||
                     maketasks_arg->nmoves < maketasks_arg->minmoves ||
                     solutions_done(solve_arg->solution_list,
diff --git a/test/000_basic/basic_tests.c b/test/000_basic/basic_tests.c
index accde66..df38e88 100644
--- a/test/000_basic/basic_tests.c
+++ b/test/000_basic/basic_tests.c
@@ -1,27 +1,29 @@
 #include "../test.h"
 
-bool issolved(cube_t);
+bool issolved(oriented_cube_t);
 bool equal(cube_t, cube_t);
 
 void
-check(cube_t cube, char *name)
+check(oriented_cube_t cube, char *name)
 {
         printf("%s is%s solvable\n", name, issolvable(cube) ? "" : " NOT");
         printf("%s is%s solved\n", name, issolved(cube) ? "" : " NOT");
 }
 
 void
-check2(cube_t cube1, char *name1, cube_t cube2, char *name2)
+check2(oriented_cube_t cube1, char *name1, oriented_cube_t cube2, char *name2)
 {
-        printf("%s and %s are%s equal\n", name1, name2,
-            equal(cube1, cube2) ? "" : " NOT");
+        bool eq = equal(cube1.cube, cube2.cube) &&
+            cube1.orientation == cube2.orientation;
+        printf("%s and %s are%s equal\n", name1, name2, eq ? "" : " NOT");
 }
 
 void run(void) {
-        cube_t zero, solved;
+        oriented_cube_t zero, solved;
 
-        memset(&zero, 0, sizeof(cube_t));
+        memset(&zero, 0, sizeof(oriented_cube_t));
         solved = solvedcube();
+
         check(solved, "Solved");
         check(zero, "Zero");
 
diff --git a/test/001_pieces/pieces_tests.c b/test/001_pieces/pieces_tests.c
index 452a11b..f46a143 100644
--- a/test/001_pieces/pieces_tests.c
+++ b/test/001_pieces/pieces_tests.c
@@ -6,7 +6,7 @@ void run(void) {
         int i;
         uint8_t corner[8], edge[12];
         char str[STRLENMAX], *aux;
-        cube_t cube;
+        oriented_cube_t cube;
 
         aux = str;
         while (fgets(aux, STRLENMAX, stdin) != NULL)
@@ -14,7 +14,7 @@ void run(void) {
                         aux++;
 
         cube = readcube(str);
-        pieces(&cube, corner, edge);
+        pieces(&cube.cube, corner, edge);
 
         for (i = 0; i < 8; i++)
                 printf("%" PRIu8 " ", corner[i]);
diff --git a/test/020_io_cube_read_write/01_solved_oneline.in b/test/020_io_cube_read_write/01_solved_oriented.in
index 5aa6ba7..5aa6ba7 100644
--- a/test/020_io_cube_read_write/01_solved_oneline.in
+++ b/test/020_io_cube_read_write/01_solved_oriented.in
diff --git a/test/020_io_cube_read_write/01_solved_oneline.out b/test/020_io_cube_read_write/01_solved_oriented.out
index 5aa6ba7..5aa6ba7 100644
--- a/test/020_io_cube_read_write/01_solved_oneline.out
+++ b/test/020_io_cube_read_write/01_solved_oriented.out
diff --git a/test/020_io_cube_read_write/02_solve_misoriented.in b/test/020_io_cube_read_write/02_solve_misoriented.in
new file mode 100644
index 0000000..f3279c5
--- /dev/null
+++ b/test/020_io_cube_read_write/02_solve_misoriented.in
@@ -0,0 +1 @@
+ABCDEFGH=ABCDEFGHIJKL=L
diff --git a/test/020_io_cube_read_write/02_solve_misoriented.out b/test/020_io_cube_read_write/02_solve_misoriented.out
new file mode 100644
index 0000000..f3279c5
--- /dev/null
+++ b/test/020_io_cube_read_write/02_solve_misoriented.out
@@ -0,0 +1 @@
+ABCDEFGH=ABCDEFGHIJKL=L
diff --git a/test/020_io_cube_read_write/io_cube_tests.c b/test/020_io_cube_read_write/io_cube_tests.c
index c9df1a9..3d7601c 100644
--- a/test/020_io_cube_read_write/io_cube_tests.c
+++ b/test/020_io_cube_read_write/io_cube_tests.c
@@ -2,7 +2,7 @@
 
 void run(void) {
         char str[STRLENMAX], *aux;
-        cube_t cube;
+        oriented_cube_t cube;
 
         aux = str;
         while (fgets(aux, STRLENMAX, stdin) != NULL)
diff --git a/test/030_move/move_tests.c b/test/030_move/move_tests.c
index e5aed44..98c9592 100644
--- a/test/030_move/move_tests.c
+++ b/test/030_move/move_tests.c
@@ -1,10 +1,10 @@
 #include "../test.h"
 
-cube_t applymoves(cube_t, char *);
+oriented_cube_t applymoves(oriented_cube_t, char *);
 
 void run(void) {
         char movestr[STRLENMAX], cubestr[STRLENMAX];
-        cube_t cube;
+        oriented_cube_t cube;
 
         fgets(movestr, STRLENMAX, stdin);
         fgets(cubestr, STRLENMAX, stdin);
diff --git a/test/031_premove/premove_tests.c b/test/031_premove/premove_tests.c
index 24773cd..10bed92 100644
--- a/test/031_premove/premove_tests.c
+++ b/test/031_premove/premove_tests.c
@@ -7,14 +7,14 @@ cube_t premove(cube_t, uint8_t);
 void run(void) {
         char movestr[STRLENMAX], cubestr[STRLENMAX];
         uint8_t move;
-        cube_t cube;
+        oriented_cube_t cube;
 
         fgets(movestr, STRLENMAX, stdin);
         move = readmove(movestr[0]) + readmodifier(movestr[1]);
         fgets(cubestr, STRLENMAX, stdin);
         cube = readcube(cubestr);
 
-        cube = premove(cube, move);
+        cube.cube = premove(cube.cube, move);
 
         if (iserror(cube)) {
                 printf("Error moving cube\n");
diff --git a/test/040_inverse_cube/inverse_tests.c b/test/040_inverse_cube/inverse_tests.c
index 9e8925a..f0401ea 100644
--- a/test/040_inverse_cube/inverse_tests.c
+++ b/test/040_inverse_cube/inverse_tests.c
@@ -4,11 +4,14 @@ cube_t inverse(cube_t);
 
 void run(void) {
         char str[STRLENMAX];
-        cube_t cube, inv;
+        oriented_cube_t cube, inv;
 
         fgets(str, STRLENMAX, stdin);
         cube = readcube(str);
-        inv = inverse(cube);
+        inv = (oriented_cube_t) {
+                .cube = inverse(cube.cube),
+                .orientation = cube.orientation
+        };
 
         if (iserror(inv)) {
                 printf("Error inverting cube\n");
diff --git a/test/050_compose/compose_tests.c b/test/050_compose/compose_tests.c
index c61775f..3dea055 100644
--- a/test/050_compose/compose_tests.c
+++ b/test/050_compose/compose_tests.c
@@ -4,14 +4,17 @@ cube_t compose(cube_t, cube_t);
 
 void run(void) {
         char str[STRLENMAX];
-        cube_t c1, c2, c3;
+        oriented_cube_t c1, c2, c3;
 
         fgets(str, STRLENMAX, stdin);
         c1 = readcube(str);
         fgets(str, STRLENMAX, stdin);
         c2 = readcube(str);
 
-        c3 = compose(c1, c2);
+        c3 = (oriented_cube_t) {
+                .cube = compose(c1.cube, c2.cube),
+                .orientation = c1.orientation
+        };
 
         if (iserror(c3)) {
                 printf("Error composing cubes\n");
diff --git a/test/060_transform/transform_tests.c b/test/060_transform/transform_tests.c
index 4ae161c..82694b2 100644
--- a/test/060_transform/transform_tests.c
+++ b/test/060_transform/transform_tests.c
@@ -1,10 +1,10 @@
 #include "../test.h"
 
-cube_t applytrans(cube_t, char *);
+oriented_cube_t applytrans(oriented_cube_t, char *);
 
 void run(void) {
         char cubestr[STRLENMAX], transtr[STRLENMAX];
-        cube_t cube;
+        oriented_cube_t cube;
 
         fgets(transtr, STRLENMAX, stdin);
         fgets(cubestr, STRLENMAX, stdin);
diff --git a/test/061_inverse_trans/inverse_trans_tests.c b/test/061_inverse_trans/inverse_trans_tests.c
index 441fef8..bad39fa 100644
--- a/test/061_inverse_trans/inverse_trans_tests.c
+++ b/test/061_inverse_trans/inverse_trans_tests.c
@@ -2,13 +2,13 @@
 
 uint8_t readtrans(char [static NISSY_SIZE_TRANSFORMATION]);
 uint8_t inverse_trans(uint8_t);
-cube_t applymoves(cube_t, char *);
-cube_t applytrans(cube_t, char *);
+oriented_cube_t applymoves(oriented_cube_t, char *);
+oriented_cube_t applytrans(oriented_cube_t, char *);
 extern char *transstr[];
 
 void run(void) {
         uint8_t t, tinv;
-        cube_t cube;
+        oriented_cube_t cube;
 
         for (t = 0; t < 48; t++) {
                 cube = solvedcube();
diff --git a/test/062_transform_move/transform_move_tests.c b/test/062_transform_move/transform_move_tests.c
index 66889f9..4f554c7 100644
--- a/test/062_transform_move/transform_move_tests.c
+++ b/test/062_transform_move/transform_move_tests.c
@@ -6,14 +6,14 @@ cube_t applytrans(cube_t, const char *);
 uint8_t transform_move(uint8_t, uint8_t);
 int64_t readmoves(const char *, size_t n, uint8_t [n]);
 cube_t move(cube_t, uint8_t);
-cube_t applymoves(cube_t, const char *);
+oriented_cube_t applymoves(oriented_cube_t, const char *);
 uint8_t readtrans(const char[static NISSY_SIZE_TRANSFORMATION]);
 
 void run(void) {
         char movestr[STRLENMAX], transtr[STRLENMAX], cubestr[STRLENMAX];
         uint8_t t, moves[MAXMOVES];
         int i, n;
-        cube_t cube;
+        oriented_cube_t cube;
 
         fgets(transtr, STRLENMAX, stdin);
         fgets(movestr, STRLENMAX, stdin);
@@ -22,7 +22,7 @@ void run(void) {
         n = readmoves(movestr, MAXMOVES, moves);
         t = readtrans(transtr);
         for (i = 0; i < n; i++)
-                cube = move(cube, transform_move(moves[i], t));
+                cube.cube = move(cube.cube, transform_move(moves[i], t));
 
         writecube(cube, STRLENMAX, cubestr);
         printf("%s\n", cubestr);
diff --git a/test/063_symmetry_mask/symmetry_mask_tests.c b/test/063_symmetry_mask/symmetry_mask_tests.c
index c14fd14..e717b12 100644
--- a/test/063_symmetry_mask/symmetry_mask_tests.c
+++ b/test/063_symmetry_mask/symmetry_mask_tests.c
@@ -5,11 +5,11 @@ uint64_t symmetry_mask(cube_t);
 void run(void) {
         char str[STRLENMAX];
         uint64_t i, result;
-        cube_t cube;
+        oriented_cube_t cube;
 
         fgets(str, STRLENMAX, stdin);
         cube = readcube(str);
-        result = symmetry_mask(cube); 
+        result = symmetry_mask(cube.cube); 
 
         for (i = 0; i < 48; result >>= 1, i++)
                 printf("%" PRIu64, result % UINT64_C(2));
diff --git a/test/071_coord_eo/coord_eo_tests.c b/test/071_coord_eo/coord_eo_tests.c
index 11a8ac3..360720e 100644
--- a/test/071_coord_eo/coord_eo_tests.c
+++ b/test/071_coord_eo/coord_eo_tests.c
@@ -4,13 +4,13 @@ int64_t coord_eo(cube_t);
 
 void run(void) {
         char str[STRLENMAX];
-        cube_t cube;
+        oriented_cube_t cube;
         int64_t result;
 
         fgets(str, STRLENMAX, stdin);
         cube = readcube(str);
 
-        result = coord_eo(cube);
+        result = coord_eo(cube.cube);
 
         printf("%" PRId64 "\n", result);
 }
diff --git a/test/072_coord_co/coord_co_tests.c b/test/072_coord_co/coord_co_tests.c
index b1de223..440ad2e 100644
--- a/test/072_coord_co/coord_co_tests.c
+++ b/test/072_coord_co/coord_co_tests.c
@@ -4,13 +4,13 @@ int64_t coord_co(cube_t);
 
 void run(void) {
         char str[STRLENMAX];
-        cube_t cube;
+        oriented_cube_t cube;
         int64_t result;
 
         fgets(str, STRLENMAX, stdin);
         cube = readcube(str);
 
-        result = coord_co(cube);
+        result = coord_co(cube.cube);
 
         printf("%" PRId64 "\n", result);
 }
diff --git a/test/073_coord_csep/coord_csep_tests.c b/test/073_coord_csep/coord_csep_tests.c
index 6fe16b2..21a3b3a 100644
--- a/test/073_coord_csep/coord_csep_tests.c
+++ b/test/073_coord_csep/coord_csep_tests.c
@@ -4,13 +4,13 @@ int64_t coord_csep(cube_t);
 
 void run(void) {
         char str[STRLENMAX];
-        cube_t cube;
+        oriented_cube_t cube;
         int64_t result;
 
         fgets(str, STRLENMAX, stdin);
         cube = readcube(str);
 
-        result = coord_csep(cube);
+        result = coord_csep(cube.cube);
 
         printf("%" PRId64 "\n", result);
 }
diff --git a/test/074_coord_esep/coord_esep_tests.c b/test/074_coord_esep/coord_esep_tests.c
index 7c53c9a..679e1c6 100644
--- a/test/074_coord_esep/coord_esep_tests.c
+++ b/test/074_coord_esep/coord_esep_tests.c
@@ -4,13 +4,13 @@ int64_t coord_esep(cube_t);
 
 void run(void) {
         char str[STRLENMAX];
-        cube_t cube;
+        oriented_cube_t cube;
         int64_t result;
 
         fgets(str, STRLENMAX, stdin);
         cube = readcube(str);
 
-        result = coord_esep(cube);
+        result = coord_esep(cube.cube);
 
         printf("%" PRId64 "\n", result);
 }
diff --git a/test/075_set_eo/set_eo_tests.c b/test/075_set_eo/set_eo_tests.c
index 2e05e9a..ef2156d 100644
--- a/test/075_set_eo/set_eo_tests.c
+++ b/test/075_set_eo/set_eo_tests.c
@@ -6,7 +6,7 @@ void pieces(cube_t *, uint8_t [static 8], uint8_t [static 12]);
 
 void run(void) {
         char str[STRLENMAX];
-        cube_t cube;
+        oriented_cube_t cube;
         uint8_t edge[12], corner[8];
         int64_t eo;
 
@@ -15,12 +15,12 @@ void run(void) {
         fgets(str, STRLENMAX, stdin);
         eo = atoi(str);
 
-        set_eo(&cube, eo);
+        set_eo(&cube.cube, eo);
 
         if (iserror(cube)) {
                 printf("Error setting EO\n");
         } else if (!isconsistent(cube)) {
-                pieces(&cube, corner, edge);
+                pieces(&cube.cube, corner, edge);
                 fprintf(stderr, "edges: ");
                 for (int i = 0; i < 12; i++)
                         fprintf(stderr, "%d ", edge[i]);
diff --git a/test/076_copy_corners/copy_corners_tests.c b/test/076_copy_corners/copy_corners_tests.c
index 94e2a2a..02e949b 100644
--- a/test/076_copy_corners/copy_corners_tests.c
+++ b/test/076_copy_corners/copy_corners_tests.c
@@ -4,7 +4,7 @@ void copy_corners(cube_t *, cube_t);
 
 void run(void) {
         char str[STRLENMAX];
-        cube_t c1, c2;
+        oriented_cube_t c1, c2;
 
         fgets(str, STRLENMAX, stdin);
         c1 = readcube(str);
@@ -12,7 +12,7 @@ void run(void) {
         fgets(str, STRLENMAX, stdin);
         c2 = readcube(str);
 
-        copy_corners(&c1, c2);
+        copy_corners(&c1.cube, c2.cube);
 
         if (iserror(c1)) {
                 printf("Error setting EO\n");
diff --git a/test/077_copy_edges/copy_edges_tests.c b/test/077_copy_edges/copy_edges_tests.c
index 36e32af..f3b0589 100644
--- a/test/077_copy_edges/copy_edges_tests.c
+++ b/test/077_copy_edges/copy_edges_tests.c
@@ -4,7 +4,7 @@ void copy_edges(cube_t *, cube_t);
 
 void run(void) {
         char str[STRLENMAX];
-        cube_t c1, c2;
+        oriented_cube_t c1, c2;
 
         fgets(str, STRLENMAX, stdin);
         c1 = readcube(str);
@@ -12,7 +12,7 @@ void run(void) {
         fgets(str, STRLENMAX, stdin);
         c2 = readcube(str);
 
-        copy_edges(&c1, c2);
+        copy_edges(&c1.cube, c2.cube);
 
         if (iserror(c1)) {
                 printf("Error setting EO\n");
diff --git a/test/078_invcoord_esep/invcoord_esep_tests.c b/test/078_invcoord_esep/invcoord_esep_tests.c
index ebf35b0..9945e77 100644
--- a/test/078_invcoord_esep/invcoord_esep_tests.c
+++ b/test/078_invcoord_esep/invcoord_esep_tests.c
@@ -5,15 +5,15 @@ cube_t invcoord_esep(int64_t);
 
 void run(void) {
         char str[STRLENMAX];
-        cube_t cube;
+        oriented_cube_t cube;
         int64_t i;
 
         fgets(str, STRLENMAX, stdin);
         cube = readcube(str);
 
-        i = coord_esep(cube);
-        cube = invcoord_esep(i);
-        i = coord_esep(cube);
+        i = coord_esep(cube.cube);
+        cube.cube = invcoord_esep(i);
+        i = coord_esep(cube.cube);
 
         printf("%" PRId64 "\n", i);
 }
diff --git a/test/079_invcoord_co/invcoord_co_tests.c b/test/079_invcoord_co/invcoord_co_tests.c
index 9f7c3d5..fcd68d0 100644
--- a/test/079_invcoord_co/invcoord_co_tests.c
+++ b/test/079_invcoord_co/invcoord_co_tests.c
@@ -6,12 +6,14 @@ int64_t coord_co(cube_t);
 cube_t invcoord_co(int64_t);
 
 void run(void) {
-        cube_t cube;
+        oriented_cube_t cube;
         int64_t coord, coord2;
 
+        cube.orientation = 0;
+
         /* Test all possible values for CO coordinate */
         for (coord = 0; coord < POW_3_7; coord++) {
-                cube = invcoord_co(coord);
+                cube.cube = invcoord_co(coord);
 
                 if (!isconsistent(cube)) {
                         printf("Not consistent\n");
@@ -22,7 +24,7 @@ void run(void) {
                         return;
                 }
 
-                coord2 = coord_co(cube);
+                coord2 = coord_co(cube.cube);
                 if (coord != coord2) {
                         printf("Error: invcoord of %" PRId64
                             " returns %" PRId64 "\n", coord, coord2);
diff --git a/test/081_getcube/getcube_tests.c b/test/081_getcube/getcube_tests.c
index 916c42b..07e621e 100644
--- a/test/081_getcube/getcube_tests.c
+++ b/test/081_getcube/getcube_tests.c
@@ -4,7 +4,7 @@ cube_t getcube(int64_t, int64_t, int64_t, int64_t);
 
 void run(void) {
         char str[STRLENMAX];
-        cube_t cube;
+        oriented_cube_t cube;
         int64_t ep, eo, cp, co;
 
         fgets(str, STRLENMAX, stdin);
@@ -16,7 +16,10 @@ void run(void) {
         fgets(str, STRLENMAX, stdin);
         co = atoll(str);
 
-        cube = getcube(ep, eo, cp, co);
+        cube = (oriented_cube_t) {
+                .cube = getcube(ep, eo, cp, co),
+                .orientation = 0
+        };
 
         if (iserror(cube)) {
                 printf("Error cube\n");
diff --git a/test/101_cocsep_transform_invariant/cocsep_transform_invariant.c b/test/101_cocsep_transform_invariant/cocsep_transform_invariant.c
index 7ded2e9..5553fd1 100644
--- a/test/101_cocsep_transform_invariant/cocsep_transform_invariant.c
+++ b/test/101_cocsep_transform_invariant/cocsep_transform_invariant.c
@@ -11,7 +11,8 @@ void run(void) {
         uint64_t selfsim[COCSEP_CLASSES];
         int64_t coord, tcoord;
         char str[STRLENMAX];
-        cube_t cube, transd, rep[COCSEP_CLASSES];
+        oriented_cube_t cube;
+        cube_t rep[COCSEP_CLASSES], transd;
 
         fgets(str, STRLENMAX, stdin);
         cube = readcube(str);
@@ -19,9 +20,9 @@ void run(void) {
         gendata_cocsep(buf, selfsim, rep);
         cocsepdata = (uint32_t *)((char *)buf + INFOSIZE);
 
-        coord = (int64_t)COCLASS(cocsepdata[coord_cocsep(cube)]);
+        coord = (int64_t)COCLASS(cocsepdata[coord_cocsep(cube.cube)]);
         for (t = 0; t < 48; t++) {
-                transd = transform(cube, t);
+                transd = transform(cube.cube, t);
                 tcoord = (int64_t)COCLASS(cocsepdata[coord_cocsep(transd)]);
                 if (coord != tcoord)
                         printf("Error: expected %" PRId64
diff --git a/test/102_cocsep_selfsim/cocsep_selfsim_tests.c b/test/102_cocsep_selfsim/cocsep_selfsim_tests.c
index 9966321..1a1c6f2 100644
--- a/test/102_cocsep_selfsim/cocsep_selfsim_tests.c
+++ b/test/102_cocsep_selfsim/cocsep_selfsim_tests.c
@@ -16,7 +16,8 @@ void run(void) {
         uint32_t *cocsepdata, data;
         int64_t coord, coclass;
         uint64_t selfsim[COCSEP_CLASSES], sim, t;
-        cube_t cube, rep[COCSEP_CLASSES];
+        oriented_cube_t cube;
+        cube_t rep[COCSEP_CLASSES];
 
         gendata_cocsep(buf, selfsim, rep);
         cocsepdata = (uint32_t *)(buf + INFOSIZE);
@@ -25,7 +26,7 @@ void run(void) {
 
         while (fgets(str, STRLENMAX, stdin) != NULL) {
                 cube = readcube(str);
-                coord = coord_cocsep(cube);
+                coord = coord_cocsep(cube.cube);
                 data = cocsepdata[coord];
                 coclass = (data & (0xFFFU << 16)) >> 16;
                 sim = selfsim[coclass];
diff --git a/test/110_coord_invcoord_h48/coord_invcoord_h48_tests.c b/test/110_coord_invcoord_h48/coord_invcoord_h48_tests.c
index 458ad31..0333f27 100644
--- a/test/110_coord_invcoord_h48/coord_invcoord_h48_tests.c
+++ b/test/110_coord_invcoord_h48/coord_invcoord_h48_tests.c
@@ -14,7 +14,8 @@ void run(void) {
         uint32_t *cocsepdata;
         uint64_t selfsim[COCSEP_CLASSES];
         int64_t c, cc;
-        cube_t cube, invc, rep[COCSEP_CLASSES];
+        oriented_cube_t cube;
+        cube_t invc, rep[COCSEP_CLASSES];
 
         gendata_cocsep(buf, selfsim, rep);
         cocsepdata = (uint32_t *)(buf + INFOSIZE);
@@ -23,11 +24,11 @@ void run(void) {
         h = 11;
         while (fgets(str, STRLENMAX, stdin) != NULL) {
                 cube = readcube(str);
-                c = coord_h48(cube, cocsepdata, h);
+                c = coord_h48(cube.cube, cocsepdata, h);
                 invc = invcoord_h48(c, rep, h);
                 for (t = 0, found = false; t < 48; t++) {
-                        cube = transform(invc, t);
-                        cc = coord_h48(cube, cocsepdata, h);
+                        cube.cube = transform(invc, t);
+                        cc = coord_h48(cube.cube, cocsepdata, h);
                         found = found || cc == c;
                 }
                 printf("%d %s\n", i, found ? "ok" : "ERROR");
diff --git a/test/121_coorddata_dr/coorddata_dr.c b/test/121_coorddata_dr/coorddata_dr.c
index d7efcfb..e8407c8 100644
--- a/test/121_coorddata_dr/coorddata_dr.c
+++ b/test/121_coorddata_dr/coorddata_dr.c
@@ -16,6 +16,7 @@ void run(void) {
         unsigned char *data;
         size_t size;
         cube_t cube;
+        oriented_cube_t oc;
         uint64_t coord, coord2;
 
         size = coordinate_dr_gendata(NULL);
@@ -25,7 +26,8 @@ void run(void) {
         for (coord = 0; coord < BOUND; coord++) {
                 cube = coordinate_dr_cube(coord, data);
 
-                if (!isconsistent(cube)) {
+                oc = (oriented_cube_t) { .cube = cube, .orientation = 0 };
+                if (!isconsistent(oc)) {
                         printf("Error: invcoord of %" PRId64
                             " is not consistent\n", coord);
                         goto cleanup;
@@ -43,9 +45,10 @@ void run(void) {
                 }
 
                 if (!found) {
+                        oc = (oriented_cube_t){.cube = cube, .orientation = 0};
                         printf("Error: invcoord of %" PRId64 " returns %"
                             PRId64 " with cube:\n", coord, coord2);
-                        writecube(cube, STRLENMAX, str);
+                        writecube(oc, STRLENMAX, str);
                         printf("%s\n", str);
                         goto cleanup;
                 }
diff --git a/test/122_coorddata_dreo/coorddata_dreo.c b/test/122_coorddata_dreo/coorddata_dreo.c
index 98c954d..942e837 100644
--- a/test/122_coorddata_dreo/coorddata_dreo.c
+++ b/test/122_coorddata_dreo/coorddata_dreo.c
@@ -16,6 +16,7 @@ void run(void) {
         unsigned char *data;
         size_t size;
         cube_t cube;
+        oriented_cube_t oc;
         uint64_t coord, coord2;
 
         size = coordinate_dreo_gendata(NULL);
@@ -25,7 +26,8 @@ void run(void) {
         for (coord = 0; coord < BOUND; coord++) {
                 cube = coordinate_dreo_cube(coord, data);
 
-                if (!isconsistent(cube)) {
+                oc = (oriented_cube_t) { .cube = cube, .orientation = 0 };
+                if (!isconsistent(oc)) {
                         printf("Error: invcoord of %" PRId64
                             " is not consistent\n", coord);
                         goto cleanup;
@@ -43,9 +45,10 @@ void run(void) {
                 }
 
                 if (!found) {
+                        oc = (oriented_cube_t){.cube = cube, .orientation = 0};
                         printf("Error: invcoord of %" PRId64 " returns %"
                             PRId64 " with cube:\n", coord, coord2);
-                        writecube(cube, STRLENMAX, str);
+                        writecube(oc, STRLENMAX, str);
                         printf("%s\n", str);
                         goto cleanup;
                 }
diff --git a/test/test.h b/test/test.h
index 78a3fd9..6230f36 100644
--- a/test/test.h
+++ b/test/test.h
@@ -10,6 +10,7 @@
 
 #include "../src/nissy.h"
 #include "../src/arch/arch.h"
+#include "../src/core/core_types.h"
 #include "../src/solvers/solutions_types_macros.h"
 #include "../src/solvers/tables_types_macros.h"
 #include "../src/solvers/h48/coordinate_types_macros.h"
@@ -20,13 +21,13 @@
 #define STRLENMAX 10000
 
 /* Basic functions used in most tests */
-cube_t solvedcube(void);
-bool iserror(cube_t);
-bool isconsistent(cube_t);
-bool issolvable(cube_t);
-bool issolved(cube_t);
-cube_t readcube(char *);
-int64_t writecube(cube_t, size_t n, char [n]);
+oriented_cube_t solvedcube(void);
+bool iserror(oriented_cube_t);
+bool isconsistent(oriented_cube_t);
+bool issolvable(oriented_cube_t);
+bool issolved(oriented_cube_t);
+oriented_cube_t readcube(char *);
+int64_t writecube(oriented_cube_t, size_t n, char [n]);
 
 /* Test function to be implemented by all tests */
 void run(void);