tests/storage/query_attached.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 <assert.h>
  18 #include <stdlib.h>
  19 #include <string.h>
  20 #include <xornstorage.h>
  21
  22 #define _ NULL
  23
  24
  25 static void assert_attached_objects_0(
  26         xorn_revision_t rev, xorn_object_t attached_to)
  27 {
  28         xorn_object_t *objects;
  29         size_t count;
  30         xorn_selection_t sel;
  31
  32         assert(xorn_get_objects_attached_to(
  33                        rev, attached_to, NULL, &count) == 0);
  34         assert(count == 0);
  35
  36         count = -1;
  37         assert(xorn_get_objects_attached_to(
  38                        rev, attached_to, &objects, &count) == 0);
  39         assert(count == 0);
  40         free(objects);
  41
  42         assert(sel = xorn_select_attached_to(rev, attached_to));
  43         assert(xorn_get_selected_objects(rev, sel, &objects, &count) == 0);
  44         assert(count == 0);
  45         free(objects);
  46         xorn_free_selection(sel);
  47 }
  48
  49 static void assert_attached_objects_1(
  50         xorn_revision_t rev, xorn_object_t attached_to,
  51         xorn_object_t ob0)
  52 {
  53         xorn_object_t *objects;
  54         size_t count;
  55         xorn_selection_t sel;
  56
  57         assert(xorn_get_objects_attached_to(
  58                        rev, attached_to, NULL, &count) == 0);
  59         assert(count == 1);
  60
  61         count = -1;
  62         assert(xorn_get_objects_attached_to(
  63                        rev, attached_to, &objects, &count) == 0);
  64         assert(objects != NULL);
  65         assert(count == 1);
  66         assert(objects[0] == ob0);
  67         free(objects);
  68
  69         assert(sel = xorn_select_attached_to(rev, attached_to));
  70         assert(xorn_get_selected_objects(rev, sel, &objects, &count) == 0);
  71         assert(objects != NULL);
  72         assert(count == 1);
  73         assert(objects[0] == ob0);
  74         free(objects);
  75         xorn_free_selection(sel);
  76 }
  77
  78 static void assert_attached_objects_2(
  79         xorn_revision_t rev, xorn_object_t attached_to,
  80         xorn_object_t ob0, xorn_object_t ob1)
  81 {
  82         xorn_object_t *objects;
  83         size_t count;
  84         xorn_selection_t sel;
  85
  86         assert(xorn_get_objects_attached_to(
  87                        rev, attached_to, NULL, &count) == 0);
  88         assert(count == 2);
  89
  90         count = -1;
  91         assert(xorn_get_objects_attached_to(
  92                        rev, attached_to, &objects, &count) == 0);
  93         assert(objects != NULL);
  94         assert(count == 2);
  95         assert(objects[0] == ob0);
  96         assert(objects[1] == ob1);
  97         free(objects);
  98
  99         assert(sel = xorn_select_attached_to(rev, attached_to));
 100         assert(xorn_get_selected_objects(rev, sel, &objects, &count) == 0);
 101         assert(objects != NULL);
 102         assert(count == 2);
 103         assert((objects[0] == ob0 && objects[1] == ob1) ||
 104                (objects[0] == ob1 && objects[1] == ob0));
 105         free(objects);
 106         xorn_free_selection(sel);
 107 }
 108
 109 static void assert_attached_objects_3(
 110         xorn_revision_t rev, xorn_object_t attached_to,
 111         xorn_object_t ob0, xorn_object_t ob1, xorn_object_t ob2)
 112 {
 113         xorn_object_t *objects;
 114         size_t count;
 115         xorn_selection_t sel;
 116
 117         assert(xorn_get_objects_attached_to(
 118                        rev, attached_to, NULL, &count) == 0);
 119         assert(count == 3);
 120
 121         count = -1;
 122         assert(xorn_get_objects_attached_to(
 123                        rev, attached_to, &objects, &count) == 0);
 124         assert(objects != NULL);
 125         assert(count == 3);
 126         assert(objects[0] == ob0);
 127         assert(objects[1] == ob1);
 128         assert(objects[2] == ob2);
 129         free(objects);
 130
 131         assert(sel = xorn_select_attached_to(rev, attached_to));
 132         assert(xorn_get_selected_objects(rev, sel, &objects, &count) == 0);
 133         assert(objects != NULL);
 134         assert(count == 3);
 135         assert(
 136             (objects[0] == ob0 && objects[1] == ob1 && objects[2] == ob2) ||
 137             (objects[0] == ob0 && objects[1] == ob2 && objects[2] == ob1) ||
 138             (objects[0] == ob1 && objects[1] == ob0 && objects[2] == ob2) ||
 139             (objects[0] == ob1 && objects[1] == ob2 && objects[2] == ob0) ||
 140             (objects[0] == ob2 && objects[1] == ob0 && objects[2] == ob1) ||
 141             (objects[0] == ob2 && objects[1] == ob1 && objects[2] == ob0));
 142         free(objects);
 143         xorn_free_selection(sel);
 144 }
 145
 146 static void assert_attached_objects_f(
 147         xorn_revision_t rev, xorn_object_t attached_to)
 148 {
 149         xorn_object_t *objects;
 150         size_t count;
 151
 152         assert(xorn_get_objects_attached_to(
 153                        rev, attached_to, &objects, &count) == -1);
 154
 155         assert(xorn_select_attached_to(rev, attached_to) == NULL);
 156 }
 157
 158 int main(void)
 159 {
 160         xorn_revision_t rev;
 161         struct xornsch_net net_data;
 162         struct xornsch_text text_data;
 163         xorn_object_t N, a, b;
 164
 165         assert(rev = xorn_new_revision(NULL));
 166
 167         memset(&net_data, 0, sizeof net_data);
 168         assert(N = xornsch_add_net(rev, &net_data, NULL));
 169
 170         memset(&text_data, 0, sizeof text_data);
 171         assert(a = xornsch_add_text(rev, &text_data, NULL));
 172         assert(b = xornsch_add_text(rev, &text_data, NULL));
 173
 174         assert_attached_objects_3(rev, _, N, a, b);
 175         assert_attached_objects_0(rev, N);
 176         assert_attached_objects_0(rev, a);
 177         assert_attached_objects_0(rev, b);
 178
 179         assert(xorn_relocate_object(rev, N, _, _, NULL) == 0);
 180
 181         assert_attached_objects_3(rev, _, a, b, N);
 182         assert_attached_objects_0(rev, N);
 183         assert_attached_objects_0(rev, a);
 184         assert_attached_objects_0(rev, b);
 185
 186         assert(xorn_relocate_object(rev, N, _, b, NULL) == 0);
 187
 188         assert_attached_objects_3(rev, _, a, N, b);
 189         assert_attached_objects_0(rev, N);
 190         assert_attached_objects_0(rev, a);
 191         assert_attached_objects_0(rev, b);
 192
 193         assert(xorn_relocate_object(rev, a, N, _, NULL) == 0);
 194
 195         assert_attached_objects_2(rev, _, N, b);
 196         assert_attached_objects_1(rev, N, a);
 197         assert_attached_objects_0(rev, a);
 198         assert_attached_objects_0(rev, b);
 199
 200         assert(xorn_relocate_object(rev, b, N, _, NULL) == 0);
 201
 202         assert_attached_objects_1(rev, _, N);
 203         assert_attached_objects_2(rev, N, a, b);
 204         assert_attached_objects_0(rev, a);
 205         assert_attached_objects_0(rev, b);
 206
 207         assert(xorn_relocate_object(rev, a, N, _, NULL) == 0);
 208
 209         assert_attached_objects_1(rev, _, N);
 210         assert_attached_objects_2(rev, N, b, a);
 211         assert_attached_objects_0(rev, a);
 212         assert_attached_objects_0(rev, b);
 213
 214         assert(xorn_relocate_object(rev, a, N, b, NULL) == 0);
 215
 216         assert_attached_objects_1(rev, _, N);
 217         assert_attached_objects_2(rev, N, a, b);
 218         assert_attached_objects_0(rev, a);
 219         assert_attached_objects_0(rev, b);
 220
 221         assert(xorn_delete_object(rev, b, NULL) == 0);
 222
 223         assert_attached_objects_1(rev, _, N);
 224         assert_attached_objects_1(rev, N, a);
 225         assert_attached_objects_0(rev, a);
 226         assert_attached_objects_f(rev, b);
 227
 228         assert(xorn_delete_object(rev, N, NULL) == 0);
 229
 230         assert_attached_objects_0(rev, _);
 231         assert_attached_objects_f(rev, N);
 232         assert_attached_objects_f(rev, a);
 233         assert_attached_objects_f(rev, b);
 234
 235         xorn_free_revision(rev);
 236         return 0;
 237 }