tests/storage/copy_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
  23 static void assert_this_net(xorn_revision_t rev, xorn_object_t ob, int color)
  24 {
  25         xorn_object_t *objects;
  26         size_t count;
  27
  28         assert(xorn_get_objects(rev, &objects, &count) == 0);
  29         assert(objects != NULL);
  30         assert(count == 1);
  31         assert(objects[0] == ob);
  32         assert(xorn_get_object_type(rev, ob) == xornsch_obtype_net);
  33         assert(xornsch_get_net_data(rev, ob)->color == color);
  34         free(objects);
  35 }
  36
  37 static void assert_this_net_with_text(
  38         xorn_revision_t rev, xorn_object_t ob, int color, int text_color)
  39 {
  40         xorn_object_t *objects;
  41         size_t count;
  42
  43         assert(xorn_get_objects_attached_to(rev, NULL, &objects, &count) == 0);
  44         assert(objects != NULL);
  45         assert(count == 1);
  46         assert(objects[0] == ob);
  47         assert(xorn_get_object_type(rev, ob) == xornsch_obtype_net);
  48         assert(xornsch_get_net_data(rev, ob)->color == color);
  49         free(objects);
  50
  51         assert(xorn_get_objects_attached_to(rev, ob, &objects, &count) == 0);
  52         assert(objects != NULL);
  53         assert(count == 1);
  54         assert(xorn_get_object_type(rev, objects[0]) == xornsch_obtype_text);
  55         assert(xornsch_get_text_data(rev, objects[0])->color == text_color);
  56         free(objects);
  57 }
  58
  59 static xorn_object_t get_only_selected_object(
  60         xorn_revision_t rev, xorn_selection_t sel)
  61 {
  62         xorn_object_t *objects;
  63         size_t count;
  64         xorn_object_t ob;
  65
  66         assert(xorn_get_selected_objects(rev, sel, &objects, &count) == 0);
  67         assert(objects != NULL);
  68         assert(count == 1);
  69         ob = objects[0];
  70         free(objects);
  71
  72         return ob;
  73 }
  74
  75 static void assert_four(xorn_revision_t rev, xorn_selection_t sel,
  76                         int net0_color, int net1_color,
  77                         int text0_color, int text1_color)
  78 {
  79         xorn_object_t *objects;
  80         size_t count;
  81         xorn_object_t net0, net1, text0, text1;
  82
  83         const struct xornsch_net *net_data;
  84         const struct xornsch_text *text_data;
  85
  86         assert(xorn_get_objects_attached_to(rev, NULL, &objects, &count) == 0);
  87         assert(objects != NULL);
  88         assert(count == 3);
  89           assert(net_data = xornsch_get_net_data(rev, objects[0]));
  90           assert(net_data->color == net0_color);
  91           net0 = objects[0];
  92
  93           assert(net_data = xornsch_get_net_data(rev, objects[1]));
  94           assert(net_data->color == net1_color);
  95           net1 = objects[1];
  96
  97           assert(text_data = xornsch_get_text_data(rev, objects[2]));
  98           assert(text_data->color == text0_color);
  99           text0 = objects[2];
 100         free(objects);
 101
 102         assert(xorn_get_objects_attached_to(rev, net0, &objects, &count) == 0);
 103         assert(count == 0);
 104         free(objects);
 105
 106         assert(xorn_get_objects_attached_to(rev, net1, &objects, &count) == 0);
 107         assert(objects != NULL);
 108         assert(count == 1);
 109         assert(text_data = xornsch_get_text_data(rev, objects[0]));
 110         assert(text_data->color == text1_color);
 111         text1 = objects[0];
 112         free(objects);
 113
 114         assert(xorn_get_objects_attached_to(
 115                        rev, text0, &objects, &count) == 0);
 116         assert(count == 0);
 117         free(objects);
 118
 119         assert(xorn_get_objects_attached_to(
 120                        rev, text1, &objects, &count) == 0);
 121         assert(count == 0);
 122         free(objects);
 123
 124         assert(xorn_object_is_selected(rev, sel, net0) == true);
 125         assert(xorn_object_is_selected(rev, sel, net1) == true);
 126         assert(xorn_object_is_selected(rev, sel, text0) == true);
 127         assert(xorn_object_is_selected(rev, sel, text1) == false);
 128 }
 129
 130 int main(void)
 131 {
 132         xorn_revision_t src, dest;
 133         struct xornsch_net net_data;
 134         struct xornsch_text text_data;
 135         xorn_object_t net0, net1, text0, text1, copy;
 136         xorn_selection_t sel, copies;
 137
 138         assert(src = xorn_new_revision(NULL));
 139
 140         memset(&net_data, 0, sizeof net_data);
 141         net_data.color = 1;
 142         assert(net0 = xornsch_add_net(src, &net_data, NULL));
 143         net_data.color = 2;
 144         assert(net1 = xornsch_add_net(src, &net_data, NULL));
 145
 146         memset(&text_data, 0, sizeof text_data);
 147         text_data.color = 3;
 148         assert(text0 = xornsch_add_text(src, &text_data, NULL));
 149         text_data.color = 4;
 150         assert(text1 = xornsch_add_text(src, &text_data, NULL));
 151
 152         assert(xorn_relocate_object(src, text1, net1, NULL, NULL) == 0);
 153
 154         xorn_finalize_revision(src);
 155
 156         /* text1 is attached to net1, text0 is not attached */
 157
 158         assert(dest = xorn_new_revision(NULL));
 159         assert(copy = xorn_copy_object(dest, src, net0, NULL));
 160         assert_this_net(dest, copy, 1);
 161         xorn_free_revision(dest);
 162
 163         assert(dest = xorn_new_revision(NULL));
 164         assert(copy = xorn_copy_object(dest, src, net1, NULL));
 165         assert_this_net_with_text(dest, copy, 2, 4);
 166         xorn_free_revision(dest);
 167
 168         assert(dest = xorn_new_revision(NULL));
 169         assert(sel = xorn_select_object(net0));
 170         assert(copies = xorn_copy_objects(dest, src, sel, NULL));
 171         assert_this_net(dest, get_only_selected_object(dest, copies), 1);
 172         xorn_free_selection(copies);
 173         xorn_free_selection(sel);
 174         xorn_free_revision(dest);
 175
 176         assert(dest = xorn_new_revision(NULL));
 177         assert(sel = xorn_select_object(net1));
 178         assert(copies = xorn_copy_objects(dest, src, sel, NULL));
 179         assert_this_net_with_text(
 180                 dest, get_only_selected_object(dest, copies), 2, 4);
 181         xorn_free_selection(copies);
 182         xorn_free_selection(sel);
 183         xorn_free_revision(dest);
 184
 185         assert(dest = xorn_new_revision(NULL));
 186         assert(sel = xorn_select_attached_to(src, NULL));
 187         assert(copies = xorn_copy_objects(dest, src, sel, NULL));
 188         assert_four(dest, copies, 1, 2, 3, 4);
 189         xorn_free_selection(copies);
 190         xorn_free_selection(sel);
 191         xorn_free_revision(dest);
 192
 193         xorn_free_revision(src);
 194         return 0;
 195 }