cddl 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0f6311c506c4a4e5cbf7e7ae7311301a9d4b6c8d
-  data.tar.gz: e6fdfe83c6aec225ce434ae492a709fd06d0c890
+  metadata.gz: 4b41bbfc4b845713489d878733a2c1e51277ce80
+  data.tar.gz: 00096ccc572f588b44cd35007ef8795453f57430
 SHA512:
-  metadata.gz: c2926569f00e5e7e509b3e6d05271da2c0d79a79eb46e38e97701218fe339113d08a8057369ff3c4b5f02bdd3f5fbb80ebc34875c6767b619ea327f722bf7ce3
-  data.tar.gz: 3df458899c4ed7890ef68a40b3c64484599b2805084eb9c8eee15789c94c269452c6352ce34d77dd078e612957c29ded13b650520c179dc6fe886f853e2a60e6
+  metadata.gz: 5481738cee35fb77e07500fe839b0f9a7c6473309938e098893f6af32cf3a00d5f720061e733211ac1df4f3dcd945cc0dbe3d855920a288e44cd432de01b723e
+  data.tar.gz: c3d84ab6506b6620996963e76040af1b097c4886b678317f70598a989fdd5d2a9e82d52119fb49e1e987e0abf9af7a2095addbafcf5592f9db287cd6f7dca3eb

data/cddl.gemspec

@@ -1,6 +1,6 @@
 spec = Gem::Specification.new do |s|
   s.name = 'cddl'
-  s.version = '0.4.2'
+  s.version = '0.5.0'
   s.summary = "CDDL generator and validator."
   s.description = %{A parser, generator, and validator for CDDL}
   s.add_dependency('cbor-diag')

data/data/cddl.abnf

@@ -1,6 +1,6 @@
 cddl = S 1*rule
 rule = typename [genericparm] S "=" S type S
-     / groupname [genericparm] S "=" S group S
+     / groupname [genericparm] S "=" S grpent S
 
 typename = id
 groupname = id
@@ -27,11 +27,13 @@ rangeop = "..." / ".."
 
 annotator = "." id
 
-group = "(" S *grpent S ")"
-      / *grpent
+group = grpchoice S *("//" S grpchoice S)
+
+grpchoice = *grpent
 
 grpent = [occur S] [memberkey S] type optcom
        / [occur S] groupname [genericarg] optcom ; always preempted by previous...
+       / [occur S] "(" S group S ")" optcom
 
 memberkey = type1 S "=>"
           / bareword S ":"

data/lib/cddl.rb

@@ -57,6 +57,10 @@ module CDDL
       @abnf.parse_results
     end
 
