Refactored parsing of YANG uses statement.

[controller.git] / opendaylight / sal / yang-prototype / code-generator / yang-model-parser-impl / src / test / resources / model / testfile2.yang

diff --git a/opendaylight/sal/yang-prototype/code-generator/yang-model-parser-impl/src/test/resources/model/testfile2.yang b/opendaylight/sal/yang-prototype/code-generator/yang-model-parser-impl/src/test/resources/model/testfile2.yang
index 9d1220717971721b687da6ee34070539845c0117..b25f65e4a45705d1ff6326987303cc2bf562c3b8 100644 (file)
--- a/opendaylight/sal/yang-prototype/code-generator/yang-model-parser-impl/src/test/resources/model/testfile2.yang
+++ b/opendaylight/sal/yang-prototype/code-generator/yang-model-parser-impl/src/test/resources/model/testfile2.yang
@@ -1,43 +1,257 @@
 module types2 {
-       yang-version 1;
+    yang-version 1;
     namespace "urn:simple.types.data.demo";
     prefix "t2";
     
-    import types1 {
-         prefix "if";
-         revision-date 2013-02-27;
-     }
-
-    organization "Cisco";
-    contact "WILL-BE-DEFINED-LATER";
+    organization "opendaylight";
+    contact "http://www.opendaylight.org/";
+    
     description "This is types-data test description";
 
     revision "2013-02-27" {
         reference " WILL BE DEFINED LATER";
     }
+
+    typedef my-base-int32-type {
+        type int32 {
+            range "2..20";
+        }
+    }
+
+    typedef my-type1 {
+        type my-base-int32-type {
+            range "3..9|11..max";
+        }
+        units "mile";
+        default "11";
+    }
+
+    typedef my-custom-string {
+        type string {
+            pattern "[a-k]*";
+            length "5..11";
+        }
+    }
+
+    typedef my-string-type {
+        type my-custom-string {
+            length "6..10";
+        }
+    }
     
-    
-     augment "/if:interfaces/if:ifEntry" {
-         when "if:ifType='ds0'";
-         leaf ds0ChannelNumber {
-             type string;
+    typedef my-string-type2 {
+        type my-string-type {
+            pattern "[b-u]*";
+        }
+    }
+
+    typedef my-string-type-ext {
+        type my-string-type2 {
+            pattern "[e-z]*";
+        }
+    }
+
+    typedef my-int-type {
+        type int32 {
+            range "10..20";
+        }
+    }
+
+    typedef my-int-type2 {
+        type my-int-type {
+            range "12..18";
+        }
+    }
+
+    typedef my-int-type-ext {
+        type my-int-type2 {
+            range "14..16";
+        }
+    }
+
+    typedef my-decimal-type {
+        type decimal64 {
+            fraction-digits 6;
+        }
+    }
+
+    typedef my-decimal-type-ext {
+        type decimal64 {
+            fraction-digits 5;
+        }
+    }
+
+    typedef my-union {
+        type union {
+            type int16 {
+                range "1..100";
+            }
+            type int32;
+        }
+    }
+
+    typedef my-union-ext {
+        type my-union;
+    }
+
+    typedef nested-union1 {
+        type nested-union2;
+    }
+
+    typedef nested-union2 {
+        type union {
+            type my-union-ext;
+            type string;
+        }
+    }
+
+    leaf if-name {
+        type leafref {
+            path "/interface/name";
+        }
+    }
+
+    leaf name {
+        type string;
+    }
+
+    leaf count {
+        type int8 {
+            range "1..10";
+        }
+    }
+
+    leaf nested-type-leaf {
+        type my-type1;
+    }
+
+    extension c-define {
+        description
+        "Takes as argument a name string.
+        Makes the code generator use the given name in the
+        #define.";
+        argument "name" {
+            yin-element "true";
+        }
+    }
+
+    container system {
+        leaf user {
+            type string;
+        }
+    }
+
+    grouping target {
+        anyxml data {
+            config true;
+            description "Copy of the source datastore subset.";
+            mandatory false;
+            must "test-condition-text";
+            reference "test-no-reference";
+            status "obsolete";
+            when "test-when-text";
+        }
+        choice how {
+            description "test choice description";
+            default interval;
+            case interval {
+                leaf interval {
+                    type uint16;
+                    default 30;
+                    units minutes;
+                }
+            }
+            case daily {
+                leaf daily {
+                    type empty;
+                }
+                leaf time-of-day {
+                    type string;
+                    units 24-hour-clock;
+                    default 1am;
+                }
+            }
+        }
+        leaf address {
+            type string;
+            description "Target IP address";
+        }
+        container port {
+            description "Target port container";
+        }
+        list addresses {
+            key "id";
+            leaf id {
+                type int8;
+            }
+        }
+        grouping target-inner {
+            description "target-inner default description";
+            leaf inner-grouping-id {
+                type int8;
+            }
+        }
+        typedef group-type {
+            type my-decimal-type;
+        }
+
+        opendaylight;
+    }
+
+    container peer {
+        container destination {
+            uses target {
+                refine address {
+                    default "1.2.3.4";
+                    description "IP address of target node";
+                    reference "address reference added by refine";
+                    config false;
+                    mandatory true;
+                    must "ifType != 'ethernet' or " +
+                            "(ifType = 'ethernet' and ifMTU = 1500)" {
+                        error-message "An ethernet MTU must be 1500";
+                    }
+                }
+                refine port {
+                    description "description of port defined by refine";
+                    reference "port reference added by refine";
+                    config false;
+                    presence "presence is required";
+                }
+                refine addresses {
+                    description "description of addresses defined by refine";
+                    reference "addresses reference added by refine";
+                    config false;
+                    min-elements 2;
+                    max-elements 12;
+                }
+                refine target-inner {
+                    description "new target-inner grouping description";
+                }
+                refine group-type {
+                    description "new group-type description";
+                    reference "new group-type reference";
+                }
+            }
+        }
+    }
+
+    container interfaces {
+         list ifEntry {
+             key "ifIndex";
+
+             leaf ifIndex {
+                 type uint32;
+                 units minutes;
+             }
+
+             leaf ifMtu {
+                 type int32;
+             }
+
+             min-elements 1;
+             max-elements 11;
          }
-     }
-     
-     leaf if-name {
-       type leafref {
-               path "/interface/name";
-        }
-     }
-     
-     leaf name {
-       type string;
-     }
-     
-     typedef my-base-int32-type {
-               type int32 {
-               range "0..32";
-        }
-       }
+    }
 
 }