tests/storage/reloc_order.c

   1 /* Copyright (C) 2013-2020 Roland Lutz
   2
   3    This program is free software; you can redistribute it and/or modify
   4    it under the terms of the GNU General Public License as published by
   5    the Free Software Foundation; either version 2 of the License, or
   6    (at your option) any later version.
   7
   8    This program is distributed in the hope that it will be useful,
   9    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11    GNU General Public License for more details.
  12
  13    You should have received a copy of the GNU General Public License
  14    along with this program; if not, write to the Free Software Foundation,
  15    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  16
  17 #include "Setup.h"
  18 #include <stdlib.h>
  19
  20 #define E_OK      ((xorn_error_t) -1)
  21 #define E_NOTRANS xorn_error_revision_not_transient
  22 #define E_NOEXIST xorn_error_object_doesnt_exist
  23 #define E_NOSUCC  xorn_error_successor_doesnt_exist
  24
  25
  26 static void relocate_and_assert_3(
  27         xorn_revision_t rev,
  28         xorn_object_t ob, xorn_object_t insert_before,
  29         xorn_error_t expected_result,
  30         xorn_object_t ob0, xorn_object_t ob1, xorn_object_t ob2)
  31 {
  32         xorn_error_t err;
  33         xorn_object_t *objects;
  34         size_t count;
  35
  36         err = E_OK;
  37         assert(xorn_relocate_object(rev, ob, NULL, insert_before, &err)
  38                    == (expected_result == E_OK ? 0 : -1));
  39         assert(err == expected_result);
  40
  41         assert(xorn_get_objects(rev, &objects, &count) == 0);
  42         assert(objects != NULL);
  43         assert(count == 3);
  44         assert(objects[0] == ob0);
  45         assert(objects[1] == ob1);
  46         assert(objects[2] == ob2);
  47         free(objects);
  48 }
  49
  50 static void relocate_and_assert_2(
  51         xorn_revision_t rev,
  52         xorn_object_t ob, xorn_object_t insert_before,
  53         xorn_error_t expected_result,
  54         xorn_object_t ob0, xorn_object_t ob1)
  55 {
  56         xorn_error_t err;
  57         xorn_object_t *objects;
  58         size_t count;
  59
  60         err = E_OK;
  61         assert(xorn_relocate_object(rev, ob, NULL, insert_before, &err)
  62                    == (expected_result == E_OK ? 0 : -1));
  63         assert(err == expected_result);
  64
  65         assert(xorn_get_objects(rev, &objects, &count) == 0);
  66         assert(objects != NULL);
  67         assert(count == 2);
  68         assert(objects[0] == ob0);
  69         assert(objects[1] == ob1);
  70         free(objects);
  71 }
  72
  73 int main(void)
  74 {
  75         xorn_revision_t rev0, rev1, rev2, rev3;
  76         xorn_object_t ob0, ob1a, ob1b;
  77
  78         xorn_object_t *objects;
  79         size_t count;
  80
  81         xorn_revision_t rev4;
  82
  83         setup(&rev0, &rev1, &rev2, &rev3, &ob0, &ob1a, &ob1b);
  84
  85         rev4 = xorn_new_revision(rev2);
  86
  87         assert(xorn_get_objects(rev4, &objects, &count) == 0);
  88         assert(objects != NULL);
  89         assert(count == 3);
  90         assert(objects[0] == ob0);
  91         assert(objects[1] == ob1a);
  92         assert(objects[2] == ob1b);
  93         free(objects);
  94
  95         relocate_and_assert_3(rev4, ob0,  ob0,  E_OK,      ob0, ob1a, ob1b);
  96         relocate_and_assert_3(rev4, ob0,  ob1a, E_OK,      ob0, ob1a, ob1b);
  97         relocate_and_assert_3(rev4, ob0,  ob1b, E_OK,      ob1a, ob0, ob1b);
  98         relocate_and_assert_3(rev4, ob0,  NULL, E_OK,      ob1a, ob1b, ob0);
  99         relocate_and_assert_3(rev4, ob1a, ob0,  E_OK,      ob1b, ob1a, ob0);
 100         relocate_and_assert_3(rev4, ob1a, ob1a, E_OK,      ob1b, ob1a, ob0);
 101         relocate_and_assert_3(rev4, ob1a, ob1b, E_OK,      ob1a, ob1b, ob0);
 102         relocate_and_assert_3(rev4, ob1a, NULL, E_OK,      ob1b, ob0, ob1a);
 103         relocate_and_assert_3(rev4, ob1b, ob0,  E_OK,      ob1b, ob0, ob1a);
 104         relocate_and_assert_3(rev4, ob1b, ob1a, E_OK,      ob0, ob1b, ob1a);
 105         relocate_and_assert_3(rev4, ob1b, ob1b, E_OK,      ob0, ob1b, ob1a);
 106         relocate_and_assert_3(rev4, ob1b, NULL, E_OK,      ob0, ob1a, ob1b);
 107         relocate_and_assert_3(rev4, NULL, ob0,  E_NOEXIST, ob0, ob1a, ob1b);
 108         relocate_and_assert_3(rev4, NULL, ob1a, E_NOEXIST, ob0, ob1a, ob1b);
 109         relocate_and_assert_3(rev4, NULL, ob1b, E_NOEXIST, ob0, ob1a, ob1b);
 110         relocate_and_assert_3(rev4, NULL, NULL, E_NOEXIST, ob0, ob1a, ob1b);
 111
 112         relocate_and_assert_3(rev4, ob0,  ob0,  E_OK,      ob0, ob1a, ob1b);
 113         relocate_and_assert_3(rev4, ob1a, ob1a, E_OK,      ob0, ob1a, ob1b);
 114         relocate_and_assert_3(rev4, ob1b, ob1b, E_OK,      ob0, ob1a, ob1b);
 115
 116         assert(xorn_delete_object(rev4, ob0, NULL) == 0);
 117
 118         assert(xorn_get_objects(rev4, &objects, &count) == 0);
 119         assert(objects != NULL);
 120         assert(count == 2);
 121         assert(objects[0] == ob1a);
 122         assert(objects[1] == ob1b);
 123         free(objects);
 124
 125         relocate_and_assert_2(rev4, ob0,  ob0,  E_NOEXIST, ob1a, ob1b);
 126         relocate_and_assert_2(rev4, ob0,  ob1a, E_NOEXIST, ob1a, ob1b);
 127         relocate_and_assert_2(rev4, ob0,  ob1b, E_NOEXIST, ob1a, ob1b);
 128         relocate_and_assert_2(rev4, ob0,  NULL, E_NOEXIST, ob1a, ob1b);
 129         relocate_and_assert_2(rev4, ob1a, ob0,  E_NOSUCC,  ob1a, ob1b);
 130         relocate_and_assert_2(rev4, ob1a, ob1a, E_OK,      ob1a, ob1b);
 131         relocate_and_assert_2(rev4, ob1a, ob1b, E_OK,      ob1a, ob1b);
 132         relocate_and_assert_2(rev4, ob1a, NULL, E_OK,      ob1b, ob1a);
 133         relocate_and_assert_2(rev4, ob1b, ob0,  E_NOSUCC,  ob1b, ob1a);
 134         relocate_and_assert_2(rev4, ob1b, ob1a, E_OK,      ob1b, ob1a);
 135         relocate_and_assert_2(rev4, ob1b, ob1b, E_OK,      ob1b, ob1a);
 136         relocate_and_assert_2(rev4, ob1b, NULL, E_OK,      ob1a, ob1b);
 137         relocate_and_assert_2(rev4, NULL, ob0,  E_NOEXIST, ob1a, ob1b);
 138         relocate_and_assert_2(rev4, NULL, ob1a, E_NOEXIST, ob1a, ob1b);
 139         relocate_and_assert_2(rev4, NULL, ob1b, E_NOEXIST, ob1a, ob1b);
 140         relocate_and_assert_2(rev4, NULL, NULL, E_NOEXIST, ob1a, ob1b);
 141
 142         xorn_finalize_revision(rev4);
 143
 144         relocate_and_assert_2(rev4, ob1a, ob1a, E_NOTRANS, ob1a, ob1b);
 145         relocate_and_assert_2(rev4, ob1a, ob1b, E_NOTRANS, ob1a, ob1b);
 146         relocate_and_assert_2(rev4, ob1a, NULL, E_NOTRANS, ob1a, ob1b);
 147         relocate_and_assert_2(rev4, ob1b, ob1a, E_NOTRANS, ob1a, ob1b);
 148         relocate_and_assert_2(rev4, ob1b, ob1b, E_NOTRANS, ob1a, ob1b);
 149         relocate_and_assert_2(rev4, ob1b, NULL, E_NOTRANS, ob1a, ob1b);
 150
 151         xorn_free_revision(rev4);
 152         xorn_free_revision(rev3);
 153         xorn_free_revision(rev2);
 154         xorn_free_revision(rev1);
 155         xorn_free_revision(rev0);
 156         return 0;
 157 }