vendor/merge/tests/derive.rs

   1 // SPDX-FileCopyrightText: 2020 Robin Krahl <robin.krahl@ireas.org>
   2 // SPDX-License-Identifier: Apache-2.0 or MIT
   3
   4 #![cfg(feature = "derive")]
   5
   6 use merge::Merge;
   7
   8 fn test<T: std::fmt::Debug + Merge + PartialEq>(expected: T, mut left: T, right: T) {
   9     left.merge(right);
  10     assert_eq!(expected, left);
  11 }
  12
  13 #[test]
  14 fn test_one_option_field() {
  15     #[derive(Debug, Merge, PartialEq)]
  16     struct S {
  17         field1: Option<usize>,
  18     }
  19
  20     impl S {
  21         pub fn new(field1: Option<usize>) -> S {
  22             S { field1 }
  23         }
  24     }
  25
  26     test(S::new(Some(1)), S::new(Some(1)), S::new(Some(2)));
  27     test(S::new(Some(1)), S::new(Some(1)), S::new(None));
  28     test(S::new(Some(2)), S::new(None), S::new(Some(2)));
  29     test(S::new(None), S::new(None), S::new(None));
  30 }
  31
  32 #[test]
  33 fn test_two_option_fields() {
  34     #[derive(Debug, Merge, PartialEq)]
  35     struct S {
  36         field1: Option<usize>,
  37         field2: Option<usize>,
  38     }
  39
  40     impl S {
  41         pub fn new(field1: Option<usize>, field2: Option<usize>) -> S {
  42             S { field1, field2 }
  43         }
  44     }
  45
  46     // left.field1 == Some(1)
  47     // right.field1 == Some(2)
  48     test(
  49         S::new(Some(1), Some(1)),
  50         S::new(Some(1), Some(1)),
  51         S::new(Some(2), Some(2)),
  52     );
  53     test(
  54         S::new(Some(1), Some(1)),
  55         S::new(Some(1), Some(1)),
  56         S::new(Some(2), None),
  57     );
  58     test(
  59         S::new(Some(1), Some(2)),
  60         S::new(Some(1), None),
  61         S::new(Some(2), Some(2)),
  62     );
  63     test(
  64         S::new(Some(1), None),
  65         S::new(Some(1), None),
  66         S::new(Some(2), None),
  67     );
  68
  69     // left.field1 == Some(1)
  70     // right.field1 == None
  71     test(
  72         S::new(Some(1), Some(1)),
  73         S::new(Some(1), Some(1)),
  74         S::new(None, Some(2)),
  75     );
  76     test(
  77         S::new(Some(1), Some(1)),
  78         S::new(Some(1), Some(1)),
  79         S::new(None, None),
  80     );
  81     test(
  82         S::new(Some(1), Some(2)),
  83         S::new(Some(1), None),
  84         S::new(None, Some(2)),
  85     );
  86     test(
  87         S::new(Some(1), None),
  88         S::new(Some(1), None),
  89         S::new(None, None),
  90     );
  91
  92     // left.field1 == None
  93     // right.field1 == Some(2)
  94     test(
  95         S::new(Some(2), Some(1)),
  96         S::new(None, Some(1)),
  97         S::new(Some(2), Some(2)),
  98     );
  99     test(
 100         S::new(Some(2), Some(1)),
 101         S::new(None, Some(1)),
 102         S::new(Some(2), None),
 103     );
 104     test(
 105         S::new(Some(2), Some(2)),
 106         S::new(None, None),
 107         S::new(Some(2), Some(2)),
 108     );
 109     test(
 110         S::new(Some(2), None),
 111         S::new(None, None),
 112         S::new(Some(2), None),
 113     );
 114
 115     // left.field1 == None
 116     // right.field1 == None
 117     test(
 118         S::new(None, Some(1)),
 119         S::new(None, Some(1)),
 120         S::new(None, Some(2)),
 121     );
 122     test(
 123         S::new(None, Some(1)),
 124         S::new(None, Some(1)),
 125         S::new(None, None),
 126     );
 127     test(
 128         S::new(None, Some(2)),
 129         S::new(None, None),
 130         S::new(None, Some(2)),
 131     );
 132     test(S::new(None, None), S::new(None, None), S::new(None, None));
 133 }
 134
 135 #[test]
 136 fn test_skip_valid() {
 137     #[derive(Debug, Merge, PartialEq)]
 138     struct S {
 139         field1: Option<usize>,
 140         #[merge(skip)]
 141         field2: Option<usize>,
 142     }
 143
 144     impl S {
 145         pub fn new(field1: Option<usize>, field2: Option<usize>) -> S {
 146             S { field1, field2 }
 147         }
 148     }
 149
 150     // left.field1 == Some(1)
 151     // right.field1 == Some(2)
 152     test(
 153         S::new(Some(1), Some(1)),
 154         S::new(Some(1), Some(1)),
 155         S::new(Some(2), Some(2)),
 156     );
 157     test(
 158         S::new(Some(1), Some(1)),
 159         S::new(Some(1), Some(1)),
 160         S::new(Some(2), None),
 161     );
 162     test(
 163         S::new(Some(1), None),
 164         S::new(Some(1), None),
 165         S::new(Some(2), Some(2)),
 166     );
 167     test(
 168         S::new(Some(1), None),
 169         S::new(Some(1), None),
 170         S::new(Some(2), None),
 171     );
 172
 173     // left.field1 == Some(1)
 174     // right.field1 == None
 175     test(
 176         S::new(Some(1), Some(1)),
 177         S::new(Some(1), Some(1)),
 178         S::new(None, Some(2)),
 179     );
 180     test(
 181         S::new(Some(1), Some(1)),
 182         S::new(Some(1), Some(1)),
 183         S::new(None, None),
 184     );
 185     test(
 186         S::new(Some(1), None),
 187         S::new(Some(1), None),
 188         S::new(None, Some(2)),
 189     );
 190     test(
 191         S::new(Some(1), None),
 192         S::new(Some(1), None),
 193         S::new(None, None),
 194     );
 195
 196     // left.field1 == None
 197     // right.field1 == Some(2)
 198     test(
 199         S::new(Some(2), Some(1)),
 200         S::new(None, Some(1)),
 201         S::new(Some(2), Some(2)),
 202     );
 203     test(
 204         S::new(Some(2), Some(1)),
 205         S::new(None, Some(1)),
 206         S::new(Some(2), None),
 207     );
 208     test(
 209         S::new(Some(2), None),
 210         S::new(None, None),
 211         S::new(Some(2), Some(2)),
 212     );
 213     test(
 214         S::new(Some(2), None),
 215         S::new(None, None),
 216         S::new(Some(2), None),
 217     );
 218
 219     // left.field1 == None
 220     // right.field1 == None
 221     test(
 222         S::new(None, Some(1)),
 223         S::new(None, Some(1)),
 224         S::new(None, Some(2)),
 225     );
 226     test(
 227         S::new(None, Some(1)),
 228         S::new(None, Some(1)),
 229         S::new(None, None),
 230     );
 231     test(
 232         S::new(None, None),
 233         S::new(None, None),
 234         S::new(None, Some(2)),
 235     );
 236     test(S::new(None, None), S::new(None, None), S::new(None, None));
 237 }
 238
 239 #[test]
 240 fn test_skip_invalid() {
 241     #[derive(Debug, Merge, PartialEq)]
 242     struct S {
 243         field1: Option<usize>,
 244         #[merge(skip)]
 245         field2: usize,
 246     }
 247
 248     impl S {
 249         pub fn new(field1: Option<usize>, field2: usize) -> S {
 250             S { field1, field2 }
 251         }
 252     }
 253
 254     // left.field1 == Some(1)
 255     // right.field1 == Some(2)
 256     test(S::new(Some(1), 1), S::new(Some(1), 1), S::new(Some(2), 2));
 257     test(S::new(Some(1), 1), S::new(Some(1), 1), S::new(Some(2), 0));
 258     test(S::new(Some(1), 0), S::new(Some(1), 0), S::new(Some(2), 2));
 259     test(S::new(Some(1), 0), S::new(Some(1), 0), S::new(Some(2), 0));
 260
 261     // left.field1 == Some(1)
 262     // right.field1 == None
 263     test(S::new(Some(1), 1), S::new(Some(1), 1), S::new(None, 2));
 264     test(S::new(Some(1), 1), S::new(Some(1), 1), S::new(None, 0));
 265     test(S::new(Some(1), 0), S::new(Some(1), 0), S::new(None, 2));
 266     test(S::new(Some(1), 0), S::new(Some(1), 0), S::new(None, 0));
 267
 268     // left.field1 == None
 269     // right.field1 == Some(2)
 270     test(S::new(Some(2), 1), S::new(None, 1), S::new(Some(2), 2));
 271     test(S::new(Some(2), 1), S::new(None, 1), S::new(Some(2), 0));
 272     test(S::new(Some(2), 0), S::new(None, 0), S::new(Some(2), 2));
 273     test(S::new(Some(2), 0), S::new(None, 0), S::new(Some(2), 0));
 274
 275     // left.field1 == None
 276     // right.field1 == None
 277     test(S::new(None, 1), S::new(None, 1), S::new(None, 2));
 278     test(S::new(None, 1), S::new(None, 1), S::new(None, 0));
 279     test(S::new(None, 0), S::new(None, 0), S::new(None, 2));
 280     test(S::new(None, 0), S::new(None, 0), S::new(None, 0));
 281 }
 282
 283 #[test]
 284 fn test_strategy_usize_add() {
 285     #[derive(Debug, Merge, PartialEq)]
 286     struct S {
 287         #[merge(strategy = add)]
 288         field1: usize,
 289     }
 290
 291     impl S {
 292         pub fn new(field1: usize) -> S {
 293             S { field1 }
 294         }
 295     }
 296
 297     fn add(left: &mut usize, right: usize) {
 298         *left = *left + right;
 299     }
 300
 301     test(S::new(0), S::new(0), S::new(0));
 302     test(S::new(1), S::new(1), S::new(0));
 303     test(S::new(1), S::new(0), S::new(1));
 304     test(S::new(2), S::new(1), S::new(1));
 305 }
 306
 307 #[test]
 308 fn test_strategy_vec_append() {
 309     #[derive(Debug, Merge, PartialEq)]
 310     struct S {
 311         #[merge(strategy = append)]
 312         field1: Vec<usize>,
 313     }
 314
 315     impl S {
 316         pub fn new(field1: Vec<usize>) -> S {
 317             S { field1 }
 318         }
 319     }
 320
 321     fn append(left: &mut Vec<usize>, mut right: Vec<usize>) {
 322         left.append(&mut right);
 323     }
 324
 325     test(
 326         S::new(vec![0, 1, 2, 3]),
 327         S::new(vec![0, 1]),
 328         S::new(vec![2, 3]),
 329     );
 330     test(
 331         S::new(vec![0, 1, 2, 3]),
 332         S::new(vec![0, 1, 2, 3]),
 333         S::new(vec![]),
 334     );
 335     test(
 336         S::new(vec![0, 1, 2, 3]),
 337         S::new(vec![]),
 338         S::new(vec![0, 1, 2, 3]),
 339     );
 340 }
 341
 342 #[test]
 343 fn test_unnamed_fields() {
 344     #[derive(Debug, Merge, PartialEq)]
 345     struct S(Option<usize>, Option<usize>);
 346
 347     impl S {
 348         pub fn new(field1: Option<usize>, field2: Option<usize>) -> S {
 349             S(field1, field2)
 350         }
 351     }
 352
 353     // left.field1 == Some(1)
 354     // right.field1 == Some(2)
 355     test(
 356         S::new(Some(1), Some(1)),
 357         S::new(Some(1), Some(1)),
 358         S::new(Some(2), Some(2)),
 359     );
 360     test(
 361         S::new(Some(1), Some(1)),
 362         S::new(Some(1), Some(1)),
 363         S::new(Some(2), None),
 364     );
 365     test(
 366         S::new(Some(1), Some(2)),
 367         S::new(Some(1), None),
 368         S::new(Some(2), Some(2)),
 369     );
 370     test(
 371         S::new(Some(1), None),
 372         S::new(Some(1), None),
 373         S::new(Some(2), None),
 374     );
 375
 376     // left.field1 == Some(1)
 377     // right.field1 == None
 378     test(
 379         S::new(Some(1), Some(1)),
 380         S::new(Some(1), Some(1)),
 381         S::new(None, Some(2)),
 382     );
 383     test(
 384         S::new(Some(1), Some(1)),
 385         S::new(Some(1), Some(1)),
 386         S::new(None, None),
 387     );
 388     test(
 389         S::new(Some(1), Some(2)),
 390         S::new(Some(1), None),
 391         S::new(None, Some(2)),
 392     );
 393     test(
 394         S::new(Some(1), None),
 395         S::new(Some(1), None),
 396         S::new(None, None),
 397     );
 398
 399     // left.field1 == None
 400     // right.field1 == Some(2)
 401     test(
 402         S::new(Some(2), Some(1)),
 403         S::new(None, Some(1)),
 404         S::new(Some(2), Some(2)),
 405     );
 406     test(
 407         S::new(Some(2), Some(1)),
 408         S::new(None, Some(1)),
 409         S::new(Some(2), None),
 410     );
 411     test(
 412         S::new(Some(2), Some(2)),
 413         S::new(None, None),
 414         S::new(Some(2), Some(2)),
 415     );
 416     test(
 417         S::new(Some(2), None),
 418         S::new(None, None),
 419         S::new(Some(2), None),
 420     );
 421
 422     // left.field1 == None
 423     // right.field1 == None
 424     test(
 425         S::new(None, Some(1)),
 426         S::new(None, Some(1)),
 427         S::new(None, Some(2)),
 428     );
 429     test(
 430         S::new(None, Some(1)),
 431         S::new(None, Some(1)),
 432         S::new(None, None),
 433     );
 434     test(
 435         S::new(None, Some(2)),
 436         S::new(None, None),
 437         S::new(None, Some(2)),
 438     );
 439     test(S::new(None, None), S::new(None, None), S::new(None, None));
 440 }
 441
 442 #[test]
 443 fn test_unnamed_fields_skip() {
 444     #[derive(Debug, Merge, PartialEq)]
 445     struct S(Option<usize>, #[merge(skip)] Option<usize>);
 446
 447     impl S {
 448         pub fn new(field1: Option<usize>, field2: Option<usize>) -> S {
 449             S(field1, field2)
 450         }
 451     }
 452
 453     // left.field1 == Some(1)
 454     // right.field1 == Some(2)
 455     test(
 456         S::new(Some(1), Some(1)),
 457         S::new(Some(1), Some(1)),
 458         S::new(Some(2), Some(2)),
 459     );
 460     test(
 461         S::new(Some(1), Some(1)),
 462         S::new(Some(1), Some(1)),
 463         S::new(Some(2), None),
 464     );
 465     test(
 466         S::new(Some(1), None),
 467         S::new(Some(1), None),
 468         S::new(Some(2), Some(2)),
 469     );
 470     test(
 471         S::new(Some(1), None),
 472         S::new(Some(1), None),
 473         S::new(Some(2), None),
 474     );
 475
 476     // left.field1 == Some(1)
 477     // right.field1 == None
 478     test(
 479         S::new(Some(1), Some(1)),
 480         S::new(Some(1), Some(1)),
 481         S::new(None, Some(2)),
 482     );
 483     test(
 484         S::new(Some(1), Some(1)),
 485         S::new(Some(1), Some(1)),
 486         S::new(None, None),
 487     );
 488     test(
 489         S::new(Some(1), None),
 490         S::new(Some(1), None),
 491         S::new(None, Some(2)),
 492     );
 493     test(
 494         S::new(Some(1), None),
 495         S::new(Some(1), None),
 496         S::new(None, None),
 497     );
 498
 499     // left.field1 == None
 500     // right.field1 == Some(2)
 501     test(
 502         S::new(Some(2), Some(1)),
 503         S::new(None, Some(1)),
 504         S::new(Some(2), Some(2)),
 505     );
 506     test(
 507         S::new(Some(2), Some(1)),
 508         S::new(None, Some(1)),
 509         S::new(Some(2), None),
 510     );
 511     test(
 512         S::new(Some(2), None),
 513         S::new(None, None),
 514         S::new(Some(2), Some(2)),
 515     );
 516     test(
 517         S::new(Some(2), None),
 518         S::new(None, None),
 519         S::new(Some(2), None),
 520     );
 521
 522     // left.field1 == None
 523     // right.field1 == None
 524     test(
 525         S::new(None, Some(1)),
 526         S::new(None, Some(1)),
 527         S::new(None, Some(2)),
 528     );
 529     test(
 530         S::new(None, Some(1)),
 531         S::new(None, Some(1)),
 532         S::new(None, None),
 533     );
 534     test(
 535         S::new(None, None),
 536         S::new(None, None),
 537         S::new(None, Some(2)),
 538     );
 539     test(S::new(None, None), S::new(None, None), S::new(None, None));
 540 }