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