tests/storage/set_attribute.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
  19
  20 static void assert_color(xorn_revision_t rev, xorn_object_t ob,
  21                          bool has_color, int color)
  22 {
  23         xorn_selection_t sel;
  24         xorn_attst_t state;
  25         int real_color;
  26
  27         sel = xorn_select_object(ob);
  28         assert(sel != NULL);
  29         xornsch_get_color(rev, sel, &state, &real_color);
  30         assert(state == (has_color ? xorn_attst_consistent : xorn_attst_na));
  31         assert(real_color == color);
  32         xorn_free_selection(sel);
  33 }
  34
  35 static void assert_line_width(xorn_revision_t rev, xorn_object_t ob,
  36                               bool has_line_width, double line_width)
  37 {
  38         xorn_selection_t sel;
  39         xorn_attst_t state;
  40         double real_line_width;
  41
  42         sel = xorn_select_object(ob);
  43         assert(sel != NULL);
  44         xornsch_get_line_width(rev, sel, &state, &real_line_width);
  45         assert(state == (has_line_width ? xorn_attst_consistent
  46                                         : xorn_attst_na));
  47         assert(real_line_width == line_width);
  48         xorn_free_selection(sel);
  49 }
  50
  51 static void assert_position(xorn_revision_t rev, xorn_object_t ob,
  52                             bool has_position, double x, double y)
  53 {
  54         xorn_selection_t sel;
  55         xorn_attst_t state;
  56         struct xorn_double2d real_position;
  57
  58         sel = xorn_select_object(ob);
  59         assert(sel != NULL);
  60         xornsch_get_pos(rev, sel, &state, &real_position);
  61         assert(state == (has_position ? xorn_attst_consistent
  62                                       : xorn_attst_na));
  63         assert(real_position.x == x);
  64         assert(real_position.y == y);
  65         xorn_free_selection(sel);
  66 }
  67
  68 static void assert_text(xorn_revision_t rev, xorn_object_t ob,
  69                         bool has_text, const char *text)
  70 {
  71         xorn_selection_t sel;
  72         xorn_attst_t state;
  73         struct xorn_string real_text;
  74
  75         sel = xorn_select_object(ob);
  76         assert(sel != NULL);
  77         xornsch_get_text(rev, sel, &state, &real_text);
  78         assert(state == (has_text ? xorn_attst_consistent : xorn_attst_na));
  79         assert(real_text.len == strlen(text));
  80         assert(memcmp(real_text.s, text, real_text.len) == 0);
  81         xorn_free_selection(sel);
  82 }
  83
  84 static void assert_line(xorn_revision_t rev, xorn_object_t ob, bool has_line,
  85                         double width, int cap_style, int dash_style,
  86                         double dash_length, double dash_space)
  87 {
  88         xorn_selection_t sel;
  89         xorn_attst_t state;
  90         struct xornsch_line_attr expected_line, real_line;
  91
  92         memset(&expected_line, 0, sizeof expected_line);
  93         expected_line.width = width;
  94         expected_line.cap_style = cap_style;
  95         expected_line.dash_style = dash_style;
  96         expected_line.dash_length = dash_length;
  97         expected_line.dash_space = dash_space;
  98
  99         sel = xorn_select_object(ob);
 100         assert(sel != NULL);
 101         xornsch_get_line(rev, sel, &state, &real_line);
 102         assert(state == (has_line ? xorn_attst_consistent : xorn_attst_na));
 103         assert(memcmp(&expected_line, &real_line, sizeof expected_line) == 0);
 104         xorn_free_selection(sel);
 105 }
 106
 107 static void assert_fill(xorn_revision_t rev, xorn_object_t ob, bool has_fill,
 108                         int type, double width, int angle0, double pitch0,
 109                         int angle1, double pitch1)
 110 {
 111         xorn_selection_t sel;
 112         xorn_attst_t state;
 113         struct xornsch_fill_attr expected_fill, real_fill;
 114
 115         memset(&expected_fill, 0, sizeof expected_fill);
 116         expected_fill.type = type;
 117         expected_fill.width = width;
 118         expected_fill.angle0 = angle0;
 119         expected_fill.pitch0 = pitch0;
 120         expected_fill.angle1 = angle1;
 121         expected_fill.pitch1 = pitch1;
 122
 123         sel = xorn_select_object(ob);
 124         assert(sel != NULL);
 125         xornsch_get_fill(rev, sel, &state, &real_fill);
 126         assert(state == (has_fill ? xorn_attst_consistent : xorn_attst_na));
 127         assert(memcmp(&expected_fill, &real_fill, sizeof expected_fill) == 0);
 128         xorn_free_selection(sel);
 129 }
 130
 131 int main(void)
 132 {
 133         xorn_revision_t rev0, rev1, rev2, rev3;
 134         xorn_object_t ob0, ob1a, ob1b;
 135
 136         xorn_selection_t sel0, sel1, sel2, sel3;
 137         xorn_revision_t rev4;
 138         struct xorn_double2d pos;
 139
 140         struct xornsch_text text_data;
 141         xorn_object_t text_ob;
 142         xorn_selection_t text_sel;
 143
 144         xorn_revision_t rev5;
 145         struct xornsch_line_attr line;
 146         struct xornsch_fill_attr fill;
 147
 148         xorn_error_t err;
 149
 150         setup(&rev0, &rev1, &rev2, &rev3, &ob0, &ob1a, &ob1b);
 151
 152         sel0 = xorn_select_all(rev0); assert(sel0 != NULL);
 153         sel1 = xorn_select_all(rev1); assert(sel1 != NULL);
 154         sel2 = xorn_select_all(rev2); assert(sel2 != NULL);
 155         sel3 = xorn_select_all(rev3); assert(sel3 != NULL);
 156
 157         rev4 = xorn_new_revision(rev3);
 158         assert(rev4 != NULL);
 159
 160         assert(xornsch_set_color(rev4, sel0, 17, NULL) == 0);
 161         assert_color(rev4, ob0, true, 4);
 162         assert_color(rev4, ob1a, false, 0);
 163         assert_color(rev4, ob1b, true, 3);
 164
 165         assert(xornsch_set_color(rev4, sel1, 18, NULL) == 0);
 166         assert_color(rev4, ob0, true, 18);
 167         assert_color(rev4, ob1a, false, 0);
 168         assert_color(rev4, ob1b, true, 3);
 169
 170         assert(xornsch_set_color(rev4, sel2, 19, NULL) == 0);
 171         assert_color(rev4, ob0, true, 19);
 172         assert_color(rev4, ob1a, false, 0);
 173         assert_color(rev4, ob1b, true, 19);
 174
 175         assert(xornsch_set_color(rev4, sel3, 20, NULL) == 0);
 176         assert_color(rev4, ob0, true, 20);
 177         assert_color(rev4, ob1a, false, 0);
 178         assert_color(rev4, ob1b, true, 20);
 179
 180         assert(xornsch_set_color(rev4, sel3, 21, NULL) == 0);
 181         /* I'd prefer to have this raise an error */
 182         assert_color(rev4, ob0, true, 20);
 183         assert_color(rev4, ob1a, false, 0);
 184         assert_color(rev4, ob1b, true, 20);
 185
 186         assert(xornsch_set_line_width(rev4, sel0, 8.0, NULL) == 0);
 187         assert_line_width(rev4, ob0, false, 0.);
 188         assert_line_width(rev4, ob1a, false, 0.);
 189         assert_line_width(rev4, ob1b, true, 1.);
 190
 191         assert(xornsch_set_line_width(rev4, sel1, 8.1, NULL) == 0);
 192         assert_line_width(rev4, ob0, false, 0.);
 193         assert_line_width(rev4, ob1a, false, 0.);
 194         assert_line_width(rev4, ob1b, true, 1.);
 195
 196         assert(xornsch_set_line_width(rev4, sel2, 8.2, NULL) == 0);
 197         assert_line_width(rev4, ob0, false, 0.);
 198         assert_line_width(rev4, ob1a, false, 0.);
 199         assert_line_width(rev4, ob1b, true, 8.2);
 200
 201         assert(xornsch_set_line_width(rev4, sel3, 8.3, NULL) == 0);
 202         assert_line_width(rev4, ob0, false, 0.);
 203         assert_line_width(rev4, ob1a, false, 0.);
 204         assert_line_width(rev4, ob1b, true, 8.3);
 205
 206         pos.x = 9.00; pos.y = 9.05;
 207         assert(xornsch_set_pos(rev4, sel0, &pos, NULL) == 0);
 208         assert_position(rev4, ob0, true, 0., 1.);
 209         assert_position(rev4, ob1a, false, 0., 0.);
 210         assert_position(rev4, ob1b, true, -1., -1.);
 211
 212         pos.x = 9.10; pos.y = 9.15;
 213         assert(xornsch_set_pos(rev4, sel1, &pos, NULL) == 0);
 214         assert_position(rev4, ob0, true, 9.10, 9.15);
 215         assert_position(rev4, ob1a, false, 0., 0.);
 216         assert_position(rev4, ob1b, true, -1., -1.);
 217
 218         pos.x = 9.20; pos.y = 9.25;
 219         assert(xornsch_set_pos(rev4, sel2, &pos, NULL) == 0);
 220         assert_position(rev4, ob0, true, 9.20, 9.25);
 221         assert_position(rev4, ob1a, false, 0., 0.);
 222         assert_position(rev4, ob1b, true, 9.20, 9.25);
 223
 224         pos.x = 9.30; pos.y = 9.35;
 225         assert(xornsch_set_pos(rev4, sel3, &pos, NULL) == 0);
 226         assert_position(rev4, ob0, true, 9.30, 9.35);
 227         assert_position(rev4, ob1a, false, 0., 0.);
 228         assert_position(rev4, ob1b, true, 9.30, 9.35);
 229
 230         assert(xornsch_set_pos_x(rev4, sel3, 9.40, NULL) == 0);
 231         assert_position(rev4, ob0, true, 9.40, 9.35);
 232         assert_position(rev4, ob1a, false, 0., 0.);
 233         assert_position(rev4, ob1b, true, 9.40, 9.35);
 234
 235         assert(xornsch_set_pos_y(rev4, sel3, 9.45, NULL) == 0);
 236         assert_position(rev4, ob0, true, 9.40, 9.45);
 237         assert_position(rev4, ob1a, false, 0., 0.);
 238         assert_position(rev4, ob1b, true, 9.40, 9.45);
 239
 240         memset(&text_data, 0, sizeof text_data);
 241         text_data.text.s = "Hello world";
 242         text_data.text.len = 11;
 243         text_ob = xornsch_add_text(rev4, &text_data, NULL);
 244         assert(text_ob != NULL);
 245         text_sel = xorn_select_object(text_ob);
 246         assert(text_sel != NULL);
 247
 248         assert_text(rev4, ob0, false, "");
 249         assert_text(rev4, ob1a, false, "");
 250         assert_text(rev4, ob1b, false, "");
 251         assert_text(rev4, text_ob, true, "Hello world");
 252
 253         text_data.text.s = "dlrow olleH";
 254         assert(xornsch_set_text(rev4, text_sel, &text_data.text, NULL) == 0);
 255
 256         assert_text(rev4, ob0, false, "");
 257         assert_text(rev4, ob1a, false, "");
 258         assert_text(rev4, ob1b, false, "");
 259         assert_text(rev4, text_ob, true, "dlrow olleH");
 260
 261         xorn_finalize_revision(rev4);
 262
 263         rev5 = xorn_new_revision(rev2);
 264         assert(rev5 != NULL);
 265
 266         memset(&line, 0, sizeof line);
 267         line.width = 10.;
 268         line.cap_style = 1;
 269         line.dash_style = 2;
 270         line.dash_length = 13.;
 271         line.dash_space = 14.;
 272
 273         assert(xornsch_set_line(rev5, sel0, &line, NULL) == 0);
 274         assert_line(rev5, ob0, true, 1., 0, 0, 0., 0.);
 275         assert_line(rev5, ob1a, true, 1., 0, 0, 0., 0.);
 276         assert_line(rev5, ob1b, true, 1., 0, 0, 0., 0.);
 277
 278         assert(xornsch_set_line(rev5, sel1, &line, NULL) == 0);
 279         assert_line(rev5, ob0, true, 10., 1, 2, 13., 14.);
 280         assert_line(rev5, ob1a, true, 1., 0, 0, 0., 0.);
 281         assert_line(rev5, ob1b, true, 1., 0, 0, 0., 0.);
 282
 283         assert(xornsch_set_line(rev5, sel2, &line, NULL) == 0);
 284         assert_line(rev5, ob0, true, 10., 1, 2, 13., 14.);
 285         assert_line(rev5, ob1a, true, 10., 1, 2, 13., 14.);
 286         assert_line(rev5, ob1b, true, 10., 1, 2, 13., 14.);
 287
 288         line.dash_space = 14.1;
 289
 290         assert(xornsch_set_line(rev5, sel3, &line, NULL) == 0);
 291         assert_line(rev5, ob0, true, 10., 1, 2, 13., 14.1);
 292         assert_line(rev5, ob1a, true, 10., 1, 2, 13., 14.);
 293         assert_line(rev5, ob1b, true, 10., 1, 2, 13., 14.1);
 294
 295         memset(&fill, 0, sizeof fill);
 296         fill.type = 2;
 297         fill.width = 21.;
 298         fill.angle0 = 22;
 299         fill.pitch0 = 23.;
 300         fill.angle1 = 24;
 301         fill.pitch1 = 25.;
 302
 303         assert(xornsch_set_fill(rev5, sel0, &fill, NULL) == 0);
 304         assert_fill(rev5, ob0, false, 0, 0., 0, 0., 0, 0.);
 305         assert_fill(rev5, ob1a, true, 0, 0., 0, 0., 0, 0.);
 306         assert_fill(rev5, ob1b, true, 1, 0., 0, 0., 0, 0.);
 307
 308         assert(xornsch_set_fill(rev5, sel1, &fill, NULL) == 0);
 309         assert_fill(rev5, ob0, false, 0, 0., 0, 0., 0, 0.);
 310         assert_fill(rev5, ob1a, true, 0, 0., 0, 0., 0, 0.);
 311         assert_fill(rev5, ob1b, true, 1, 0., 0, 0., 0, 0.);
 312
 313         assert(xornsch_set_fill(rev5, sel2, &fill, NULL) == 0);
 314         assert_fill(rev5, ob0, false, 0, 0., 0, 0., 0, 0.);
 315         assert_fill(rev5, ob1a, true, 2, 21., 22, 23., 24, 25.);
 316         assert_fill(rev5, ob1b, true, 2, 21., 22, 23., 24, 25.);
 317
 318         fill.pitch1 = 25.1;
 319
 320         assert(xornsch_set_fill(rev5, sel3, &fill, NULL) == 0);
 321         assert_fill(rev5, ob0, false, 0, 0., 0, 0., 0, 0.);
 322         assert_fill(rev5, ob1a, true, 2, 21., 22, 23., 24, 25.);
 323         assert_fill(rev5, ob1b, true, 2, 21., 22, 23., 24, 25.1);
 324
 325         xorn_finalize_revision(rev5);
 326
 327         fill.pitch1 = 25.2;
 328
 329         assert(xornsch_set_fill(rev5, sel3, &fill, &err) == -1);
 330         assert(err == xorn_error_revision_not_transient);
 331         assert_fill(rev5, ob0, false, 0, 0., 0, 0., 0, 0.);
 332         assert_fill(rev5, ob1a, true, 2, 21., 22, 23., 24, 25.);
 333         assert_fill(rev5, ob1b, true, 2, 21., 22, 23., 24, 25.1);
 334
 335         xorn_free_selection(text_sel);
 336         xorn_free_selection(sel3);
 337         xorn_free_selection(sel2);
 338         xorn_free_selection(sel1);
 339         xorn_free_selection(sel0);
 340
 341         xorn_free_revision(rev5);
 342         xorn_free_revision(rev4);
 343         xorn_free_revision(rev3);
 344         xorn_free_revision(rev2);
 345         xorn_free_revision(rev1);
 346         xorn_free_revision(rev0);
 347         return 0;
 348 }