+    def ast_debug
+      ast.to_s[/.*comment/m]    # stop at first comment -- prelude
+    end
+
     def strip_nodes(n)
       [n[0], *n[1..-1].map {|e|
         e._strip
@@ -70,7 +74,7 @@ module CDDL
       ast.each :rule do |rule|
         rule_ast =
           if rulename = rule.groupname
-            [:grpent, *rule.group.children(:grpent)]
+            [:grpent, rule.grpent]
           elsif rulename = rule.typename
             [:type1, *rule.type.children(:type1)]
           else
@@ -117,10 +121,9 @@ module CDDL
 
     def lookup_recurse_grpent(name)
       rule = @stage1[name]
-      [rule[0], *rule[1..-1].map {|x| 
-         fail rule.inspect if x.size != 1
-         x[0]
-       }]
+      # pp rule
+      fail unless rule.size == 2
+      [rule[0], *rule[1]]
     end
 
     # Memoize a bit here
@@ -138,10 +141,17 @@ module CDDL
       case where[0]
       when :type1
         generate1(where[rand(where.size-1)+1])
+      when :grpchoice
+        chosen = where[rand(where.size-1)+1]
+        # pp [:chosen, chosen]
+        r = chosen.flat_map {|m| generate1(m, inmap)}
+        # pp r
+        r
       when :map
         Hash[where[1..-1].flat_map {|m| generate1(m, true)}]
       when :recurse_grpent
-        rule = lookup_recurse_grpent(where[1])
+        name = where[1]
+        rule = lookup_recurse_grpent(name)
         if @recursion < MAX_RECURSE
           @recursion += 1
 #p ["recurse_grpent", *rule]
@@ -315,6 +325,11 @@ module CDDL
           n = validate_linear(d, start+i, rule)
           return false unless n
           i += n
+        elsif t == :grpchoice
+          return false unless r[1..-1].any? {|cand|
+            if n = validate_forward(d, start+i, [:foo, *cand])
+              i += n
+            end}
         else
           fail r.inspect unless t == :member
           occ = 0
@@ -343,6 +358,49 @@ module CDDL
       end
     end
 
+    def map_check(d, d_check, members)
+      members.all? { |r|
+        # puts "SUBRULE: #{r.inspect}"
+        t, s, _e, k, v = r
+        case t
+        when :recurse_grpent
+          rule = lookup_recurse_grpent(s)
+          map_check(d, d_check, rule[1..-1])
+        when :grpchoice
+          r[1..-1].any? {|cand|
+            cand_d_check = d_check.dup
+            if map_check(d, cand_d_check, cand)
+              d_check.replace(cand_d_check)
+            end
+          }
+        when :member
+          # this is mostly quadratic; let's do the linear thing if possible
+          fail "member name not known for group entry #{r} in map" unless k
+          simple, simpleval = extract_value(k)
+          if simple
+            #              puts "SIMPLE: #{d_check.inspect} #{simpleval}"
+            # add occurrence check; check that val is present in the first place
+            actual = d.fetch(simpleval, :not_found)
+            if actual == :not_found
+              s == 0          # minimum occurrence must be 0 then
+            else
+              validate1(actual, v) && d_check.delete(simpleval)
+            end
+          else
+            #              puts "COMPLEX: #{k.inspect} #{simple.inspect} #{simpleval.inspect}"
+            keys = d_check.keys
+            ta, keys = keys.partition{ |key| validate1(key, k)}
+            # XXX check ta.size against s/e
+            ta.all? { |val|
+              validate1(d[val], v) && d_check.delete(val)
+            }
+          end
+        else
+          fail "Cannot validate #{t} in maps yet #{r}" # MMM
+        end
+      }
+    end
+
     def validate1(d, where=rules)
 #      puts "DATA: #{d.inspect}"
 #      puts "RULE: #{where.inspect}"
@@ -354,32 +412,7 @@ module CDDL
       when :map
         if Hash === d
           d_check = d.dup
-          where[1..-1].all? { |r|
-            # puts "SUBRULE: #{r.inspect}"
-            t, s, _e, k, v = r
-            fail unless t == :member
-            # this is mostly quadratic; let's do the linear thing if possible
-            fail "member name not known for group entry #{r} in map" unless k
-            simple, simpleval = extract_value(k)
-            if simple
-#              puts "SIMPLE: #{d_check.inspect} #{simpleval}"
-              # add occurrence check; check that val is present in the first place
-              actual = d.fetch(simpleval, :not_found)
-              if actual == :not_found
-                s == 0          # minimum occurrence must be 0 then
-              else
-                validate1(actual, v) && d_check.delete(simpleval)
-              end
-            else
-#              puts "COMPLEX: #{k.inspect} #{simple.inspect} #{simpleval.inspect}"
-              keys = d_check.keys
-              ta, keys = keys.partition{ |key| validate1(key, k)}
-              # XXX check ta.size against s/e
-              ta.all? { |val|
-                validate1(d[val], v) && d_check.delete(val)
-              }
-            end
-          } && d_check == {}
+          map_check(d, d_check, where[1..-1]) && d_check == {}
         end
       when :array
         if Array === d
@@ -511,7 +544,7 @@ module CDDL
       end
     end
 
-    RECURSE_TYPE = {grpent: :recurse_grpent, type1: :recurse}
+    RECURSE_TYPE = {grpent: :recurse_grpent, type1: :recurse} # MMM
     RECURSE_TYPE.default_proc = proc do |a|
       fail a.inspect
     end
@@ -549,15 +582,33 @@ module CDDL
        end, val]
     end
 
+    def workaround1(n)
+      n.children.each do |ch|
+        if ch.to_s == ")"
+          # warn "W1 #{ch.inspect} -> #{ch.group.inspect}"
+          return ch.group
+        end
+      end
+      nil
+    end
+
     def grpent(n)               # returns array of entries
-      nt = n.type || n.bareword.s.type                # check for grpchoice later
+      occ = occur(n.occur)
+      if g = n.group || workaround1(n)
+        gr = group(g)
+        if occ != [1, 1]
+          gr = [[:member, *occ, nil, [:grpent, *gr]]]
+        end
+        return gr
+      end
+      nt = n.type || (n.s && n.s.type) || (n.bareword && n.bareword.s.type) # workarounds
       unless nt
+        warn "NO NT"
         warn @abnf.ast?
         fail ["ntype", n, n.children].inspect
       end
-      occ = occur(n.occur)
       if mk = n.memberkey       # work around unclear bug in ast generation below
-        if (t1 = mk.type1 || t1 = mk.value || 
+        if (t1 = mk.type1 || t1 = mk.value ||
                           ((t1 = mk.s) && (t1 = t1.type) && (t1 = t1.type1))) # workaround
           [[:member, *occ, type1(t1), type(nt)]]
         else
@@ -582,6 +633,9 @@ module CDDL
           t1 = t[1..-1].flatten(1)
           if t1[0] == :recurse_grpent
             [t1]
+          elsif Array === t1[0] && t1[0][0] == :grpchoice
+            fail t1.inspect unless t1.size == 1
+            t1
           else
             t1.flat_map {|t2|
               if t2[0] == :member
@@ -667,6 +721,22 @@ module CDDL
       end
     end
 
+    def memberkey_check(s)
+      s.each do |member|
+        case member[0]
+        when :grpchoice
+          member[1..-1].each do |m|
+            memberkey_check(m)
+          end
+        when :recurse_grpent # XXX we don't have the entry yet
+        when :member
+          fail "map entry without member key given: #{member}" unless member[3]
+        else
+          fail ["type1 member", member].inspect unless member[0] == :member
+        end
+      end
+    end
+
     BRACE = {"{" => :map, "[" => :array}
     RANGE_EXCLUDE_END = {".." => false, "..." => true}
     SUPPORTED_ANNOTATIONS = [:bits, :size, :regexp]
@@ -711,10 +781,7 @@ module CDDL
           s = n.children(:group).flat_map {|ch| group(ch)}
           @insides.pop
           if type == :map
-            s.each do |member|
-              fail unless member[0] == :member
-              fail "map entry without member key given: #{member}" unless member[3]
-            end
+            memberkey_check(s)
             # XXX could do the occurrence multiplier here
           end
           # warn s.inspect
@@ -729,7 +796,7 @@ module CDDL
           end
           [:type1, *s.map {|mem|
              t, _s, _e, _k, v = mem
-             fail unless t == :member
+             fail "enum #{t.inspect}" unless t == :member
              v
            }
           ]
@@ -750,7 +817,20 @@ module CDDL
     end
 
     def group(n)                # returns array
-      n.children(:grpent).flat_map {|ch| grpent(ch)}
+      choices = n.children(:grpchoice)
+      if choices == []          # "cannot happen", workaround
+        choices = n.s.children(:grpchoice)
+        # warn "W2: #{choices.inspect}"
+      end
+      choices = choices.map {|choice|
+        choice.children(:grpent).flat_map {|ch| grpent(ch)}
+      }
+      case choices.size
+      when 1
+        choices.first
+      else
+        [[:grpchoice, *choices]]
+      end
     end
 
     def occur(n)

data/test-data/a.cddl

@@ -0,0 +1,9 @@
+col = {color}
+color = 
+(  black: 0,
+  red: 1,
+  green: 2,)
+//
+(  foo: 4,
+  bar: 5,
+  baz: 6,)

data/test-data/b.cddl

@@ -0,0 +1,3 @@
+x = (a, b)
+a = ()
+b = //

data/test-data/ifmap-base-2.0v17.cddl

@@ -0,0 +1,392 @@
+messages = request / response
+
+request = new-session-request / end-session / renew-session / publish-request / search-request / subscribe-request / poll-request
+        / purge-publisher-request
+
+; response = subscribe-received / publish-received / purge-publisher-received / results
+
+;results = error-result / poll-result / search-result / new-session-result / end-session-result
+
+message<namespace,name,attributes,content> = [
+  namespace: namespace,
+  name: name,
+  attributes: attributes,
+  content: content
+]
+
+error-code = "AccessDenied" / "Failure" / "InvalidIdentifier" / "InvalidIdentifierType" /
+             "IdentifierTooLong" / "InvalidMetadata" / "InvalidSchemaVersion" / "InvalidSessionID" /
+             "MetadataTooLong" / "SearchResultsTooBig" / "PollResultsTooBig" / "SystemError"
+
+error-result =
+  message<"ifmap", "error-result",
+  [ ],
+  [ ? "name", ? tstr,
+    "error-code", error-code,
+    "error-string", tstr
+  ]>
+
+poll-result = ["", "poll-result", [], [ *(search-result / error-result)]]
+
+response-choice = error-result / poll-result / search-result / subscribe-received /
+                  publish-received / purge-publisher-received / new-session-result /
+                  renew-session-result / end-session-result 
+
+response = 
+  message<"ifmap", "response",
+    [ ? validation-attributes ],
+    [ response-choice ]>
+
+purge-publisher-received =
+  ["", "purge-publisher-received", [], []]
+
+purge-publisher-request =
+  message<"ifmap", "purge-publisher",
+    [ "ifmap-publisher-id", tstr,
+      session-attributes
+    ],
+    []>
+
+; needs to be constructed according to IF-MAP Filter syntax
+filter-type = tstr
+
+poll-request =
+  message<"ifmap", "poll",
+    [ session-attributes,
+      validation-attributes
+    ],
+    []>
+
+subscribe-received =
+  ["", "subscribe-received", [], []]
+
+subscribe-request =
+  message<"ifmap", "subscribe",
+    [ session-attributes,
+      validation-attributes
+    ],
+    [ 1*(subscribe-update / subscribe-delete)
+    ]>
+
+subscribe-delete =
+  message<"", "delete",
+    [ "name", tstr,
+    ],
+    []>
+
+subscribe-update =
+  message<"", "update",
+    [ "match-links", filter-type,
+      "max-depth", uint,
+      "terminal-identifier-type", tstr,
+      "max-size", uint,
+      "result-filter", filter-type,
+      "name", tstr,
+    ],
+    [ access-request / identity / ip-address / mac-address / device
+    ]>
+search-request =
+  message<"ifmap", "search",
+    [ session-attributes,
+      validation-attributes,
+      "match-links", filter-type,
+      "max-depth", uint,
+      "terminal-identifier-type", tstr,
+      "max-size", uint,
+      "result-filter", filter-type
+    ],
+    [ access-request / identity / ip-address / mac-address / device
+    ]>
+
+search-result =
+  ["", "search-result",
+    ["name", tstr],
+    [ *result-item]]
+
+result-item =
+  message<"", "result-item",
+    [],
+    [ 1*2(access-request / identity / ip-address / mac-address / device),
+      "metadata", metadata-list-type
+    ]>
+
+publish-request =
+  message<"ifmap", "publish",
+    [ session-attributes, validation-attributes ],
+    [+ (update-request / notify-request / delete-request) ]>
+
+update-request = message<"", "update", [ ? lifetime-attributes], [ 1*2 identifier, metadata-list-type ]>
+notify-request = message<"", "notify", [ ? lifetime-attributes], [ 1*2 identifier ]>
+delete-request = message<"", "delete", [ "filter", tstr], []>
+
+publish-received =
+  ["", "publish-received", [], []]
+
+renew-session = message<"ifmap", "renew-session", [ ? session-attributes ], []>
+renew-session-result = ["", "renew-session-result", [], []]
+
+end-session = message<"ifmap", "end-session", [], []>
+end-session-result =
+  ["", "end-session-result", [], []]
+
+new-session-request =
+  message<"ifmap", "new-session",
+    [ "max-poll-result-size", uint],
+    []>
+
+new-session-result =
+  ["", "new-session-result",
+    [ session-attributes,
+      "ifmap-publisher-id", tstr,
+      "max-poll-result-size", uint,
+    ],
+    []]
+
+identifier = access-request / device / identity / ip-address / mac-address
+
+session-attributes = (
+  "session-id", tstr
+)
+
+validation-attributes = (
+  "validation", ("None" / "BaseOnly" / "MetadataOnly" / "All")
+)
+
+adm-dom = (
+  "administrative-domain", tstr,
+)
+
+lifetime-attributes = (
+  "lifetime", ("session" / "forever")
+)
+
+access-request =
+  message<"ifmap", "access-request",
+    [ ? adm-dom,
+     "name", tstr
+    ],
+    []>
+
+device = message<"ifmap", "device", [], [device-type]>
+device-type =
+  message<"ifmap","aik-name", [], tstr> /
+  message<"ifmap","name", [], tstr>
+
+identity = message<"ifmap", "identity",
+    [ ? adm-dom,
+     "name", tstr,
+     "type", ("aik-name" / "distinguished-name" / "dns-name" / "email-address" /
+                "hip-hit" / "kerberos-principal" / "trusted-platform-module" /
+                "username" / "other"),
+     "other-type-definition", tstr
+    ],
+    []>
+
+ip-address = message<"ifmap", "ip-address",
+    [ ? adm-dom,
+      "value", tstr,
+      "type", ("IPv4" / "IPv6")
+    ],
+    []>
+
+mac-address = message<"ifmap", "mac-address",
+    [ ? adm-dom,
+      "value", tstr,
+    ],
+    []>
+
+metadata-attributes = (
+    "ifmap-publisher-id", tstr,
+    "ifmap-timestamp", tdate,
+    "ifmap-timestamp-fraction", tstr
+    )
+
+; optional metadata attributes? not yet possible
+single-value-metadata-attributes = (
+    ? metadata-attributes,
+    "ifmap-cardinality", "singleValue"
+    )
+
+multi-value-metadata-attributes = (
+    ? metadata-attributes,
+    "ifmap-cardinality", "multiValue"
+    )
+
+access-request-device = message<"meta", "access-request-device",
+    [ single-value-metadata-attributes ], []>
+
+access-request-ip = message<"meta", "access-request-ip",
+    [ single-value-metadata-attributes ], []>
+
+access-request-mac = message<"meta", "access-request-mac",
+    [ single-value-metadata-attributes ], []>
+
+authenticated-as = message<"meta", "authenticated-as",
+    [ single-value-metadata-attributes ], []>
+
+authenticated-by = message<"meta", "authenticated-by",
+    [ single-value-metadata-attributes ], []>
+
+capability = message<"meta", "capability",
+    [ multi-value-metadata-attributes ],
+    [ ? adm-dom,
+      "name", tstr
+    ]>
+
+device-attribute = message<"meta", "device-attribute",
+    [ multi-value-metadata-attributes ], 
+    [ "name", tstr
+    ]>
+
+manufacturer = message<"", "manufacturer", [], tstr>
+model = message<"", "model", [], tstr>
+os = message<"", "os", [], tstr>
+os-version = message<"", "os-version", [], tstr>
+type = message<"", "type", [],
+     ("p2p" / "cve" / "botnet infection" / "worm infection" / "excessive flows" /
+      "behavioral change" / "policy violation" / "other")>
+discovered-time = message<"", "discovered-time", [], tdate>
+discoverer-id = message<"", "discoverer-id", [], tstr>
+discovery-method = message<"", "discovery-method", [], tstr>
+name = message<"", "name", [], tstr>
+magnitude = message<"", "magnitude", [], 0..100>
+confidence = message<"", "confidence", [], 0..100>
+significance = message<"", "significance", [], ("critical" / "important" / "informational")>
+information = message<"", "information", [], tstr>
+vulnerability-uri = message<"", "vulnerability-uri", [], uri>
+enforcement-action = message<"", "enforcement-action", [], tstr>
+other-type-definition = message<"", "other-type-definition", [], tstr>
+enforcement-reason = message<"", "enforcement-reason", [], tstr>
+start-time = message<"", "start-time", [], tdate>
+end-time = message<"", "end-time", [], tdate>
+dhcp-server = message<"", "dhcp-server", [], tstr>
+vlan = message<"", "vlan", [], uint>
+vlan-name = message<"", "vlan-name", [], uint>
+port = message<"", "port", [], uint>
+location-information = message<"", "location-information",
+    [ "type", tstr,
+      "value", tstr], []>
+qualifier = message<"", "qualifier", [], tstr>
+
+device-characteristic = message<"meta", "device-characteristic",
+    [ multi-value-metadata-attributes ],
+    [ ? manufacturer,
+      ? model,
+      ? os,
+      ? os-version,
+      * type,
+      discovered-time,
+      discoverer-id,
+      + discovery-method
+    ]>
+
+device-ip = message<"meta", "device-ip",
+    [ single-value-metadata-attributes ], [ device, ip-address]>
+
+discovered-by = message<"meta", "discovered-by",
+    [ single-value-metadata-attributes ], []>
+
+enforcement-report = message<"meta", "enforcement-report",
+    [ multi-value-metadata-attributes ],
+    [ enforcement-action,
+      other-type-definition,
+      enforcement-reason
+    ]>
+
+event = message<"meta", "event",
+    [ multi-value-metadata-attributes ],
+    [ name,
+      discovered-time,
+      discoverer-id,
+      magnitude,
+      confidence,
+      significance,
+      ? type,
+      ? other-type-definition,
+      ? information,
+      ? vulnerability-uri
+    ]>
+
+ip-mac = message<"meta", "ip-mac",
+    [ multi-value-metadata-attributes ],
+    [ ? start-time,
+      ? end-time,
+      ? dhcp-server
+    ]>
+
+layer2-information = message<"meta", "layer2-information",
+    [ multi-value-metadata-attributes ],
+    [ ? vlan,
+      ? vlan-name,
+      ? port,
+      ? adm-dom
+    ]>
+
+location = message<"meta", "location",
+    [ multi-value-metadata-attributes ],
+    [ discovered-time,
+      discoverer-id,
+      + location-information
+    ]>
+
+request-for-investigation = message<"meta", "request-for-investigation",
+    [ multi-value-metadata-attributes ],
+    [ ? qualifier ]>
+
+role = message<"meta", "role",
+    [ multi-value-metadata-attributes ],
+    [ ? adm-dom,
+      name
+    ]>
+
+unexpected-behavior = message<"meta", "unexpected-behavior",
+    [ multi-value-metadata-attributes ],
+    [ discovered-time,
+      discoverer-id,
+      ? information,
+      magnitude,
+      ? confidence,
+      significance,
+      ? type
+    ]>
+
+wlan-security-type = "open" / "wep" / "tkip" / "ccmp" / "bip" / "other"
+
+ssid = message<"", "ssid", [], tstr>
+ssid-unicast-security = message<"", "ssid-unicast-security",
+    [ ? other-type-definition ],
+    [ wlan-security-type ]>
+ssid-group-security = message<"", "ssid-group-security",
+    [ ? other-type-definition ],
+    [ wlan-security-type ]>
+ssid-management-security = message<"", "ssid-management-security",
+    [ ? other-type-definition ],
+    [ wlan-security-type ]>
+
+wlan-information = message<"meta", "wlan-information",
+    [ single-value-metadata-attributes ],
+    [ ? ssid,
+      + ssid-unicast-security,
+      ssid-group-security,
+      + ssid-management-security
+    ]>
+
+client-time = message<"opmeta", "client-time",
+    [ single-value-metadata-attributes,
+      "current-time", tdate
+    ], []>
+
+; list every capability explicitly?
+server-capability = message<"opmeta", "server-capability",
+    [ single-value-metadata-attributes,
+    ],
+    [ message<"", "capability", [], tstr>,
+    ]>
+
+metadata-list-type = [
+  *(access-request-device / access-request-ip / access-request-mac /
+    authenticated-as / authenticated-by / capability / device-attribute /
+    device-characteristic / device-ip / discovered-by / enforcement-report /
+    event / ip-mac / layer2-information / location / request-for-investigation /
+    role / unexpected-behavior / wlan-information
+    )]

data/test/test-cddl.rb

@@ -410,6 +410,35 @@ HERE
     }
   end
 
+  def test_another_simple_alternative_group
+    parser = CDDL::Parser.new <<HERE
+test = {
+  bar: int // bar: true
+}
+HERE
+    # pp parser.rules
+    10.times {
+      g = parser.generate
+      # pp ["tasag", g]
+      bar = g['bar']
+      assert bar == true || Integer(bar)
+      assert parser.validate(g)
+      refute parser.validate(g.merge(foo: 3), false)
+      refute parser.validate(g.merge(bar: "baz"), false)
+    }
+  end
+
+  
+  def test_bad_simple_alternative_group
+    parser = CDDL::Parser.new <<HERE
+test = {
+  bar: int // true              ; no member key in second choice
+}
+HERE
+    assert_raise { parser.rules }
+  end
+
+
   def test_simple_alternative_in_array
     parser = CDDL::Parser.new <<HERE
 test = [
@@ -450,6 +479,38 @@ HERE
   end
 
 
+  def test_group_choice_in_array2
+    parser = CDDL::Parser.new <<HERE
+test = [
+  (1 // 2)
+  bar
+  (foob: 3 // boof: 4)
+  (bar // zab: 9, baz: 10)
+]
+bar = (5 // 6)
+HERE
+    # puts parser.ast_debug
+    pp parser.rules
+    10.times {
+      g = parser.generate
+      pp ["gcia", g]
+      assert_equal g.size, (g[3] == 9 ? 5 : 4)
+      assert [1, 2].include? g[0]
+      assert [5, 6].include? g[1]
+      assert [3, 4].include? g[2]
+      assert [5, 6, 9].include? g[3]
+      assert_equal g[4], 10 if g[3] == 9
+      assert parser.validate(g)
+    }
+    refute parser.validate([1, 5, 8, 9], false)
+    refute parser.validate([1, 5, 3], false)
+    assert parser.validate([1, 5, 4, 5])
+    refute parser.validate([1, 5, 4, 9], false)
+    assert parser.validate([1, 5, 4, 9, 10])
+    refute parser.validate([1, 5, 4, 3], false)
+    refute parser.validate([1, 5, 4, 9, 10, 3], false)
+  end
+
   def test_validate_number_key
     parser = CDDL::Parser.new <<HERE
 test = [test1, test2, test3]
@@ -901,7 +962,7 @@ a = [a] / 1
 HERE
     10.times {
       g = parser.generate
-      pp ["recurse-test1", g]
+      # pp ["recurse-test1", g]
       assert parser.validate(g)
     }
   end
@@ -943,11 +1004,31 @@ HERE
     p parser.rules
     10.times {
       g = parser.generate
-      # pp ["recurse-group-test", g]
+      pp ["recurse-group-test", g]
       assert parser.validate(g)
     }
   end
 
+  
+  def test_group_recursion2
+    parser = CDDL::Parser.new <<HERE
+b = {1: 2, a}
+a = (
+  foo: int
+  bar: ([+aa] / 1 / 2)
+)
+aa = {a}
+HERE
+    p parser.rules
+    10.times {
+      g = parser.generate
+      pp ["recurse-group-test2", g]
+      assert parser.validate(g)
+      refute parser.validate(g.merge(baz: 3), false)
+    }
+  end
+
+
   def test_group_recursion_fail1
     parser = CDDL::Parser.new <<HERE
 b = {a}
@@ -964,6 +1045,25 @@ HERE
 a = {b}
 b = ()
 HERE
+    # puts "empty_group AST:"
+    # puts parser.ast_debug
+    # puts "empty_group RULES:"
+    # pp parser.rules
+    assert_equal({}, parser.generate)
+    assert parser.validate({})
+  end
+
+
+  def test_empty_group_sp
+    parser = CDDL::Parser.new <<HERE
+a = {b}
+b = (
+)
+HERE
+    # puts "empty_group_sp AST:"
+    # puts parser.ast_debug
+    # puts "empty_group_sp RULES:"
+    # pp parser.rules
     assert_equal({}, parser.generate)
     assert parser.validate({})
   end
@@ -980,4 +1080,31 @@ HERE
 #    assert parser.validate({})
   end
 
+  def test_group_occur
+    parser = CDDL::Parser.new <<HERE
+a = [1*3 b]
+b = (
+1, 2
+)
+HERE
+    parser2 = CDDL::Parser.new <<HERE
+a = [1*3 (1, 2)]
+HERE
+    # puts "empty_group_sp AST:"
+    # puts parser.ast_debug
+    # puts "empty_group_sp RULES:"
+    pp parser.rules
+    assert_equal parser.rules, parser2.rules
+    # assert parser.validate({})
+    10.times {
+      g = parser2.generate
+      # pp ["group-occur", g]
+      assert [2, 4, 6].include? g.size
+      g.each_slice(2) do |sl|
+        assert_equal sl, [1, 2]
+      end
+      assert parser2.validate(g)
+      refute parser2.validate(g << 1, false)
+    }
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cddl
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.5.0
 platform: ruby
 authors:
 - Carsten Bormann
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-17 00:00:00.000000000 Z
+date: 2015-06-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cbor-diag
@@ -100,9 +100,12 @@ files:
 - lib/cddl.rb
 - test-data/7071-concise.cddl
 - test-data/7071-verbose.cddl
+- test-data/a.cddl
+- test-data/b.cddl
 - test-data/basic_syntax_example.cddl
 - test-data/cdni-ct.cddl
 - test-data/dcaf1.cddl
+- test-data/ifmap-base-2.0v17.cddl
 - test-data/jcr-ex.cddl
 - test-data/minimal.cddl
 - test-data/reused_named_group.cddl