tests/storage/get_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_selection_t sel,
  21                          xorn_attst_t expected_state, int expected_color)
  22 {
  23         xorn_attst_t state;
  24         int color;
  25
  26         xornsch_get_color(rev, sel, &state, &color);
  27         assert(state == expected_state);
  28         assert(color == expected_color);
  29 }
  30
  31 static void assert_line_width(xorn_revision_t rev, xorn_selection_t sel,
  32                               xorn_attst_t expected_state,
  33                               double expected_value)
  34 {
  35         xorn_attst_t state;
  36         double value;
  37
  38         xornsch_get_line_width(rev, sel, &state, &value);
  39         assert(state == expected_state);
  40         assert(value == expected_value);
  41 }
  42
  43 static void assert_fill_type(xorn_revision_t rev, xorn_selection_t sel,
  44                              xorn_attst_t expected_state, int expected_value)
  45 {
  46         xorn_attst_t state;
  47         int value;
  48
  49         xornsch_get_fill_type(rev, sel, &state, &value);
  50         assert(state == expected_state);
  51         assert(value == expected_value);
  52 }
  53
  54 static void assert_position(xorn_revision_t rev, xorn_selection_t sel,
  55                             xorn_attst_t expected_state,
  56                             double expected_x, double expected_y)
  57 {
  58         xorn_attst_t state;
  59         struct xorn_double2d position;
  60         double x, y;
  61
  62         xornsch_get_pos(rev, sel, &state, &position);
  63         assert(state == expected_state);
  64         assert(position.x == expected_x);
  65         assert(position.y == expected_y);
  66
  67         /* this doesn't generally work */
  68         xornsch_get_pos_x(rev, sel, &state, &x);
  69         assert(state == expected_state);
  70         assert(x == expected_x);
  71
  72         xornsch_get_pos_y(rev, sel, &state, &y);
  73         assert(state == expected_state);
  74         assert(y == expected_y);
  75 }
  76
  77 static void assert_text(xorn_revision_t rev, xorn_selection_t sel,
  78                         xorn_attst_t expected_state, char *expected_text)
  79 {
  80         xorn_attst_t state;
  81         struct xorn_string text;
  82
  83         xornsch_get_text(rev, sel, &state, &text);
  84         assert(state == expected_state);
  85         assert(text.len == strlen(expected_text));
  86         assert(memcmp(text.s, expected_text, text.len) == 0);
  87 }
  88
  89 static void assert_line(xorn_revision_t rev, xorn_selection_t sel,
  90                         xorn_attst_t expected_state,
  91                         double width, int cap_style, int dash_style,
  92                         double dash_length, double dash_space)
  93 {
  94         xorn_attst_t state;
  95         struct xornsch_line_attr expected_line, real_line;
  96
  97         memset(&expected_line, 0, sizeof expected_line);
  98         expected_line.width = width;
  99         expected_line.cap_style = cap_style;
 100         expected_line.dash_style = dash_style;
 101         expected_line.dash_length = dash_length;
 102         expected_line.dash_space = dash_space;
 103
 104         xornsch_get_line(rev, sel, &state, &real_line);
 105         assert(state == expected_state);
 106         assert(memcmp(&expected_line, &real_line, sizeof expected_line) == 0);
 107 }
 108
 109 static void assert_fill(xorn_revision_t rev, xorn_selection_t sel,
 110                         xorn_attst_t expected_state, int type, double width,
 111                         int angle0, double pitch0, int angle1, double pitch1)
 112 {
 113         xorn_attst_t state;
 114         struct xornsch_fill_attr expected_fill, real_fill;
 115
 116         memset(&expected_fill, 0, sizeof expected_fill);
 117         expected_fill.type = type;
 118         expected_fill.width = width;
 119         expected_fill.angle0 = angle0;
 120         expected_fill.pitch0 = pitch0;
 121         expected_fill.angle1 = angle1;
 122         expected_fill.pitch1 = pitch1;
 123
 124         xornsch_get_fill(rev, sel, &state, &real_fill);
 125         assert(state == expected_state);
 126         assert(memcmp(&expected_fill, &real_fill, sizeof expected_fill) == 0);
 127 }
 128
 129 int main(void)
 130 {
 131         xorn_revision_t rev0, rev1, rev2, rev3;
 132         xorn_object_t ob0, ob1a, ob1b;
 133         xorn_selection_t sel0, sel1, sel2, sel3;
 134
 135         xorn_revision_t rev4;
 136         struct xornsch_text text_data;
 137         xorn_object_t text0, text1;
 138         xorn_selection_t tsel0, tsel1, tselA;
 139
 140         setup(&rev0, &rev1, &rev2, &rev3, &ob0, &ob1a, &ob1b);
 141
 142         sel0 = xorn_select_all(rev0); assert(sel0 != NULL);
 143         sel1 = xorn_select_all(rev1); assert(sel1 != NULL);
 144         sel2 = xorn_select_all(rev2); assert(sel2 != NULL);
 145         sel3 = xorn_select_all(rev3); assert(sel3 != NULL);
 146
 147         rev4 = xorn_new_revision(rev3);
 148         assert(rev4 != NULL);
 149
 150         memset(&text_data, 0, sizeof text_data);
 151
 152         text_data.text.s = "Hello world";
 153         text_data.text.len = 11;
 154         text0 = xornsch_add_text(rev4, &text_data, NULL);
 155         assert(text0 != NULL);
 156
 157         text_data.text.s = "dlrow olleH";
 158         text_data.text.len = 11;
 159         text1 = xornsch_add_text(rev4, &text_data, NULL);
 160         assert(text0 != NULL);
 161
 162         xorn_finalize_revision(rev4);
 163
 164         tsel0 = xorn_select_object(text0);
 165         assert(tsel0 != NULL);
 166         tsel1 = xorn_select_object(text1);
 167         assert(tsel1 != NULL);
 168         tselA = xorn_select_all(rev4);
 169         assert(tselA != NULL);
 170
 171         assert_color(rev0, sel0, xorn_attst_na, 0);
 172         assert_color(rev0, sel1, xorn_attst_na, 0);
 173         assert_color(rev0, sel2, xorn_attst_na, 0);
 174         assert_color(rev0, sel3, xorn_attst_na, 0);
 175
 176         assert_color(rev1, sel0, xorn_attst_na, 0);
 177         assert_color(rev1, sel1, xorn_attst_consistent, 3);
 178         assert_color(rev1, sel2, xorn_attst_consistent, 3);
 179         assert_color(rev1, sel3, xorn_attst_consistent, 3);
 180
 181         assert_color(rev2, sel0, xorn_attst_na, 0);
 182         assert_color(rev2, sel1, xorn_attst_consistent, 3);
 183         assert_color(rev2, sel2, xorn_attst_consistent, 3);
 184         assert_color(rev2, sel3, xorn_attst_consistent, 3);
 185
 186         assert_color(rev3, sel0, xorn_attst_na, 0);
 187         assert_color(rev3, sel1, xorn_attst_consistent, 4);
 188         assert_color(rev3, sel2, xorn_attst_inconsistent, 0);
 189         assert_color(rev3, sel3, xorn_attst_inconsistent, 0);
 190
 191         assert_line_width(rev0, sel0, xorn_attst_na, 0.);
 192         assert_line_width(rev0, sel1, xorn_attst_na, 0.);
 193         assert_line_width(rev0, sel2, xorn_attst_na, 0.);
 194         assert_line_width(rev0, sel3, xorn_attst_na, 0.);
 195
 196         assert_line_width(rev1, sel0, xorn_attst_na, 0.);
 197         assert_line_width(rev1, sel1, xorn_attst_consistent, 1.);
 198         assert_line_width(rev1, sel2, xorn_attst_consistent, 1.);
 199         assert_line_width(rev1, sel3, xorn_attst_consistent, 1.);
 200
 201         assert_line_width(rev2, sel0, xorn_attst_na, 0.);
 202         assert_line_width(rev2, sel1, xorn_attst_consistent, 1.);
 203         assert_line_width(rev2, sel2, xorn_attst_consistent, 1.);
 204         assert_line_width(rev2, sel3, xorn_attst_consistent, 1.);
 205
 206         assert_line_width(rev3, sel0, xorn_attst_na, 0.);
 207         assert_line_width(rev3, sel1, xorn_attst_na, 0.);
 208         assert_line_width(rev3, sel2, xorn_attst_consistent, 1.);
 209         assert_line_width(rev3, sel3, xorn_attst_consistent, 1.);
 210
 211         assert_fill_type(rev0, sel0, xorn_attst_na, 0);
 212         assert_fill_type(rev0, sel1, xorn_attst_na, 0);
 213         assert_fill_type(rev0, sel2, xorn_attst_na, 0);
 214         assert_fill_type(rev0, sel3, xorn_attst_na, 0);
 215
 216         assert_fill_type(rev1, sel0, xorn_attst_na, 0);
 217         assert_fill_type(rev1, sel1, xorn_attst_na, 0);
 218         assert_fill_type(rev1, sel2, xorn_attst_na, 0);
 219         assert_fill_type(rev1, sel3, xorn_attst_na, 0);
 220
 221         assert_fill_type(rev2, sel0, xorn_attst_na, 0);
 222         assert_fill_type(rev2, sel1, xorn_attst_na, 0);
 223         assert_fill_type(rev2, sel2, xorn_attst_inconsistent, 0);
 224         assert_fill_type(rev2, sel3, xorn_attst_consistent, 1);
 225
 226         assert_fill_type(rev3, sel0, xorn_attst_na, 0);
 227         assert_fill_type(rev3, sel1, xorn_attst_na, 0);
 228         assert_fill_type(rev3, sel2, xorn_attst_consistent, 1);
 229         assert_fill_type(rev3, sel3, xorn_attst_consistent, 1);
 230
 231         assert_position(rev0, sel0, xorn_attst_na, 0., 0.);
 232         assert_position(rev0, sel1, xorn_attst_na, 0., 0.);
 233         assert_position(rev0, sel2, xorn_attst_na, 0., 0.);
 234         assert_position(rev0, sel3, xorn_attst_na, 0., 0.);
 235
 236         assert_position(rev1, sel0, xorn_attst_na, 0., 0.);
 237         assert_position(rev1, sel1, xorn_attst_consistent, 0., 1.);
 238         assert_position(rev1, sel2, xorn_attst_consistent, 0., 1.);
 239         assert_position(rev1, sel3, xorn_attst_consistent, 0., 1.);
 240
 241         assert_position(rev2, sel0, xorn_attst_na, 0., 0.);
 242         assert_position(rev2, sel1, xorn_attst_consistent, 0., 1.);
 243         assert_position(rev2, sel2, xorn_attst_inconsistent, 0., 0.);
 244         assert_position(rev2, sel3, xorn_attst_inconsistent, 0., 0.);
 245
 246         assert_position(rev3, sel0, xorn_attst_na, 0., 0.);
 247         assert_position(rev3, sel1, xorn_attst_consistent, 0., 1.);
 248         assert_position(rev3, sel2, xorn_attst_inconsistent, 0., 0.);
 249         assert_position(rev3, sel3, xorn_attst_inconsistent, 0., 0.);
 250
 251         assert_text(rev4, sel0, xorn_attst_na, "");
 252         assert_text(rev4, tsel0, xorn_attst_consistent, "Hello world");
 253         assert_text(rev4, tsel1, xorn_attst_consistent, "dlrow olleH");
 254         assert_text(rev4, tselA, xorn_attst_inconsistent, "");
 255
 256         assert_line(rev0, sel0, xorn_attst_na, 0., 0, 0, 0., 0.);
 257         assert_line(rev0, sel1, xorn_attst_na, 0., 0, 0, 0., 0.);
 258         assert_line(rev0, sel2, xorn_attst_na, 0., 0, 0, 0., 0.);
 259         assert_line(rev0, sel3, xorn_attst_na, 0., 0, 0, 0., 0.);
 260
 261         assert_line(rev1, sel0, xorn_attst_na, 0., 0, 0, 0., 0.);
 262         assert_line(rev1, sel1, xorn_attst_consistent, 1., 0, 0, 0., 0.);
 263         assert_line(rev1, sel2, xorn_attst_consistent, 1., 0, 0, 0., 0.);
 264         assert_line(rev1, sel3, xorn_attst_consistent, 1., 0, 0, 0., 0.);
 265
 266         assert_line(rev2, sel0, xorn_attst_na, 0., 0, 0, 0., 0.);
 267         assert_line(rev2, sel1, xorn_attst_consistent, 1., 0, 0, 0., 0.);
 268         assert_line(rev2, sel2, xorn_attst_consistent, 1., 0, 0, 0., 0.);
 269         assert_line(rev2, sel3, xorn_attst_consistent, 1., 0, 0, 0., 0.);
 270
 271         assert_line(rev3, sel0, xorn_attst_na, 0., 0, 0, 0., 0.);
 272         assert_line(rev3, sel1, xorn_attst_na, 0., 0, 0, 0., 0.);
 273         assert_line(rev3, sel2, xorn_attst_consistent, 1., 0, 0, 0., 0.);
 274         assert_line(rev3, sel3, xorn_attst_consistent, 1., 0, 0, 0., 0.);
 275
 276         assert_fill(rev0, sel0, xorn_attst_na, 0, 0., 0, 0., 0, 0.);
 277         assert_fill(rev0, sel1, xorn_attst_na, 0, 0., 0, 0., 0, 0.);
 278         assert_fill(rev0, sel2, xorn_attst_na, 0, 0., 0, 0., 0, 0.);
 279         assert_fill(rev0, sel3, xorn_attst_na, 0, 0., 0, 0., 0, 0.);
 280
 281         assert_fill(rev1, sel0, xorn_attst_na, 0, 0., 0, 0., 0, 0.);
 282         assert_fill(rev1, sel1, xorn_attst_na, 0, 0., 0, 0., 0, 0.);
 283         assert_fill(rev1, sel2, xorn_attst_na, 0, 0., 0, 0., 0, 0.);
 284         assert_fill(rev1, sel3, xorn_attst_na, 0, 0., 0, 0., 0, 0.);
 285
 286         assert_fill(rev2, sel0, xorn_attst_na, 0, 0., 0, 0., 0, 0.);
 287         assert_fill(rev2, sel1, xorn_attst_na, 0, 0., 0, 0., 0, 0.);
 288         assert_fill(rev2, sel2, xorn_attst_inconsistent, 0, 0., 0, 0., 0, 0.);
 289         assert_fill(rev2, sel3, xorn_attst_consistent, 1, 0., 0, 0., 0, 0.);
 290
 291         assert_fill(rev3, sel0, xorn_attst_na, 0, 0., 0, 0., 0, 0.);
 292         assert_fill(rev3, sel1, xorn_attst_na, 0, 0., 0, 0., 0, 0.);
 293         assert_fill(rev3, sel2, xorn_attst_consistent, 1, 0., 0, 0., 0, 0.);
 294         assert_fill(rev3, sel3, xorn_attst_consistent, 1, 0., 0, 0., 0, 0.);
 295
 296         xorn_free_selection(tselA);
 297         xorn_free_selection(tsel1);
 298         xorn_free_selection(tsel0);
 299         xorn_free_selection(sel3);
 300         xorn_free_selection(sel2);
 301         xorn_free_selection(sel1);
 302         xorn_free_selection(sel0);
 303
 304         xorn_free_revision(rev4);
 305         xorn_free_revision(rev3);
 306         xorn_free_revision(rev2);
 307         xorn_free_revision(rev1);
 308         xorn_free_revision(rev0);
 309         return 0;
 310 }