binding/mdsal-binding-test-model/src/main/yang/opendaylight-default-value-test.yang

   1 module opendaylight-default-value-test {
   2     namespace "urn:opendaylight:params:xml:ns:default:value:test";
   3     prefix "def-val-test";
   4
   5     import opendaylight-default-value-test-2 {
   6         prefix def-val-test-2;
   7         revision-date 2016-01-11;
   8     }
   9
  10     typedef tiny-signed-integer {
  11         type int8 {
  12             range "-20..-1";
  13         }
  14         default "-18";
  15     }
  16
  17     typedef derived-tiny-signed-integer {
  18         type tiny-signed-integer;
  19     }
  20
  21     typedef derived-tiny-signed-integer2 {
  22         type tiny-signed-integer {
  23             range "-16..-11";
  24         }
  25         default "-15";
  26     }
  27
  28     typedef derived-tiny-signed-integer3 {
  29         type derived-tiny-signed-integer;
  30     }
  31
  32     typedef small-signed-integer {
  33         type int16 {
  34             range "-25000..-9000";
  35         }
  36         default "-20000";
  37     }
  38
  39     typedef derived-small-signed-integer {
  40         type small-signed-integer;
  41     }
  42
  43     typedef derived-small-signed-integer2 {
  44         type small-signed-integer {
  45             range "-19000..-11000";
  46         }
  47         default "-15000";
  48     }
  49
  50     typedef derived-small-signed-integer3 {
  51         type derived-small-signed-integer;
  52     }
  53
  54     typedef normal-signed-integer {
  55         type int32 {
  56             range "-250000..-50000";
  57         }
  58         default "-200000";
  59     }
  60
  61     typedef derived-normal-signed-integer {
  62         type normal-signed-integer;
  63     }
  64
  65     typedef derived-normal-signed-integer2 {
  66         type normal-signed-integer {
  67             range "-140000..-120000";
  68         }
  69         default "-130000";
  70     }
  71
  72     typedef derived-normal-signed-integer3 {
  73         type derived-normal-signed-integer;
  74     }
  75
  76     typedef big-signed-integer {
  77         type int64 {
  78             range "-3500000000..-2500000000";
  79         }
  80         default "-3300000000";
  81     }
  82
  83     typedef derived-big-signed-integer {
  84         type big-signed-integer;
  85     }
  86
  87     typedef derived-big-signed-integer2 {
  88         type big-signed-integer {
  89             range "-3100000000..-2600000000";
  90         }
  91         default "-2800000000";
  92     }
  93
  94     typedef derived-big-signed-integer3 {
  95         type derived-big-signed-integer;
  96     }
  97
  98     typedef tiny-unsigned-integer {
  99         type uint8 {
 100             range "15..220";
 101         }
 102         default "150";
 103     }
 104
 105     typedef derived-tiny-unsigned-integer {
 106         type tiny-unsigned-integer;
 107     }
 108
 109     typedef derived-tiny-unsigned-integer2 {
 110         type tiny-unsigned-integer {
 111             range "160..190";
 112         }
 113         default "170";
 114     }
 115
 116     typedef derived-tiny-unsigned-integer3 {
 117         type derived-tiny-unsigned-integer;
 118     }
 119
 120     typedef small-unsigned-integer {
 121         type uint16 {
 122             range "9000..60000";
 123         }
 124         default "35000";
 125     }
 126
 127     typedef derived-small-unsigned-integer {
 128         type small-unsigned-integer;
 129     }
 130
 131     typedef derived-small-unsigned-integer2 {
 132         type small-unsigned-integer {
 133             range "40000..55000";
 134         }
 135         default "45000";
 136     }
 137
 138     typedef derived-small-unsigned-integer3 {
 139         type derived-small-unsigned-integer;
 140     }
 141
 142     typedef normal-unsigned-integer {
 143         type uint32 {
 144             range "70000..4200000000";
 145         }
 146         default "100000";
 147     }
 148
 149     typedef derived-normal-unsigned-integer {
 150         type normal-unsigned-integer;
 151     }
 152
 153     typedef derived-normal-unsigned-integer2 {
 154         type normal-unsigned-integer {
 155             range "150000..3500000000";
 156         }
 157         default "250000";
 158     }
 159
 160     typedef derived-normal-unsigned-integer3 {
 161         type derived-normal-unsigned-integer;
 162     }
 163
 164     typedef big-unsigned-integer {
 165         type uint64 {
 166             range "4500000000..6500000000";
 167         }
 168         default "5000000000";
 169     }
 170
 171     typedef derived-big-unsigned-integer {
 172         type big-unsigned-integer;
 173     }
 174
 175     typedef derived-big-unsigned-integer2 {
 176         type big-unsigned-integer {
 177             range "5500000000..6200000000";
 178         }
 179         default "5800000000";
 180     }
 181
 182     typedef derived-big-unsigned-integer3 {
 183         type derived-big-unsigned-integer;
 184     }
 185
 186     typedef my-decimal {
 187         type decimal64 {
 188             fraction-digits 2;
 189             range "5.55 .. 150.55";
 190         }
 191         default "66.66";
 192     }
 193
 194     typedef my-derived-decimal {
 195         type my-decimal;
 196     }
 197
 198     typedef my-derived-decimal2 {
 199         type my-decimal {
 200             fraction-digits 2;
 201             range "77.77 .. 111.11";
 202         }
 203         default "99.99";
 204     }
 205
 206     typedef my-derived-decimal3 {
 207         type my-derived-decimal;
 208     }
 209
 210     typedef my-string {
 211         type string {
 212             length "1..30";
 213             pattern "[a-zA-Z ]+";
 214         }
 215         default "unspecified string";
 216     }
 217
 218     typedef my-derived-string {
 219         type my-string;
 220     }
 221
 222     typedef my-derived-string2 {
 223         type my-string {
 224             length "5..15";
 225             pattern "[a-z]+";
 226         }
 227         default "unknown";
 228     }
 229
 230     typedef my-derived-string3 {
 231         type my-derived-string;
 232     }
 233
 234     typedef my-enumeration {
 235         type enumeration {
 236             enum first {
 237                 value 1;
 238             }
 239             enum second {
 240                 value 2;
 241             }
 242             enum third {
 243                 value 3;
 244             }
 245         }
 246         default "second";
 247     }
 248
 249     typedef my-bits {
 250         type bits {
 251             bit bit-zero {
 252                 position 0;
 253             }
 254             bit bit-one {
 255                 position 1;
 256             }
 257             bit bit-two {
 258                 position 2;
 259             }
 260         }
 261         default "bit-one";
 262     }
 263
 264     identity my-identity {
 265         description "parent identity for testing purposes";
 266     }
 267
 268     identity my-derived-identity {
 269         base my-identity;
 270         description "child identity for testing purposes";
 271     }
 272
 273     identity my-derived-identity2 {
 274         base my-derived-identity;
 275         description "another child identity for testing purposes";
 276     }
 277
 278     typedef my-identityref {
 279         type identityref {
 280             base my-identity;
 281         }
 282     }
 283
 284     typedef my-identityref2 {
 285         type identityref {
 286             base my-identity;
 287         }
 288         default "my-derived-identity";
 289     }
 290
 291     container tiny-int-container {
 292         presence "presence container";
 293
 294         leaf tiny-int-leaf {
 295             type tiny-signed-integer;
 296         }
 297
 298         leaf tiny-int-leaf2 {
 299             type derived-tiny-signed-integer;
 300         }
 301
 302         leaf tiny-int-leaf3 {
 303             type derived-tiny-signed-integer2;
 304         }
 305
 306         leaf tiny-int-leaf4 {
 307             type derived-tiny-signed-integer3;
 308         }
 309
 310         leaf tiny-int-leaf5 {
 311             type int8;
 312             default "-120";
 313         }
 314
 315         leaf tiny-int-leaf6 {
 316             type int8;
 317         }
 318     }
 319
 320     container small-int-container {
 321         presence "presence container";
 322
 323         leaf small-int-leaf {
 324             type small-signed-integer;
 325         }
 326
 327         leaf small-int-leaf2 {
 328             type derived-small-signed-integer;
 329         }
 330
 331         leaf small-int-leaf3 {
 332             type derived-small-signed-integer2;
 333         }
 334
 335         leaf small-int-leaf4 {
 336             type derived-small-signed-integer3;
 337         }
 338
 339         leaf small-int-leaf5 {
 340             type int16;
 341             default "-5000";
 342         }
 343
 344         leaf small-int-leaf6 {
 345             type int16;
 346         }
 347     }
 348
 349     container normal-int-container {
 350         presence "presence container";
 351
 352         leaf normal-int-leaf {
 353             type normal-signed-integer;
 354         }
 355
 356         leaf normal-int-leaf2 {
 357             type derived-normal-signed-integer;
 358         }
 359
 360         leaf normal-int-leaf3 {
 361             type derived-normal-signed-integer2;
 362         }
 363
 364         leaf normal-int-leaf4 {
 365             type derived-normal-signed-integer3;
 366         }
 367
 368         leaf normal-int-leaf5 {
 369             type int32;
 370             default "-95000";
 371         }
 372
 373         leaf normal-int-leaf6 {
 374             type int32;
 375         }
 376     }
 377
 378     container big-int-container {
 379         presence "presence container";
 380
 381         leaf big-int-leaf {
 382             type big-signed-integer;
 383         }
 384
 385         leaf big-int-leaf2 {
 386             type derived-big-signed-integer;
 387         }
 388
 389         leaf big-int-leaf3 {
 390             type derived-big-signed-integer2;
 391         }
 392
 393         leaf big-int-leaf4 {
 394             type derived-big-signed-integer3;
 395         }
 396
 397         leaf big-int-leaf5 {
 398             type int64;
 399             default "-2500000000";
 400         }
 401
 402         leaf big-int-leaf6 {
 403             type int64;
 404         }
 405     }
 406
 407     container tiny-uint-container {
 408         presence "presence container";
 409
 410         leaf tiny-uint-leaf {
 411             type tiny-unsigned-integer;
 412         }
 413
 414         leaf tiny-uint-leaf2 {
 415             type derived-tiny-unsigned-integer;
 416         }
 417
 418         leaf tiny-uint-leaf3 {
 419             type derived-tiny-unsigned-integer2;
 420         }
 421
 422         leaf tiny-uint-leaf4 {
 423             type derived-tiny-unsigned-integer3;
 424         }
 425
 426         leaf tiny-uint-leaf5 {
 427             type uint8;
 428             default "155";
 429         }
 430
 431         leaf tiny-uint-leaf6 {
 432             type uint8;
 433         }
 434     }
 435
 436     container small-uint-container {
 437         presence "presence container";
 438
 439         leaf small-uint-leaf {
 440             type small-unsigned-integer;
 441         }
 442
 443         leaf small-uint-leaf2 {
 444             type derived-small-unsigned-integer;
 445         }
 446
 447         leaf small-uint-leaf3 {
 448             type derived-small-unsigned-integer2;
 449         }
 450
 451         leaf small-uint-leaf4 {
 452             type derived-small-unsigned-integer3;
 453         }
 454
 455         leaf small-uint-leaf5 {
 456             type uint16;
 457             default "62000";
 458         }
 459
 460         leaf small-uint-leaf6 {
 461             type uint16;
 462         }
 463     }
 464
 465     container normal-uint-container {
 466         presence "presence container";
 467
 468         leaf normal-uint-leaf {
 469             type normal-unsigned-integer;
 470         }
 471
 472         leaf normal-uint-leaf2 {
 473             type derived-normal-unsigned-integer;
 474         }
 475
 476         leaf normal-uint-leaf3 {
 477             type derived-normal-unsigned-integer2;
 478         }
 479
 480         leaf normal-uint-leaf4 {
 481             type derived-normal-unsigned-integer3;
 482         }
 483
 484         leaf normal-uint-leaf5 {
 485             type uint32;
 486             default "150000";
 487         }
 488
 489         leaf normal-uint-leaf6 {
 490             type uint32;
 491         }
 492     }
 493
 494     container big-uint-container {
 495         presence "presence container";
 496
 497         leaf big-uint-leaf {
 498             type big-unsigned-integer;
 499         }
 500
 501         leaf big-uint-leaf2 {
 502             type derived-big-unsigned-integer;
 503         }
 504
 505         leaf big-uint-leaf3 {
 506             type derived-big-unsigned-integer2;
 507         }
 508
 509         leaf big-uint-leaf4 {
 510             type derived-big-unsigned-integer3;
 511         }
 512
 513         leaf big-uint-leaf5 {
 514             type uint64;
 515             default "6500000000";
 516         }
 517
 518         leaf big-uint-leaf6 {
 519             type uint64;
 520         }
 521     }
 522
 523     container decimal-container {
 524         presence "presence container";
 525
 526         leaf decimal-leaf {
 527             type my-decimal;
 528         }
 529
 530         leaf decimal-leaf2 {
 531             type my-derived-decimal;
 532         }
 533
 534         leaf decimal-leaf3 {
 535             type my-derived-decimal2;
 536         }
 537
 538         leaf decimal-leaf4 {
 539             type my-derived-decimal3;
 540         }
 541
 542         leaf decimal-leaf5 {
 543             type decimal64 {
 544                 fraction-digits 2;
 545             }
 546             default "120.55";
 547         }
 548
 549         leaf decimal-leaf6 {
 550             type decimal64 {
 551                 fraction-digits 3;
 552             }
 553         }
 554     }
 555
 556     container string-container {
 557         presence "presence container";
 558
 559         leaf string-leaf {
 560             type my-string;
 561         }
 562
 563         leaf string-leaf2 {
 564             type my-derived-string;
 565         }
 566
 567         leaf string-leaf3 {
 568             type my-derived-string2;
 569         }
 570
 571         leaf string-leaf4 {
 572             type my-derived-string3;
 573         }
 574
 575         leaf string-leaf5 {
 576             type string;
 577             default "whatever";
 578         }
 579
 580         leaf string-leaf6 {
 581             type string;
 582         }
 583     }
 584
 585     container boolean-container {
 586         presence "presence container";
 587
 588         leaf boolean-leaf {
 589             type boolean;
 590             default "true";
 591         }
 592
 593         leaf boolean-leaf2 {
 594             type boolean;
 595         }
 596     }
 597
 598     container enum-container {
 599         presence "presence container";
 600
 601         leaf enum-leaf {
 602             type my-enumeration;
 603         }
 604     }
 605
 606     container bits-container {
 607         presence "presence container";
 608
 609         leaf bits-leaf {
 610             type my-bits;
 611         }
 612
 613         leaf bits-leaf2 {
 614             type bits {
 615                 bit disable-nagle {
 616                     position 0;
 617                 }
 618                 bit auto-sense-speed {
 619                     position 1;
 620                 }
 621                 bit 10-Mb-only {
 622                     position 2;
 623                 }
 624             }
 625         }
 626     }
 627
 628     container binary-container {
 629         presence "presence container";
 630
 631         leaf binary-leaf {
 632             type binary;
 633             default "aGVsbG8=";
 634         }
 635
 636         leaf binary-leaf2 {
 637             type binary;
 638         }
 639     }
 640
 641     container identityref-container {
 642         presence "presence container";
 643
 644         leaf identityref-leaf {
 645             type my-identityref;
 646         }
 647
 648         leaf identityref-leaf2 {
 649             type my-identityref;
 650             default "my-derived-identity";
 651         }
 652
 653         leaf identityref-leaf3 {
 654             type my-identityref2;
 655         }
 656
 657         leaf identityref-leaf4 {
 658             type my-identityref;
 659             default "my-derived-identity2";
 660         }
 661
 662         leaf identityref-leaf5 {
 663             type def-val-test-2:my-imported-identityref;
 664             default def-val-test-2:my-derived-imported-identity;
 665         }
 666
 667         leaf identityref-leaf6 {
 668             type my-identityref;
 669             default "def-val-test:my-derived-identity";
 670         }
 671
 672         leaf identityref-leaf7 {
 673             type def-val-test-2:my-imported-identityref;
 674             default invalid-prefix:my-derived-imported-identity;
 675         }
 676     }
 677 }