[smo/teiv.git] /

module general-syntax-test-constraints {

    namespace "test:general-syntax-test-constraints";
    prefix this;

        description
        "Copyright (C) 2024 Ericsson
        Modifications Copyright (C) 2024 OpenInfra Foundation Europe";

    revision "2020-07-22" {
        description "Initial revision";
    }

    // - - - - length - - - -

    container cont1 {

        leaf leaf1 {
                type string {
                        length 1..10 {
                                error-app-tag "some-app-tag";
                                error-message "wrong length";
                        }
                }
        }

                leaf leaf2 {
                type string {
                        length min..max;
                }
        }

                leaf leaf3 {
                type string {
                        length "min..10 | 15 | 20..max";
                }
        }

                leaf leaf4 {
                type string {
                        length "min .. min | max ..max";                // doesn't really make sense, but technically allowed
                }
        }

                leaf leaf5 {
                type string {
                        length min..max|;               // Wrong
                }
        }

                leaf leaf6 {
                type string {
                        length |min..max;               // Wrong
                }
        }

        leaf leaf7 {
                type string {
                        length zero..1.1;               // Wrong
                }
        }

        leaf leaf8 {
                type string {
                        length "10..20 | 21..30";               // OK
                }
        }

        leaf leaf9 {
                type string {
                        length "10..20 | 20..30";               // Wrong, overlap
                }
        }

        leaf leaf10 {
                type string {
                        length "19..30 | 10..20";               // Wrong order
                }
        }

                leaf leaf11 {
                type string {
                        length "-1..-3";                // Wrong, negative.
                }
        }

        leaf leaf12 {
                type string {
                        length "..10..20 | 21..30";             // Wrong
                }
        }

        leaf leaf13 {
                type string {
                        length "10..20 | 21..30..";             // Wrong
                }
        }
    }

        // -------------- Range for integer -------------------

    container cont2 {

        leaf leaf1 {
                type int32 {
                        range 1..10 {
                                error-app-tag "some-app-tag";
                                error-message "wrong length";
                        }
                }
        }

                leaf leaf2 {
                type uint8 {
                        range min..max;
                }
        }

                leaf leaf3 {
                type uint16 {
                        range min..max;
                }
        }

                leaf leaf4 {
                type uint32 {
                        range min..max;
                }
        }

                leaf leaf5 {
                type uint64 {
                        range min..max;
                }
        }

                leaf leaf6 {
                type int8 {
                        range min..max;
                }
        }

                leaf leaf7 {
                type int16 {
                        range min..max;
                }
        }

                leaf leaf8 {
                type int32 {
                        range min..max;
                }
        }

                leaf leaf9 {
                type int64 {
                        range min..max;
                }
        }

        leaf leaf10 {
                type int32 {
                        range 10.0..20.0;
                }
        }

        leaf leaf11 {
                type int32 {
                        range "10..20 | 30 .. 40";
                }
        }

        leaf leaf12 {
                type int32 {
                        range "10..20 | 25 | 30 .. 40";
                }
        }

        leaf leaf13 {
                type uint8 {
                        range "min..min | max .. max";
                }
        }

        leaf leaf14 {
                type uint8 {
                        range " | 10";
                }
        }

        leaf leaf15 {
                type uint8 {
                        range "10 | ";
                }
        }

        leaf leaf16 {
                type uint8 {
                        range "zero .. 10";
                }
        }

                leaf leaf17 {
                type uint8 {
                        range "10 .. 20 | .. 30";
                }
        }

                leaf leaf18 {
                type uint8 {
                        range "10 .. | 20 .. 30";
                }
        }

                leaf leaf19 {
                type uint8 {
                        range "10 .. 20 | 20 .. 30";
                }
        }

                leaf leaf20 {
                type uint8 {
                        range "20 .. 10 | 25 .. 30";
                }
        }

                leaf leaf21 {
                type uint8 {
                        range "30 .. 40 | 10 .. 20";
                }
        }

                leaf leaf22 {
                type uint8 {
                        range "-100 .. -90 | -80 .. -70";
                }
        }

                leaf leaf23 {
                type uint8 {
                        range "400 .. 410 | 610 .. 620";
                }
        }

                leaf leaf24 {
                type uint8 {
                        range "10.5 .. 20.8";
                }
        }

                leaf leaf25 {
                type boolean {
                        range "10 .. 20";
                }
        }
    }

        // -------------- Range for decimal64 -------------------

    container cont3 {

                leaf leaf1 {
                type decimal64 {
                        fraction-digits 1;
                        range min..max;
                }
        }

                leaf leaf2 {
                type decimal64 {
                        fraction-digits 18;
                        range min..max;
                }
        }

                leaf leaf3 {
                type decimal64 {                // missing fraction digits statement, should issue finding
                        range min..max;
                }
        }
        }

}