tests/storage/selection.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
  21 static void assert_selected_objects_0(
  22     xorn_revision_t rev, xorn_selection_t sel)
  23 {
  24         xorn_object_t *objects;
  25         size_t count;
  26
  27         assert(xorn_get_selected_objects(rev, sel, &objects, &count) == 0);
  28         assert(count == 0);
  29         free(objects);
  30
  31         assert(xorn_selection_is_empty(rev, sel) == true);
  32 }
  33
  34 static void assert_selected_objects_1(
  35     xorn_revision_t rev, xorn_selection_t sel, xorn_object_t ob)
  36 {
  37         xorn_object_t *objects;
  38         size_t count;
  39
  40         assert(xorn_get_selected_objects(rev, sel, &objects, &count) == 0);
  41         assert(objects != NULL);
  42         assert(count == 1);
  43         assert(objects[0] == ob);
  44         free(objects);
  45
  46         assert(xorn_selection_is_empty(rev, sel) == false);
  47 }
  48
  49 static void assert_selected_objects_2(
  50     xorn_revision_t rev, xorn_selection_t sel,
  51     xorn_object_t ob0, xorn_object_t ob1)
  52 {
  53         xorn_object_t *objects;
  54         size_t count;
  55
  56         assert(xorn_get_selected_objects(rev, sel, &objects, &count) == 0);
  57         assert(objects != NULL);
  58         assert(count == 2);
  59         assert((objects[0] == ob0 && objects[1] == ob1) ||
  60                (objects[0] == ob1 && objects[1] == ob0));
  61         free(objects);
  62
  63         assert(xorn_selection_is_empty(rev, sel) == false);
  64 }
  65
  66 static void assert_selected_objects_3(
  67     xorn_revision_t rev, xorn_selection_t sel,
  68     xorn_object_t ob0, xorn_object_t ob1, xorn_object_t ob2)
  69 {
  70         xorn_object_t *objects;
  71         size_t count;
  72
  73         assert(xorn_get_selected_objects(rev, sel, &objects, &count) == 0);
  74         assert(objects != NULL);
  75         assert(count == 3);
  76         assert(
  77             (objects[0] == ob0 && objects[1] == ob1 && objects[2] == ob2) ||
  78             (objects[0] == ob0 && objects[1] == ob2 && objects[2] == ob1) ||
  79             (objects[0] == ob1 && objects[1] == ob0 && objects[2] == ob2) ||
  80             (objects[0] == ob1 && objects[1] == ob2 && objects[2] == ob0) ||
  81             (objects[0] == ob2 && objects[1] == ob0 && objects[2] == ob1) ||
  82             (objects[0] == ob2 && objects[1] == ob1 && objects[2] == ob0));
  83         free(objects);
  84
  85         assert(xorn_selection_is_empty(rev, sel) == false);
  86 }
  87
  88 int main(void)
  89 {
  90         xorn_revision_t rev0, rev1, rev2, rev3;
  91         xorn_object_t ob0, ob1a, ob1b;
  92
  93         xorn_selection_t sel, sel1, sel2;
  94
  95         setup(&rev0, &rev1, &rev2, &rev3, &ob0, &ob1a, &ob1b);
  96
  97         /* select none */
  98
  99         sel = xorn_select_none();
 100         assert(sel != NULL);
 101         assert_selected_objects_0(rev0, sel);
 102         assert_selected_objects_0(rev1, sel);
 103         assert_selected_objects_0(rev2, sel);
 104         assert_selected_objects_0(rev3, sel);
 105         xorn_free_selection(sel);
 106
 107         /* select object */
 108
 109         sel = xorn_select_object(ob0);
 110         assert(sel != NULL);
 111         assert_selected_objects_0(rev0, sel);
 112         assert_selected_objects_1(rev1, sel, ob0);
 113         assert_selected_objects_1(rev2, sel, ob0);
 114         assert_selected_objects_1(rev3, sel, ob0);
 115         xorn_free_selection(sel);
 116
 117         sel = xorn_select_object(ob1a);
 118         assert(sel != NULL);
 119         assert_selected_objects_0(rev0, sel);
 120         assert_selected_objects_0(rev1, sel);
 121         assert_selected_objects_1(rev2, sel, ob1a);
 122         assert_selected_objects_0(rev3, sel);
 123         xorn_free_selection(sel);
 124
 125         sel = xorn_select_object(ob1b);
 126         assert(sel != NULL);
 127         assert_selected_objects_0(rev0, sel);
 128         assert_selected_objects_0(rev1, sel);
 129         assert_selected_objects_1(rev2, sel, ob1b);
 130         assert_selected_objects_1(rev3, sel, ob1b);
 131         xorn_free_selection(sel);
 132
 133         /* select all */
 134
 135         sel = xorn_select_all(rev0);
 136         assert(sel != NULL);
 137         assert_selected_objects_0(rev0, sel);
 138         assert_selected_objects_0(rev1, sel);
 139         assert_selected_objects_0(rev2, sel);
 140         assert_selected_objects_0(rev3, sel);
 141         xorn_free_selection(sel);
 142
 143         sel = xorn_select_all(rev1);
 144         assert(sel != NULL);
 145         assert_selected_objects_0(rev0, sel);
 146         assert_selected_objects_1(rev1, sel, ob0);
 147         assert_selected_objects_1(rev2, sel, ob0);
 148         assert_selected_objects_1(rev3, sel, ob0);
 149         xorn_free_selection(sel);
 150
 151         sel = xorn_select_all(rev2);
 152         assert(sel != NULL);
 153         assert_selected_objects_0(rev0, sel);
 154         assert_selected_objects_1(rev1, sel, ob0);
 155         assert_selected_objects_3(rev2, sel, ob0, ob1a, ob1b);
 156         assert_selected_objects_2(rev3, sel, ob0, ob1b);
 157         xorn_free_selection(sel);
 158
 159         sel = xorn_select_all(rev3);
 160         assert(sel != NULL);
 161         assert_selected_objects_0(rev0, sel);
 162         assert_selected_objects_1(rev1, sel, ob0);
 163         assert_selected_objects_2(rev2, sel, ob0, ob1b);
 164         assert_selected_objects_2(rev3, sel, ob0, ob1b);
 165         xorn_free_selection(sel);
 166
 167         /* select all except */
 168
 169         sel1 = xorn_select_none();
 170         assert(sel1 != NULL);
 171             sel = xorn_select_all_except(rev0, sel1);
 172             assert(sel != NULL);
 173             assert_selected_objects_0(rev0, sel);
 174             assert_selected_objects_0(rev1, sel);
 175             assert_selected_objects_0(rev2, sel);
 176             assert_selected_objects_0(rev3, sel);
 177             xorn_free_selection(sel);
 178
 179             sel = xorn_select_all_except(rev1, sel1);
 180             assert(sel != NULL);
 181             assert_selected_objects_0(rev0, sel);
 182             assert_selected_objects_1(rev1, sel, ob0);
 183             assert_selected_objects_1(rev2, sel, ob0);
 184             assert_selected_objects_1(rev3, sel, ob0);
 185             xorn_free_selection(sel);
 186
 187             sel = xorn_select_all_except(rev2, sel1);
 188             assert(sel != NULL);
 189             assert_selected_objects_0(rev0, sel);
 190             assert_selected_objects_1(rev1, sel, ob0);
 191             assert_selected_objects_3(rev2, sel, ob0, ob1a, ob1b);
 192             assert_selected_objects_2(rev3, sel, ob0, ob1b);
 193             xorn_free_selection(sel);
 194
 195             sel = xorn_select_all_except(rev3, sel1);
 196             assert(sel != NULL);
 197             assert_selected_objects_0(rev0, sel);
 198             assert_selected_objects_1(rev1, sel, ob0);
 199             assert_selected_objects_2(rev2, sel, ob0, ob1b);
 200             assert_selected_objects_2(rev3, sel, ob0, ob1b);
 201             xorn_free_selection(sel);
 202         xorn_free_selection(sel1);
 203
 204         sel1 = xorn_select_object(ob0);
 205         assert(sel1 != NULL);
 206             sel = xorn_select_all_except(rev0, sel1);
 207             assert(sel != NULL);
 208             assert_selected_objects_0(rev0, sel);
 209             assert_selected_objects_0(rev1, sel);
 210             assert_selected_objects_0(rev2, sel);
 211             assert_selected_objects_0(rev3, sel);
 212             xorn_free_selection(sel);
 213
 214             sel = xorn_select_all_except(rev1, sel1);
 215             assert(sel != NULL);
 216             assert_selected_objects_0(rev0, sel);
 217             assert_selected_objects_0(rev1, sel);
 218             assert_selected_objects_0(rev2, sel);
 219             assert_selected_objects_0(rev3, sel);
 220             xorn_free_selection(sel);
 221
 222             sel = xorn_select_all_except(rev2, sel1);
 223             assert(sel != NULL);
 224             assert_selected_objects_0(rev0, sel);
 225             assert_selected_objects_0(rev1, sel);
 226             assert_selected_objects_2(rev2, sel, ob1a, ob1b);
 227             assert_selected_objects_1(rev3, sel, ob1b);
 228             xorn_free_selection(sel);
 229
 230             sel = xorn_select_all_except(rev3, sel1);
 231             assert(sel != NULL);
 232             assert_selected_objects_0(rev0, sel);
 233             assert_selected_objects_0(rev1, sel);
 234             assert_selected_objects_1(rev2, sel, ob1b);
 235             assert_selected_objects_1(rev3, sel, ob1b);
 236             xorn_free_selection(sel);
 237         xorn_free_selection(sel1);
 238
 239         sel1 = xorn_select_all(rev3);
 240         assert(sel1 != NULL);
 241             sel = xorn_select_all_except(rev0, sel1);
 242             assert(sel != NULL);
 243             assert_selected_objects_0(rev0, sel);
 244             assert_selected_objects_0(rev1, sel);
 245             assert_selected_objects_0(rev2, sel);
 246             assert_selected_objects_0(rev3, sel);
 247             xorn_free_selection(sel);
 248
 249             sel = xorn_select_all_except(rev1, sel1);
 250             assert(sel != NULL);
 251             assert_selected_objects_0(rev0, sel);
 252             assert_selected_objects_0(rev1, sel);
 253             assert_selected_objects_0(rev2, sel);
 254             assert_selected_objects_0(rev3, sel);
 255             xorn_free_selection(sel);
 256
 257             sel = xorn_select_all_except(rev2, sel1);
 258             assert(sel != NULL);
 259             assert_selected_objects_0(rev0, sel);
 260             assert_selected_objects_0(rev1, sel);
 261             assert_selected_objects_1(rev2, sel, ob1a);
 262             assert_selected_objects_0(rev3, sel);
 263             xorn_free_selection(sel);
 264
 265             sel = xorn_select_all_except(rev3, sel1);
 266             assert(sel != NULL);
 267             assert_selected_objects_0(rev0, sel);
 268             assert_selected_objects_0(rev1, sel);
 269             assert_selected_objects_0(rev2, sel);
 270             assert_selected_objects_0(rev3, sel);
 271             xorn_free_selection(sel);
 272         xorn_free_selection(sel1);
 273
 274         /* select including */
 275
 276         sel1 = xorn_select_all(rev3);
 277         assert(sel1 != NULL);
 278             sel = xorn_select_including(sel1, ob0);
 279             assert(sel != NULL);
 280             assert_selected_objects_0(rev0, sel);
 281             assert_selected_objects_1(rev1, sel, ob0);
 282             assert_selected_objects_2(rev2, sel, ob0, ob1b);
 283             assert_selected_objects_2(rev3, sel, ob0, ob1b);
 284             xorn_free_selection(sel);
 285
 286             sel = xorn_select_including(sel1, ob1a);
 287             assert(sel != NULL);
 288             assert_selected_objects_0(rev0, sel);
 289             assert_selected_objects_1(rev1, sel, ob0);
 290             assert_selected_objects_3(rev2, sel, ob0, ob1a, ob1b);
 291             assert_selected_objects_2(rev3, sel, ob0, ob1b);
 292             xorn_free_selection(sel);
 293
 294             sel = xorn_select_including(sel1, ob1b);
 295             assert(sel != NULL);
 296             assert_selected_objects_0(rev0, sel);
 297             assert_selected_objects_1(rev1, sel, ob0);
 298             assert_selected_objects_2(rev2, sel, ob0, ob1b);
 299             assert_selected_objects_2(rev3, sel, ob0, ob1b);
 300             xorn_free_selection(sel);
 301         xorn_free_selection(sel1);
 302
 303         /* select excluding */
 304
 305         sel1 = xorn_select_all(rev3);
 306         assert(sel1 != NULL);
 307             sel = xorn_select_excluding(sel1, ob0);
 308             assert(sel != NULL);
 309             assert_selected_objects_0(rev0, sel);
 310             assert_selected_objects_0(rev1, sel);
 311             assert_selected_objects_1(rev2, sel, ob1b);
 312             assert_selected_objects_1(rev3, sel, ob1b);
 313             xorn_free_selection(sel);
 314
 315             sel = xorn_select_excluding(sel1, ob1a);
 316             assert(sel != NULL);
 317             assert_selected_objects_0(rev0, sel);
 318             assert_selected_objects_1(rev1, sel, ob0);
 319             assert_selected_objects_2(rev2, sel, ob0, ob1b);
 320             assert_selected_objects_2(rev3, sel, ob0, ob1b);
 321             xorn_free_selection(sel);
 322
 323             sel = xorn_select_excluding(sel1, ob1b);
 324             assert(sel != NULL);
 325             assert_selected_objects_0(rev0, sel);
 326             assert_selected_objects_1(rev1, sel, ob0);
 327             assert_selected_objects_1(rev2, sel, ob0);
 328             assert_selected_objects_1(rev3, sel, ob0);
 329             xorn_free_selection(sel);
 330         xorn_free_selection(sel1);
 331
 332         /* select union */
 333
 334         sel1 = xorn_select_all(rev1);
 335         assert(sel1 != NULL);
 336             sel2 = xorn_select_none();
 337             assert(sel2 != NULL);
 338             sel = xorn_select_union(sel1, sel2);
 339             assert(sel != NULL);
 340             assert_selected_objects_1(rev2, sel, ob0);
 341             xorn_free_selection(sel);
 342             xorn_free_selection(sel2);
 343
 344             sel2 = xorn_select_object(ob1a);
 345             assert(sel2 != NULL);
 346             sel = xorn_select_union(sel1, sel2);
 347             assert(sel != NULL);
 348             assert_selected_objects_2(rev2, sel, ob0, ob1a);
 349             xorn_free_selection(sel);
 350             xorn_free_selection(sel2);
 351
 352             sel2 = xorn_select_all(rev2);
 353             assert(sel2 != NULL);
 354             sel = xorn_select_union(sel1, sel2);
 355             assert(sel != NULL);
 356             assert_selected_objects_3(rev2, sel, ob0, ob1a, ob1b);
 357             xorn_free_selection(sel);
 358             xorn_free_selection(sel2);
 359
 360             sel2 = xorn_select_all(rev3);
 361             assert(sel2 != NULL);
 362             sel = xorn_select_union(sel1, sel2);
 363             assert(sel != NULL);
 364             assert_selected_objects_2(rev2, sel, ob0, ob1b);
 365             xorn_free_selection(sel);
 366             xorn_free_selection(sel2);
 367         sel2 = xorn_select_all_except(rev2, sel1);
 368         assert(sel2 != NULL);
 369         xorn_free_selection(sel1);
 370         sel1 = sel2;
 371             sel2 = xorn_select_none();
 372             assert(sel2 != NULL);
 373             sel = xorn_select_union(sel1, sel2);
 374             assert(sel != NULL);
 375             assert_selected_objects_2(rev2, sel, ob1a, ob1b);
 376             xorn_free_selection(sel);
 377             xorn_free_selection(sel2);
 378
 379             sel2 = xorn_select_object(ob1a);
 380             assert(sel2 != NULL);
 381             sel = xorn_select_union(sel1, sel2);
 382             assert(sel != NULL);
 383             assert_selected_objects_2(rev2, sel, ob1a, ob1b);
 384             xorn_free_selection(sel);
 385             xorn_free_selection(sel2);
 386
 387             sel2 = xorn_select_all(rev2);
 388             assert(sel2 != NULL);
 389             sel = xorn_select_union(sel1, sel2);
 390             assert(sel != NULL);
 391             assert_selected_objects_3(rev2, sel, ob0, ob1a, ob1b);
 392             xorn_free_selection(sel);
 393             xorn_free_selection(sel2);
 394
 395             sel2 = xorn_select_all(rev3);
 396             assert(sel2 != NULL);
 397             sel = xorn_select_union(sel1, sel2);
 398             assert(sel != NULL);
 399             assert_selected_objects_3(rev2, sel, ob0, ob1a, ob1b);
 400             xorn_free_selection(sel);
 401             xorn_free_selection(sel2);
 402         xorn_free_selection(sel1);
 403
 404         /* select intersection */
 405
 406         sel1 = xorn_select_all(rev1);
 407         assert(sel1 != NULL);
 408             sel2 = xorn_select_none();
 409             assert(sel2 != NULL);
 410             sel = xorn_select_intersection(sel1, sel2);
 411             assert(sel != NULL);
 412             assert_selected_objects_0(rev2, sel);
 413             xorn_free_selection(sel);
 414             xorn_free_selection(sel2);
 415
 416             sel2 = xorn_select_object(ob1a);
 417             assert(sel2 != NULL);
 418             sel = xorn_select_intersection(sel1, sel2);
 419             assert(sel != NULL);
 420             assert_selected_objects_0(rev2, sel);
 421             xorn_free_selection(sel);
 422             xorn_free_selection(sel2);
 423
 424             sel2 = xorn_select_all(rev2);
 425             assert(sel2 != NULL);
 426             sel = xorn_select_intersection(sel1, sel2);
 427             assert(sel != NULL);
 428             assert_selected_objects_1(rev2, sel, ob0);
 429             xorn_free_selection(sel);
 430             xorn_free_selection(sel2);
 431
 432             sel2 = xorn_select_all(rev3);
 433             assert(sel2 != NULL);
 434             sel = xorn_select_intersection(sel1, sel2);
 435             assert(sel != NULL);
 436             assert_selected_objects_1(rev2, sel, ob0);
 437             xorn_free_selection(sel);
 438             xorn_free_selection(sel2);
 439         sel2 = xorn_select_all_except(rev2, sel1);
 440         assert(sel2 != NULL);
 441         xorn_free_selection(sel1);
 442         sel1 = sel2;
 443             sel2 = xorn_select_none();
 444             assert(sel2 != NULL);
 445             sel = xorn_select_intersection(sel1, sel2);
 446             assert(sel != NULL);
 447             assert_selected_objects_0(rev2, sel);
 448             xorn_free_selection(sel);
 449             xorn_free_selection(sel2);
 450
 451             sel2 = xorn_select_object(ob1a);
 452             assert(sel2 != NULL);
 453             sel = xorn_select_intersection(sel1, sel2);
 454             assert(sel != NULL);
 455             assert_selected_objects_1(rev2, sel, ob1a);
 456             xorn_free_selection(sel);
 457             xorn_free_selection(sel2);
 458
 459             sel2 = xorn_select_all(rev2);
 460             assert(sel2 != NULL);
 461             sel = xorn_select_intersection(sel1, sel2);
 462             assert(sel != NULL);
 463             assert_selected_objects_2(rev2, sel, ob1a, ob1b);
 464             xorn_free_selection(sel);
 465             xorn_free_selection(sel2);
 466
 467             sel2 = xorn_select_all(rev3);
 468             assert(sel2 != NULL);
 469             sel = xorn_select_intersection(sel1, sel2);
 470             assert(sel != NULL);
 471             assert_selected_objects_1(rev2, sel, ob1b);
 472             xorn_free_selection(sel);
 473             xorn_free_selection(sel2);
 474         xorn_free_selection(sel1);
 475
 476         /* select difference */
 477
 478         sel1 = xorn_select_all(rev1);
 479         assert(sel1 != NULL);
 480             sel2 = xorn_select_none();
 481             assert(sel2 != NULL);
 482             sel = xorn_select_difference(sel1, sel2);
 483             assert(sel != NULL);
 484             assert_selected_objects_1(rev2, sel, ob0);
 485             xorn_free_selection(sel);
 486             xorn_free_selection(sel2);
 487
 488             sel2 = xorn_select_object(ob1a);
 489             assert(sel2 != NULL);
 490             sel = xorn_select_difference(sel1, sel2);
 491             assert(sel != NULL);
 492             assert_selected_objects_1(rev2, sel, ob0);
 493             xorn_free_selection(sel);
 494             xorn_free_selection(sel2);
 495
 496             sel2 = xorn_select_all(rev2);
 497             assert(sel2 != NULL);
 498             sel = xorn_select_difference(sel1, sel2);
 499             assert(sel != NULL);
 500             assert_selected_objects_0(rev2, sel);
 501             xorn_free_selection(sel);
 502             xorn_free_selection(sel2);
 503
 504             sel2 = xorn_select_all(rev3);
 505             assert(sel2 != NULL);
 506             sel = xorn_select_difference(sel1, sel2);
 507             assert(sel != NULL);
 508             assert_selected_objects_0(rev2, sel);
 509             xorn_free_selection(sel);
 510             xorn_free_selection(sel2);
 511         sel2 = xorn_select_all_except(rev2, sel1);
 512         assert(sel2 != NULL);
 513         xorn_free_selection(sel1);
 514         sel1 = sel2;
 515             sel2 = xorn_select_none();
 516             assert(sel2 != NULL);
 517             sel = xorn_select_difference(sel1, sel2);
 518             assert(sel != NULL);
 519             assert_selected_objects_2(rev2, sel, ob1a, ob1b);
 520             xorn_free_selection(sel);
 521             xorn_free_selection(sel2);
 522
 523             sel2 = xorn_select_object(ob1a);
 524             assert(sel2 != NULL);
 525             sel = xorn_select_difference(sel1, sel2);
 526             assert(sel != NULL);
 527             assert_selected_objects_1(rev2, sel, ob1b);
 528             xorn_free_selection(sel);
 529             xorn_free_selection(sel2);
 530
 531             sel2 = xorn_select_all(rev2);
 532             assert(sel2 != NULL);
 533             sel = xorn_select_difference(sel1, sel2);
 534             assert(sel != NULL);
 535             assert_selected_objects_0(rev2, sel);
 536             xorn_free_selection(sel);
 537             xorn_free_selection(sel2);
 538
 539             sel2 = xorn_select_all(rev3);
 540             assert(sel2 != NULL);
 541             sel = xorn_select_difference(sel1, sel2);
 542             assert(sel != NULL);
 543             assert_selected_objects_1(rev2, sel, ob1a);
 544             xorn_free_selection(sel);
 545             xorn_free_selection(sel2);
 546         xorn_free_selection(sel1);
 547
 548         xorn_free_revision(rev3);
 549         xorn_free_revision(rev2);
 550         xorn_free_revision(rev1);
 551         xorn_free_revision(rev0);
 552         return 0;
 553 }