commit bab22e1946a656088804b61cf765461b48744971 parent 93522effba2f200257141189de5925a23fca93b8 Author: Sebastiano Tronto <sebastiano@tronto.net> Date: Tue, 22 Apr 2025 16:12:21 +0200 Update tests for oriented_cube_t Diffstat:
38 files changed, 196 insertions(+), 142 deletions(-)
diff --git 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 @@ -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 @@ -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 @@ -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 @@ -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 @@ -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 @@ -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 @@ -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 @@ -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 diff --git 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 @@ -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 @@ -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 @@ -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 @@ -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 @@ -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 @@ -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 @@ -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 @@ -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 @@ -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 @@ -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 @@ -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 @@ -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 @@ -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 @@ -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 @@ -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 @@ -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 @@ -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 @@ -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 @@ -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 @@ -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 @@ -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 @@ -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 @@ -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 @@ -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 @@ -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 @@ -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 @@ -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);