Fixed some major sonar issues in yang-validation-tool

[yangtools.git] / code-generator / binding-generator-impl / src / test / resources / type-provider / test.yang

module test {
    yang-version 1;
    namespace "urn:opendaylight:test";
    prefix "t";

    import ietf-inet-types {
        prefix "inet";
    }

    revision "2013-10-08" {
    }



    // binary
    typedef my-binary {
        type binary;
    }

    leaf ext-binary {
        type my-binary;
        default "TWFu";
    }

    leaf leaf-binary {
        type binary;
        default "TWFu";
    }



    // bits
    typedef my-bits {
        type bits {
            bit ctrl;
            bit alt {
                position 5;
            }
            bit delete;
        }
    }

    leaf ext-bits {
        type my-bits;
        default "delete";
    }

    leaf leaf-bits {
        type bits {
            bit ctrl;
            bit alt {
                position 5;
            }
            bit delete;
        }
        default "delete";
    }



    // boolean
    typedef my-boolean {
        type boolean;
    }

    leaf ext-boolean {
        type my-boolean;
        default true;
    }

    leaf leaf-boolean {
        type boolean;
        default true;
    }



    // decimal64
    typedef my-decimal64 {
        type decimal64 {
            fraction-digits 4;
        }
    }

    leaf ext-decimal64 {
        type my-decimal64;
        default "3.14";
    }

    leaf leaf-decimal64 {
        type decimal64 {
            fraction-digits 4;
        }
        default "3.14";
    }



    // empty
    typedef my-empty {
        type empty;
    }

    leaf ext-empty {
        type my-empty;
        default false;
    }

    leaf leaf-empty {
        type empty;
        default false;
    }



    // enumeration
    typedef my-enumeration {
        type enumeration {
            enum zero;
            enum one;
            enum seven {
                value 7;
            }
        }
    }

    leaf ext-enumeration {
        type my-enumeration;
        default seven;
    }

    leaf leaf-enumeration {
        type enumeration {
            enum zero;
            enum one;
            enum seven {
                value 7;
            }
        }
        default seven;
    }



    // identityref
    typedef my-identityref {
        type identityref {
            base alg;
        }
    }

    leaf ext-identityref {
        type my-identityref;
    }

    leaf leaf-identityref {
        type identityref {
            base alg;
        }
    }



    // int8
    typedef my-int8 {
        type int8;
    }

    leaf ext-int8 {
        type my-int8;
        default "11";
    }

    leaf leaf-int8 {
        type int8;
        default "11";
    }



    // int16
    typedef my-int16 {
        type int16;
    }

    leaf ext-int16 {
        type my-int16;
        default "111";
    }

    leaf leaf-int16 {
        type int16;
        default "111";
    }



    // int32
    typedef my-int32 {
        type int32;
    }

    leaf ext-int32 {
        type my-int32;
        default "1111";
    }

    leaf leaf-int32 {
        type int32;
        default "1111";
    }



    // int64
    typedef my-int64 {
        type int64;
    }

    leaf ext-int64 {
        type my-int64;
        default "11111";
    }

    leaf leaf-int64 {
        type int64;
        default "11111";
    }



    // leafref
    typedef my-leafref {
        type leafref {
            path "/links/node/id-64";
        }
    }

    leaf ext-leafref {
        type my-leafref;
        default "1.234";
    }

    leaf leaf-leafref {
        type leafref {
            path "/links/node/id-64";
        }
        default "1.234";
    }

    typedef my-leafref1 {
        type leafref {
            path "/links/node/id-for-binary";
        }
    }

    leaf ext-leafref1 {
        type my-leafref1;
        default "TWFu";
    }

    leaf leaf-leafref1 {
        type leafref {
            path "/links/node/id-for-binary";
        }
        default "TWFu";
    }



    // string
    typedef my-string {
        type string;
    }

    leaf ext-string {
        type my-string;
        default "name";
    }

    leaf leaf-string {
        type string;
        default "name";
    }



    // uint8
    typedef my-uint8 {
        type uint8;
    }

    leaf ext-uint8 {
        type my-uint8;
        default "11";
    }

    leaf leaf-uint8 {
        type uint8;
        default "11";
    }



    // uint16
    typedef my-uint16 {
        type uint16;
    }

    leaf ext-uint16 {
        type my-uint16;
        default "111";
    }

    leaf leaf-uint16 {
        type uint16;
        default "111";
    }



    // uint32
    typedef my-uint32 {
        type uint32;
    }

    leaf ext-uint32 {
        type my-uint32;
        default "1111";
    }

    leaf leaf-uint32 {
        type uint32;
        default "1111";
    }



    // uint64
    typedef my-uint64 {
        type uint64;
    }

    leaf ext-uint64 {
        type my-uint64;
        default "11111";
    }

    leaf leaf-uint64 {
        type uint64;
        default "11111";
    }

    // uint64
    typedef my-union {
        type union {
            type string;
            type my-binary;
        }
    }

    leaf ext-union {
        type my-union;
        default "111";
    }

    leaf leaf-union {
        type union {
            type string;
            type int8;
        }
        default "111";
    }

    container c1 {
        container c2 {
            typedef nested-union {
                type union {
                    type string;
                    type int16;
                }
            }
            container c3 {
                leaf id {
                    type nested-union;
                    default "111";
                }
            }
        }
    }


    list links {
        container node {
            leaf id-64 {
                type decimal64 {
                    fraction-digits "7";
                }
            }
            leaf id-for-binary {
                type my-binary;
            }
        }
    }

    identity alg {
    }

    leaf ip-leaf {
        type inet:ipv4-address;
        default "0.0.0.1";
    }

}