cddl 0.7.2 → 0.7.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8803ef067ea0ea2959c233dadcdb2c6b9efc951c
-  data.tar.gz: 59b76d0a3da17193115e4d023414d486b07b80b7
+  metadata.gz: 8059c1eece18e74a9f61203673b8e9650b90a41b
+  data.tar.gz: 2cbd8a2ffe191c1e63b65ecd8c1274c37d916eab
 SHA512:
-  metadata.gz: c2c84dc9a1eed0643f1bfe619fbc922290f4815d3f77e04ca5e076421b717c45eb0ccd48b00636d71a602d2324aacaaf8be2256b59bcb6f6a9712dfe40f3bc21
-  data.tar.gz: bccdb7d885651ded32f13eb95aaffaed70a2c2ad4490465f4d866703d18c49c843ce84820067834287c8adb1aeddcf658719f41ee49dd5a360d749d89d0f9b89
+  metadata.gz: 805dec239578ebd63c6d0ebd53f60bb15c7b536ed6ad7c08a796158f8046ba800557985f3995469a77ddb3c7fd89f67add4ce2c336073d87ecfa369ccbcaf654
+  data.tar.gz: 336f8a01af37ca9b6f40f7a06ed8193fc96acfab84123537e8a552eb64a8fffcd457c6c0bddd0e5b80cc7c864bce03405f65531ecc42e682971da9cbfb4f8bf9

data/cddl.gemspec

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

data/lib/cbor-pp.rb

@@ -109,6 +109,19 @@ class CBOR::PP < PrettyPrint
     end
   end
 
+  module EqlMixin
+    def eql?(other)
+      if other.respond_to? :__getobj__
+        eql? other.__getobj__
+      else
+        super
+      end
+    end
+    # def ==(other)
+    #   eql?(other) || super
+    # end
+  end
+
   def self.add_annotations(tree, ann_list)
     tree.cbor_add_annotations_from(ann_list)
   end
@@ -161,7 +174,7 @@ class Hash # :nodoc:
   end
   def cbor_add_annotations_from(ann_list)
     super
-    each {|k, v| 
+    each {|k, v|
       # k.cbor_add_annotations_from(ann_list)
       v.cbor_add_annotations_from(ann_list)
     }
@@ -170,19 +183,25 @@ class Hash # :nodoc:
     # to_a.cbor_clone.to_h  # this breaks for unknown reasons
     h = {}
     each {|k, v| h[k.cbor_clone] = v.cbor_clone}
-    each {|k, v| fail [h, k, h[k], v].inspect unless h[k] == v}
+    each {|k, v| fail [h, k, k.cbor_clone, h[k], v].inspect unless h[k] == v}
     h
   end
 end
 
 class Numeric
-  def eql?(other)
-    if other.respond_to? :__getobj__
-      eql? other.__getobj__
-    else
-      super
-    end
-  end
+  prepend CBOR::PP::EqlMixin
+end
+
+class TrueClass
+  prepend CBOR::PP::EqlMixin
+end
+
+class FalseClass
+  prepend CBOR::PP::EqlMixin
+end
+
+class NilClass
+  prepend CBOR::PP::EqlMixin
 end
 
 class Object < BasicObject # :nodoc:

data/lib/cddl.rb

@@ -345,7 +345,7 @@ module CDDL
                             generate1(vr)
                           ]}
         rescue BackTrack
-          fail BackTrack("Need #{where[1]}..#{where[2]} of these: #{[kr, vr].inspect}") unless where[1] == 0
+          fail BackTrack.new("Need #{where[1]}..#{where[2]} of these: #{[kr, vr].inspect}") unless where[1] == 0
           []
         end
       when :string, :int, :float
@@ -768,7 +768,7 @@ module CDDL
         when 7
           t, v = extract_value(where)
           if t
-            v == d
+            v.eql? d
           else
             case where[2]
             when nil

data/test-data/grasp-01-extract.cddl

@@ -0,0 +1,91 @@
+
+   grasp-message = message
+
+   session-id = 0..16777215
+   ; that is up to 24 bits
+
+   message /= discovery-message
+   discovery-message = [M_DISCOVERY, session-id, objective]
+
+   message /= response-message
+   response-message = [M_RESPONSE, session-id,
+                      (+locator-option // divert-option // objective)]
+
+   message /= request-message
+   request-message = [M_REQUEST, session-id, objective]
+
+   message /= negotiation-message
+   negotiation-message = [M_NEGOTIATE, session-id, objective]
+
+   message /= end-message
+   end-message = [M_END, session-id, (accept-option / decline-option)]
+
+   message /= wait-message
+   wait-message = [M_WAIT, session-id, waiting-time-option]
+
+   divert-option = [O_DIVERT, +locator-option]
+
+   accept-option = [O_ACCEPT]
+
+   decline-option = [O_DECLINE]
+
+   waiting-time-option = [O_WAITING, option-waiting-time]
+   option-waiting-time = 0..4294967295 ; in milliseconds
+
+   option-device-id = [O_DEVICE_ID, bytes]
+
+   locator-option /= ipv4-locator-option
+   ipv4-locator-option = bytes .size 4
+   ; this is simpler than [O_IPv4_LOCATOR, bytes .size 4]
+
+   locator-option /= ipv6-locator-option
+   ipv6-locator-option = bytes .size 16
+
+   locator-option /= fqdn-locator-option
+   fqdn-locator-option = [O_FQDN_LOCATOR, text]
+
+   locator-option /= url-locator-option
+   url-locator-option = [O_URL_LOCATOR, text]
+
+   objective-flags = uint .bits objective-flag
+
+   objective-flag = &(
+   D: 0
+   N: 1
+   S: 2
+   )
+
+   ; D means valid for discovery only
+   ; N means valid for discovery and negotiation
+   ; S means valid for discovery and synchronization
+
+   objective /= generic-obj
+   generic-obj = [objective-name, objective-flags, loop-count, ?any]
+
+   objective /= vendor-obj
+   vendor-obj = [{"PEN":pen}, objective-name, objective-flags,
+                 loop-count, ?any]
+
+   ; A PEN is used to distinguish vendor-specific options.
+
+   pen = 0..4294967295
+   objective-name = tstr
+   loop-count = 0..255
+
+   ; Constants
+
+   M_DISCOVERY = 1
+   M_RESPONSE = 2
+   M_REQUEST = 3
+   M_NEGOTIATE = 4
+   M_END = 5
+   M_WAIT = 6
+
+   O_DIVERT = 100
+   O_ACCEPT = 101
+   O_DECLINE = 102
+   O_WAITING = 103
+   O_DEVICE_ID = 104
+   O_FQDN_LOCATOR = 105
+   O_URL_LOCATOR = 106
+

data/test-data/xmlmig.cddl

@@ -0,0 +1,15 @@
+element = [ns, gi, attr, elts]
+
+ns = text / nil
+; can be name syntax or URI
+
+gi = text ; name syntax
+
+attr = { * label => any }
+
+label = text / int
+
+elts = value / [* element]
+; could allow values inside array for mixed content
+
+value = int / text

data/test/test-cddl.rb

@@ -7,6 +7,13 @@ require 'cbor-diagnostic.rb'
 require_relative '../lib/cddl'
 require_relative '../lib/cbor-pp'
 
+module CDDL
+  class Parser
+    def validate_for_test(d, warn = true)
+      validate(d, warn) && validate(d.cbor_clone, warn)
+    end
+  end
+end
 
 class TestABNF < Test::Unit::TestCase
 
@@ -68,37 +75,37 @@ HERE
     parser2 = CDDL::Parser.new "oneortwoPerson = [1*2 person ]" + person
     parser3 = CDDL::Parser.new "min2Person = [2* person ]" + person
 
-    assert parser1.validate([])
-    refute parser2.validate([], false)
-    refute parser3.validate([], false)
-    assert parser1.validate(["Methuselah", 969])
-    assert parser2.validate(["Methuselah", 969])
-    refute parser3.validate(["Methuselah", 969], false)
-    assert parser1.validate(["Methuselah", 969, "Methuselah", 969])
-    assert parser2.validate(["Methuselah", 969, "Methuselah", 969])
-    assert parser3.validate(["Methuselah", 969, "Methuselah", 969])
-    assert parser1.validate(["Methuselah", 969, "Methuselah", 969, "Methuselah", 969])
-    refute parser2.validate(["Methuselah", 969, "Methuselah", 969, "Methuselah", 969], false)
-    assert parser3.validate(["Methuselah", 969, "Methuselah", 969, "Methuselah", 969])
-    refute parser1.validate(["Methuselah", "Methuselah", 969, 969], false)
-    refute parser2.validate(["Methuselah", "Methuselah", 969, 969], false)
-    refute parser3.validate(["Methuselah", "Methuselah", 969, 969], false)
-    refute parser1.validate(["Methuselah", "Methuselah", "Methuselah", 969, 969], false)
-    refute parser2.validate(["Methuselah", "Methuselah", "Methuselah", 969, 969], false)
-    refute parser3.validate(["Methuselah", "Methuselah", "Methuselah", 969, 969], false)
+    assert parser1.validate_for_test([])
+    refute parser2.validate_for_test([], false)
+    refute parser3.validate_for_test([], false)
+    assert parser1.validate_for_test(["Methuselah", 969])
+    assert parser2.validate_for_test(["Methuselah", 969])
+    refute parser3.validate_for_test(["Methuselah", 969], false)
+    assert parser1.validate_for_test(["Methuselah", 969, "Methuselah", 969])
+    assert parser2.validate_for_test(["Methuselah", 969, "Methuselah", 969])
+    assert parser3.validate_for_test(["Methuselah", 969, "Methuselah", 969])
+    assert parser1.validate_for_test(["Methuselah", 969, "Methuselah", 969, "Methuselah", 969])
+    refute parser2.validate_for_test(["Methuselah", 969, "Methuselah", 969, "Methuselah", 969], false)
+    assert parser3.validate_for_test(["Methuselah", 969, "Methuselah", 969, "Methuselah", 969])
+    refute parser1.validate_for_test(["Methuselah", "Methuselah", 969, 969], false)
+    refute parser2.validate_for_test(["Methuselah", "Methuselah", 969, 969], false)
+    refute parser3.validate_for_test(["Methuselah", "Methuselah", 969, 969], false)
+    refute parser1.validate_for_test(["Methuselah", "Methuselah", "Methuselah", 969, 969], false)
+    refute parser2.validate_for_test(["Methuselah", "Methuselah", "Methuselah", 969, 969], false)
+    refute parser3.validate_for_test(["Methuselah", "Methuselah", "Methuselah", 969, 969], false)
   end
 
   def test_validate
     parser1 = CDDL::Parser.new(File.read("test-data/7071-concise.cddl"))
     g = parser1.generate
     pp g
-    assert parser1.validate(g)
+    assert parser1.validate_for_test(g)
     old = g["application"]
     g["application"] = 4711
-    refute parser1.validate(g, false)
+    refute parser1.validate_for_test(g, false)
     g["application"] = old
     g["reputons"] << 5712
-    refute parser1.validate(g, false)
+    refute parser1.validate_for_test(g, false)
   end
 
   def test_aaaaaaa_cbor_clone_hash
@@ -136,30 +143,37 @@ HERE
     parser = CDDL::Parser.new <<HERE
 test = 1
 HERE
-    assert parser.validate(1)
+    assert parser.validate_for_test(1)
+  end
+
+  def test_aaaaaa_validate_true
+    parser = CDDL::Parser.new <<HERE
+test = true
+HERE
+    assert parser.validate_for_test(true)
   end
 
   def test_validate_a
     parser = CDDL::Parser.new <<HERE
 test = [* one: 1]
 HERE
-    assert parser.validate([])
-    assert parser.validate([1])
-    assert parser.validate([1, 1])
-    refute parser.validate([1, 2], false)
-    refute parser.validate([2, 1], false)
+    assert parser.validate_for_test([])
+    assert parser.validate_for_test([1])
+    assert parser.validate_for_test([1, 1])
+    refute parser.validate_for_test([1, 2], false)
+    refute parser.validate_for_test([2, 1], false)
   end
 
   def test_validate_a_string
     parser = CDDL::Parser.new <<HERE
 test = [* one: "one"]
 HERE
-    assert parser.validate([])
-    assert parser.validate(["one"])
-    assert parser.validate(["one", "one"])
-    refute parser.validate([1], false)
-    refute parser.validate(['two'], false)
-    refute parser.validate(["one", "two"], false)
+    assert parser.validate_for_test([])
+    assert parser.validate_for_test(["one"])
+    assert parser.validate_for_test(["one", "one"])
+    refute parser.validate_for_test([1], false)
+    refute parser.validate_for_test(['two'], false)
+    refute parser.validate_for_test(["one", "two"], false)
   end
 
 
@@ -167,12 +181,12 @@ HERE
     parser = CDDL::Parser.new <<HERE
 test = [* "two" => "one"]
 HERE
-    assert parser.validate([])
-    assert parser.validate(["one"])
-    assert parser.validate(["one", "one"])
-    refute parser.validate([1], false)
-    refute parser.validate(['two'], false)
-    refute parser.validate(["one", "two"], false)
+    assert parser.validate_for_test([])
+    assert parser.validate_for_test(["one"])
+    assert parser.validate_for_test(["one", "one"])
+    refute parser.validate_for_test([1], false)
+    refute parser.validate_for_test(['two'], false)
+    refute parser.validate_for_test(["one", "two"], false)
   end
 
   def test_validate_a_once
@@ -184,11 +198,11 @@ HERE
     # pp parser.rules
     # puts "APR:"
     # pp parser.apr
-    refute parser.validate([], false)
-    assert parser.validate([1])
-    refute parser.validate([1, 1], false)
-    refute parser.validate([1, 2], false)
-    refute parser.validate([2, 1], false)
+    refute parser.validate_for_test([], false)
+    assert parser.validate_for_test([1])
+    refute parser.validate_for_test([1, 1], false)
+    refute parser.validate_for_test([1, 2], false)
+    refute parser.validate_for_test([2, 1], false)
   end
 
   def test_validate_unknown_key
@@ -216,10 +230,10 @@ HERE
     # puts "APR:"
     # pp parser.apr
     assert_equal [1, 2], parser.generate()
-    refute parser.validate({}, false)
-    refute parser.validate([], false)
-    refute parser.validate([1], false)
-    assert parser.validate([1, 2])
+    refute parser.validate_for_test({}, false)
+    refute parser.validate_for_test([], false)
+    refute parser.validate_for_test([1], false)
+    assert parser.validate_for_test([1, 2])
   end
 
 
@@ -233,10 +247,10 @@ HERE
     # puts "APR:"
     # pp parser.apr
     assert_equal [1, 2], parser.generate()
-    refute parser.validate({}, false)
-    refute parser.validate([], false)
-    refute parser.validate([1], false)
-    assert parser.validate([1, 2])
+    refute parser.validate_for_test({}, false)
+    refute parser.validate_for_test([], false)
+    refute parser.validate_for_test([1], false)
+    assert parser.validate_for_test([1, 2])
   end
 
 
@@ -250,12 +264,12 @@ HERE
     # pp parser.rules
     # puts "APR:"
     # pp parser.apr
-    assert parser.validate([])
-    assert parser.validate([1, 2])
-    assert parser.validate([1, 2, 1, 2])
-    refute parser.validate([1, 1, 2, 2], false)
-    refute parser.validate([1], false)
-    refute parser.validate([1, 2, 1], false)
+    assert parser.validate_for_test([])
+    assert parser.validate_for_test([1, 2])
+    assert parser.validate_for_test([1, 2, 1, 2])
+    refute parser.validate_for_test([1, 1, 2, 2], false)
+    refute parser.validate_for_test([1], false)
+    refute parser.validate_for_test([1, 2, 1], false)
   end
 
   def test_validate_occur1  # XXX need indirection for now
@@ -268,13 +282,13 @@ HERE
     # pp parser.rules
     # puts "APR:"
     # pp parser.apr
-    refute parser.validate([], false)
-    refute parser.validate([1], false)
-    assert parser.validate([1, 2])
-    refute parser.validate([2, 1], false)
-    refute parser.validate([1, 1, 2, 2], false)
-    refute parser.validate([1, 2, 1, 2], false)
-    refute parser.validate([1, 2, 1], false)
+    refute parser.validate_for_test([], false)
+    refute parser.validate_for_test([1], false)
+    assert parser.validate_for_test([1, 2])
+    refute parser.validate_for_test([2, 1], false)
+    refute parser.validate_for_test([1, 1, 2, 2], false)
+    refute parser.validate_for_test([1, 2, 1, 2], false)
+    refute parser.validate_for_test([1, 2, 1], false)
   end
 
   def test_validate_occur01  # XXX need indirection for now
@@ -287,13 +301,13 @@ HERE
     # pp parser.rules
     # puts "APR:"
     # pp parser.apr
-    assert parser.validate([])
-    refute parser.validate([1], false)
-    assert parser.validate([1, 2])
-    refute parser.validate([2, 1], false)
-    refute parser.validate([1, 1, 2, 2], false)
-    refute parser.validate([1, 2, 1, 2], false)
-    refute parser.validate([1, 2, 1], false)
+    assert parser.validate_for_test([])
+    refute parser.validate_for_test([1], false)
+    assert parser.validate_for_test([1, 2])
+    refute parser.validate_for_test([2, 1], false)
+    refute parser.validate_for_test([1, 1, 2, 2], false)
+    refute parser.validate_for_test([1, 2, 1, 2], false)
+    refute parser.validate_for_test([1, 2, 1], false)
   end
 
   def test_validate_occur1n  # XXX need indirection for now
@@ -306,13 +320,13 @@ HERE
     # pp parser.rules
     # puts "APR:"
     # pp parser.apr
-    refute parser.validate([], false)
-    refute parser.validate([1], false)
-    assert parser.validate([1, 2])
-    refute parser.validate([2, 1], false)
-    refute parser.validate([1, 1, 2, 2], false)
-    assert parser.validate([1, 2, 1, 2])
-    refute parser.validate([1, 2, 1], false)
+    refute parser.validate_for_test([], false)
+    refute parser.validate_for_test([1], false)
+    assert parser.validate_for_test([1, 2])
+    refute parser.validate_for_test([2, 1], false)
+    refute parser.validate_for_test([1, 1, 2, 2], false)
+    assert parser.validate_for_test([1, 2, 1, 2])
+    refute parser.validate_for_test([1, 2, 1], false)
   end
 
   def test_validate_occur0n  # XXX need indirection for now
@@ -325,13 +339,13 @@ HERE
     # pp parser.rules
     # puts "APR:"
     # pp parser.apr
-    assert parser.validate([])
-    refute parser.validate([1], false)
-    assert parser.validate([1, 2])
-    refute parser.validate([2, 1], false)
-    refute parser.validate([1, 1, 2, 2], false)
-    assert parser.validate([1, 2, 1, 2])
-    refute parser.validate([1, 2, 1], false)
+    assert parser.validate_for_test([])
+    refute parser.validate_for_test([1], false)
+    assert parser.validate_for_test([1, 2])
+    refute parser.validate_for_test([2, 1], false)
+    refute parser.validate_for_test([1, 1, 2, 2], false)
+    assert parser.validate_for_test([1, 2, 1, 2])
+    refute parser.validate_for_test([1, 2, 1], false)
   end
 
 
@@ -346,16 +360,16 @@ HERE
     # puts "APR:"
     # pp parser.apr
     assert_includes [[1, 2, 1, 2], [1, 2, 1, 2, 1, 2]], parser.generate
-    refute parser.validate([], false)
-    refute parser.validate([1], false)
-    refute parser.validate([1, 2], false)
-    refute parser.validate([2, 1], false)
-    assert parser.validate([1, 2, 1, 2])
-    assert parser.validate([1, 2, 1, 2, 1, 2])
-    refute parser.validate([1, 2, 1, 2, 1, 2, 1, 2], false)
-    refute parser.validate([1, 1, 2, 2, 2], false)
-    refute parser.validate([1, 1, 1, 2, 2, 2], false)
-    refute parser.validate([1, 2, 1], false)
+    refute parser.validate_for_test([], false)
+    refute parser.validate_for_test([1], false)
+    refute parser.validate_for_test([1, 2], false)
+    refute parser.validate_for_test([2, 1], false)
+    assert parser.validate_for_test([1, 2, 1, 2])
+    assert parser.validate_for_test([1, 2, 1, 2, 1, 2])
+    refute parser.validate_for_test([1, 2, 1, 2, 1, 2, 1, 2], false)
+    refute parser.validate_for_test([1, 1, 2, 2, 2], false)
+    refute parser.validate_for_test([1, 1, 1, 2, 2, 2], false)
+    refute parser.validate_for_test([1, 2, 1], false)
   end
 
 
@@ -370,16 +384,16 @@ HERE
     # puts "APR:"
     # pp parser.apr
     assert_includes [[1, 2, 1, 2], [1, 2, 1, 2, 1, 2]], parser.generate
-    refute parser.validate([], false)
-    refute parser.validate([1], false)
-    refute parser.validate([1, 2], false)
-    refute parser.validate([2, 1], false)
-    refute parser.validate([1, 2, 1, 2], false) # !!! PEG semantics gets us here
-    assert parser.validate([1, 2, 1, 2, 1, 2])
-    refute parser.validate([1, 2, 1, 2, 1, 2, 1, 2], false)
-    refute parser.validate([1, 1, 2, 2, 2], false)
-    refute parser.validate([1, 1, 1, 2, 2, 2], false)
-    refute parser.validate([1, 2, 1], false)
+    refute parser.validate_for_test([], false)
+    refute parser.validate_for_test([1], false)
+    refute parser.validate_for_test([1, 2], false)
+    refute parser.validate_for_test([2, 1], false)
+    refute parser.validate_for_test([1, 2, 1, 2], false) # !!! PEG semantics gets us here
+    assert parser.validate_for_test([1, 2, 1, 2, 1, 2])
+    refute parser.validate_for_test([1, 2, 1, 2, 1, 2, 1, 2], false)
+    refute parser.validate_for_test([1, 1, 2, 2, 2], false)
+    refute parser.validate_for_test([1, 1, 1, 2, 2, 2], false)
+    refute parser.validate_for_test([1, 2, 1], false)
   end
 
 
@@ -422,7 +436,7 @@ HERE
       g = parser.generate
       # pp g
       assert expected1 == g || expected2 == g
-      assert parser.validate(g)
+      assert parser.validate_for_test(g)
     }
   end
 
@@ -438,7 +452,7 @@ HERE
       # pp ["tasa", g]
       bar = g['bar']
       assert bar == true || Integer(bar)
-      assert parser.validate(g)
+      assert parser.validate_for_test(g)
     }
   end
 
@@ -454,9 +468,9 @@ HERE
       # 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)
+      assert parser.validate_for_test(g)
+      refute parser.validate_for_test(g.merge(foo: 3), false)
+      refute parser.validate_for_test(g.merge(bar: "baz"), false)
     }
   end
 
@@ -467,7 +481,7 @@ test = {
 }
 HERE
     # pp parser.rules
-    parser.validate({})
+    parser.validate_for_test({})
     10.times {
       g = parser.generate
       # pp ["tasag", g]
@@ -475,9 +489,9 @@ HERE
         bar = g['bar']
         fail "GGG #{g.inspect}" unless 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)
+        assert parser.validate_for_test(g)
+        refute parser.validate_for_test(g.merge(foo: 3), false)
+        refute parser.validate_for_test(g.merge(bar: "baz"), false)
       end
     }
   end
@@ -506,7 +520,7 @@ HERE
       assert_equal g.size, 2
       assert [1, 2].include? g[0]
       assert [3, 4].include? g[1]
-      assert parser.validate(g)
+      assert parser.validate_for_test(g)
     }
   end
 
@@ -527,7 +541,7 @@ HERE
       assert [1, 2].include? g[0]
       assert [5, 6].include? g[1]
       assert [3, 4].include? g[2]
-      assert parser.validate(g)
+      assert parser.validate_for_test(g)
     }
   end
 
@@ -553,15 +567,15 @@ HERE
       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)
+      assert parser.validate_for_test(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)
+    refute parser.validate_for_test([1, 5, 8, 9], false)
+    refute parser.validate_for_test([1, 5, 3], false)
+    assert parser.validate_for_test([1, 5, 4, 5])
+    refute parser.validate_for_test([1, 5, 4, 9], false)
+    assert parser.validate_for_test([1, 5, 4, 9, 10])
+    refute parser.validate_for_test([1, 5, 4, 3], false)
+    refute parser.validate_for_test([1, 5, 4, 9, 10, 3], false)
   end
 
   def test_validate_number_key
@@ -574,7 +588,7 @@ HERE
     # pp parser.rules
     expected = [{1 => 2}, {3.0 => "a"}, {'foo' => "bar"}]
     assert_equal expected, parser.generate
-    assert parser.validate(expected)
+    assert parser.validate_for_test(expected)
   end
 
   def test_validate_json_float
@@ -591,12 +605,12 @@ beer = 3.14 / 6.28
 HERE
     # pp parser.rules
     # pp parser.generate
-    refute parser.validate({}, false)
-    assert parser.validate({"f16" => 1.5, "foo" => 1, "f64" => 1.1, "bar" => 3.14})
-    assert parser.validate({"f16" => 1.5, "foo" => 1, "f64" => 1.1, "bar" => 6.28})
-    refute parser.validate({"f16" => 1.5, "foo" => 1, "f64" => 1.1, "bar" => 3.15}, false)
-    assert parser.validate({"f16" => 1.5, "foo" => 1, "f64" => 1.1})
-    refute parser.validate({"f16" => 1, "foo" => 1, "f64" => 1.1}, false)
+    refute parser.validate_for_test({}, false)
+    assert parser.validate_for_test({"f16" => 1.5, "foo" => 1, "f64" => 1.1, "bar" => 3.14})
+    assert parser.validate_for_test({"f16" => 1.5, "foo" => 1, "f64" => 1.1, "bar" => 6.28})
+    refute parser.validate_for_test({"f16" => 1.5, "foo" => 1, "f64" => 1.1, "bar" => 3.15}, false)
+    assert parser.validate_for_test({"f16" => 1.5, "foo" => 1, "f64" => 1.1})
+    refute parser.validate_for_test({"f16" => 1, "foo" => 1, "f64" => 1.1}, false)
   end
 
   def test_validate_tags
@@ -612,13 +626,13 @@ solid = tstr
 HERE
     # pp parser.rules
     # pp parser.generate
-    refute parser.validate({}, false)
-    refute parser.validate(CBOR::Tagged.new(55799, CBOR::Tagged.new(997, 1)), false)
-    refute parser.validate(CBOR::Tagged.new(55799, CBOR::Tagged.new(998, 1)), false)
-    assert parser.validate(CBOR::Tagged.new(55799, CBOR::Tagged.new(998, "cornflakes")))
-    assert parser.validate(CBOR::Tagged.new(55799, CBOR::Tagged.new(999, [0, "barley"])))
-    refute parser.validate(CBOR::Tagged.new(55799, CBOR::Tagged.new(999, [0, 1])), false)
-    refute parser.validate(CBOR::Tagged.new(55799, CBOR::Tagged.new(999, [0, "barley", 1])), false)
+    refute parser.validate_for_test({}, false)
+    refute parser.validate_for_test(CBOR::Tagged.new(55799, CBOR::Tagged.new(997, 1)), false)
+    refute parser.validate_for_test(CBOR::Tagged.new(55799, CBOR::Tagged.new(998, 1)), false)
+    assert parser.validate_for_test(CBOR::Tagged.new(55799, CBOR::Tagged.new(998, "cornflakes")))
+    assert parser.validate_for_test(CBOR::Tagged.new(55799, CBOR::Tagged.new(999, [0, "barley"])))
+    refute parser.validate_for_test(CBOR::Tagged.new(55799, CBOR::Tagged.new(999, [0, 1])), false)
+    refute parser.validate_for_test(CBOR::Tagged.new(55799, CBOR::Tagged.new(999, [0, "barley", 1])), false)
   end
 
   def test_nested_group_many1
@@ -653,11 +667,11 @@ HERE
     10.times {
       assert parser.generate.between?(0, 12)
     }
-    assert parser.validate(0)
-    assert parser.validate(7)
-    assert parser.validate(12)
-    refute parser.validate(-1, false)
-    refute parser.validate(13, false)
+    assert parser.validate_for_test(0)
+    assert parser.validate_for_test(7)
+    assert parser.validate_for_test(12)
+    refute parser.validate_for_test(-1, false)
+    refute parser.validate_for_test(13, false)
   end
 
   def test_range_integer_excl
@@ -667,12 +681,12 @@ HERE
     10.times {
       assert parser.generate.between?(0, 12)
     }
-    assert parser.validate(0)
-    assert parser.validate(7)
-    refute parser.validate(7.0, false)
-    assert parser.validate(12)
-    refute parser.validate(-1, false)
-    refute parser.validate(13, false)
+    assert parser.validate_for_test(0)
+    assert parser.validate_for_test(7)
+    refute parser.validate_for_test(7.0, false)
+    assert parser.validate_for_test(12)
+    refute parser.validate_for_test(-1, false)
+    refute parser.validate_for_test(13, false)
   end
 
   def test_range_float
@@ -684,14 +698,14 @@ HERE
     10.times {
       assert parser.generate.between?(0.5, 12.5)
     }
-    refute parser.validate(0.0, false)
-    assert parser.validate(0.5)
-    assert parser.validate(7.0)
-    refute parser.validate(7, false)
-    assert parser.validate(12.0)
-    assert parser.validate(12.5)
-    refute parser.validate(-1.0, false)
-    refute parser.validate(13.0, false)
+    refute parser.validate_for_test(0.0, false)
+    assert parser.validate_for_test(0.5)
+    assert parser.validate_for_test(7.0)
+    refute parser.validate_for_test(7, false)
+    assert parser.validate_for_test(12.0)
+    assert parser.validate_for_test(12.5)
+    refute parser.validate_for_test(-1.0, false)
+    refute parser.validate_for_test(13.0, false)
   end
 
   def test_enum
@@ -852,7 +866,7 @@ HERE
     assert String === gen
     assert gen.bytesize == 3
     pp gen
-    assert parser.validate(gen)
+    assert parser.validate_for_test(gen)
   end
 
 
@@ -866,11 +880,11 @@ HERE
       assert Integer === gen
       assert gen < 2**24
       assert gen >= 0
-      assert parser.validate(gen)
+      assert parser.validate_for_test(gen)
     end
-    refute parser.validate(-1, false)
-    refute parser.validate(2**24, false)
-    refute parser.validate(2**218, false)
+    refute parser.validate_for_test(-1, false)
+    refute parser.validate_for_test(2**24, false)
+    refute parser.validate_for_test(2**218, false)
   end
 
   def test_bits_annotation
@@ -881,11 +895,11 @@ HERE
     gen = parser.generate
     assert String === gen
     pp gen                      # should mostly be "*"
-    assert parser.validate(gen)
-    assert parser.validate("\x08".b)
-    refute parser.validate("\x01".b, false)
-    refute parser.validate("\x10".b, false)
-    refute parser.validate("\x40".b, false)
+    assert parser.validate_for_test(gen)
+    assert parser.validate_for_test("\x08".b)
+    refute parser.validate_for_test("\x01".b, false)
+    refute parser.validate_for_test("\x10".b, false)
+    refute parser.validate_for_test("\x40".b, false)
   end
 
   def test_bits_annotation_on_uint
@@ -896,11 +910,11 @@ HERE
     gen = parser.generate
     assert Integer === gen
     pp gen                      # should mostly be 42
-    assert parser.validate(gen)
-    assert parser.validate(1 << 3)
-    refute parser.validate(1 << 0, false)
-    refute parser.validate(1 << 4, false)
-    refute parser.validate(1 << 6, false)
+    assert parser.validate_for_test(gen)
+    assert parser.validate_for_test(1 << 3)
+    refute parser.validate_for_test(1 << 0, false)
+    refute parser.validate_for_test(1 << 4, false)
+    refute parser.validate_for_test(1 << 6, false)
   end
 
   def test_regexp_annotation
@@ -912,12 +926,12 @@ HERE
       gen = parser.generate
       assert String === gen
       pp gen
-      assert parser.validate(gen)
+      assert parser.validate_for_test(gen)
     end
-    assert parser.validate("reg")
-    assert parser.validate("regfoo")
-    refute parser.validate("foo", false)
-    refute parser.validate("re", false)
+    assert parser.validate_for_test("reg")
+    assert parser.validate_for_test("regfoo")
+    refute parser.validate_for_test("foo", false)
+    refute parser.validate_for_test("re", false)
   end
 
   def test_cbor_annotation1
@@ -929,12 +943,12 @@ HERE
       gen = parser.generate
       assert_equal "\x01", gen
       pp gen
-      assert parser.validate(gen)
+      assert parser.validate_for_test(gen)
     end
-    assert parser.validate("\x01".b)
-    assert parser.validate("\x18\x01".b)
-    refute parser.validate("1", false)
-    refute parser.validate("\x00".b, false)
+    assert parser.validate_for_test("\x01".b)
+    assert parser.validate_for_test("\x18\x01".b)
+    refute parser.validate_for_test("1", false)
+    refute parser.validate_for_test("\x00".b, false)
   end
 
   def test_cbor_annotation_uint
@@ -947,13 +961,13 @@ HERE
       assert String === gen
       assert_equal 0, gen.getbyte(0) >> 5
       pp ["CAU", gen]
-      assert parser.validate(gen)
+      assert parser.validate_for_test(gen)
     end
-    assert parser.validate("\x01".b)
-    assert parser.validate("\x00".b)
-    assert parser.validate("\x18\x01".b)
-    refute parser.validate("1", false)
-    refute parser.validate("\x00\x00".b, false)
+    assert parser.validate_for_test("\x01".b)
+    assert parser.validate_for_test("\x00".b)
+    assert parser.validate_for_test("\x18\x01".b)
+    refute parser.validate_for_test("1", false)
+    refute parser.validate_for_test("\x00\x00".b, false)
   end
 
   def test_cborseq_annotation_uint
@@ -976,12 +990,12 @@ HERE
       assert String === gen
       pp ["CAUA", gen]
       assert_equal 0, gen.getbyte(0) >> 5 unless gen == ''
-      assert parser.validate(gen)
+      assert parser.validate_for_test(gen)
     end
-    assert parser.validate("\x01".b)
-    assert parser.validate("\x18\x01".b)
-    refute parser.validate("1", false)
-    refute parser.validate("\x00\x00\x00\x00\x00".b, false)
+    assert parser.validate_for_test("\x01".b)
+    assert parser.validate_for_test("\x18\x01".b)
+    refute parser.validate_for_test("1", false)
+    refute parser.validate_for_test("\x00\x00\x00\x00\x00".b, false)
 end
 
 def test_and_annotation
@@ -994,11 +1008,11 @@ HERE
       gen = parser.generate
       assert Integer === gen
       pp ["CAA", gen]
-      assert parser.validate(gen)
+      assert parser.validate_for_test(gen)
     end
-    assert parser.validate(1)
-    refute parser.validate(-1, false)
-    refute parser.validate(0, false)
+    assert parser.validate_for_test(1)
+    refute parser.validate_for_test(-1, false)
+    refute parser.validate_for_test(0, false)
 end
 
 def test_within_annotation
@@ -1011,11 +1025,11 @@ HERE
       gen = parser.generate
       assert Integer === gen
       pp ["CWA", gen]           # should also generate some warnings
-      assert parser.validate(gen)
+      assert parser.validate_for_test(gen)
     end
-    assert parser.validate(1)
-    refute parser.validate(-1, false)
-    refute parser.validate(0, false)
+    assert parser.validate_for_test(1)
+    refute parser.validate_for_test(-1, false)
+    refute parser.validate_for_test(0, false)
 end
 
   def test_dcaf
@@ -1132,7 +1146,7 @@ HERE
     10.times {
       g = parser.generate
       # pp ["recurse-test1", g]
-      assert parser.validate(g)
+      assert parser.validate_for_test(g)
     }
   end
 
@@ -1158,7 +1172,7 @@ HERE
     10.times {
       g = parser.generate
       # pp ["non-recurse-test", g]
-      assert parser.validate(g)
+      assert parser.validate_for_test(g)
     }
   end
 
@@ -1174,7 +1188,7 @@ HERE
     10.times {
       g = parser.generate
       pp ["recurse-group-test", g]
-      assert parser.validate(g)
+      assert parser.validate_for_test(g)
     }
   end
 
@@ -1192,8 +1206,8 @@ HERE
     10.times {
       g = parser.generate
       # pp ["recurse-group-test2", g]
-      assert parser.validate(g)
-      refute parser.validate(g.merge(baz: 3), false)
+      assert parser.validate_for_test(g)
+      refute parser.validate_for_test(g.merge(baz: 3), false)
     }
   end
 
@@ -1219,7 +1233,7 @@ HERE
     # puts "empty_group RULES:"
     # pp parser.rules
     assert_equal({}, parser.generate)
-    assert parser.validate({})
+    assert parser.validate_for_test({})
   end
 
 
@@ -1234,7 +1248,7 @@ HERE
     # puts "empty_group_sp RULES:"
     # pp parser.rules
     assert_equal({}, parser.generate)
-    assert parser.validate({})
+    assert parser.validate_for_test({})
   end
 
 
@@ -1251,7 +1265,7 @@ HERE
     # puts "empty_group_sp RULES:"
     # pp parser.rules
     assert_equal({}, parser.generate)
-    assert parser.validate({})
+    assert parser.validate_for_test({})
   end
 
   def test_simple_group_augmented
@@ -1272,9 +1286,9 @@ HERE
       v[parser.generate["abs"]] = true
     end
     assert_equal({3 => true, -3 => true, 5 => true}, v)
-    assert parser.validate({"abs" => 3})
-    assert parser.validate({"abs" => 5})
-    assert parser.validate({"abs" => -3})
+    assert parser.validate_for_test({"abs" => 3})
+    assert parser.validate_for_test({"abs" => 5})
+    assert parser.validate_for_test({"abs" => -3})
   end
 
   def test_simple_group_augmented_uninitialized
@@ -1294,8 +1308,8 @@ HERE
       v[parser.generate["abs"]] = true
     end
     assert_equal({3 => true, -3 => true}, v)
-    assert parser.validate({"abs" => 3})
-    assert parser.validate({"abs" => -3})
+    assert parser.validate_for_test({"abs" => 3})
+    assert parser.validate_for_test({"abs" => -3})
   end
 
 
@@ -1316,8 +1330,8 @@ HERE
       v[parser.generate["abs"]] = true
     end
     assert_equal({3 => true, -3 => true}, v)
-    assert parser.validate({"abs" => 3})
-    assert parser.validate({"abs" => -3})
+    assert parser.validate_for_test({"abs" => 3})
+    assert parser.validate_for_test({"abs" => -3})
   end
 
 
@@ -1356,7 +1370,7 @@ HERE
     # puts "simple_type_augmented RULES:"
     # pp parser.rules
     assert_equal parser.generate, {"abs" => 17}
-    assert parser.validate({"abs" => 17})
+    assert parser.validate_for_test({"abs" => 17})
   end
 
 
@@ -1369,7 +1383,7 @@ HERE
     # puts "simple_type_augmented RULES:"
     # pp parser.rules
     assert_equal parser.generate, {"a" => 1}
-    assert parser.validate({"a" => 1})
+    assert parser.validate_for_test({"a" => 1})
   end
 
 
@@ -1382,7 +1396,7 @@ HERE
     # puts "simple_type_augmented RULES:"
     # pp parser.rules
     assert_equal parser.generate, {}
-    assert parser.validate({})
+    assert parser.validate_for_test({})
   end
 
   def test_aaa_validate_more_socket_in_star
@@ -1407,10 +1421,10 @@ HERE
     # pp parser.rules
     10.times do
       g = parser.generate
-      # pp g
-      assert parser.validate(g)
+      pp g
+      assert parser.validate_for_test(g)
     end
-    assert parser.validate({"seq" => 1, "ack" => 2})
+    assert parser.validate_for_test({"seq" => 1, "ack" => 2})
   end
 
 
@@ -1431,8 +1445,8 @@ HERE
       v[parser.generate["abs"]] = true
     end
     assert_equal({3 => true, -3 => true}, v)
-    assert parser.validate({"abs" => 3})
-    assert parser.validate({"abs" => -3})
+    assert parser.validate_for_test({"abs" => 3})
+    assert parser.validate_for_test({"abs" => -3})
   end
 
 
@@ -1444,7 +1458,7 @@ c = ()
 HERE
 # XXX: Pending
 #    assert_equal({}, parser.generate)
-#    assert parser.validate({})
+#    assert parser.validate_for_test({})
   end
 
   def test_group_occur
@@ -1462,7 +1476,7 @@ HERE
     # puts "empty_group_sp RULES:"
     pp parser.rules
     assert_equal parser.rules, parser2.rules
-    # assert parser.validate({})
+    # assert parser.validate_for_test({})
     10.times {
       g = parser2.generate
       # pp ["group-occur", g]
@@ -1470,8 +1484,8 @@ HERE
       g.each_slice(2) do |sl|
         assert_equal sl, [1, 2]
       end
-      assert parser2.validate(g)
-      refute parser2.validate(g << 1, false)
+      assert parser2.validate_for_test(g)
+      refute parser2.validate_for_test(g << 1, false)
     }
   end
 
@@ -1529,8 +1543,9 @@ HERE
 a = {a: nil}
 HERE
     g = parser.generate
-    assert parser.validate(g)
+    assert parser.validate_for_test(g)
     assert_equal g, {"a" => nil}
+    assert_equal g.cbor_clone, {"a" => nil}
   end
 
   def test_extractor_ignores_map

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cddl
 version: !ruby/object:Gem::Version
-  version: 0.7.2
+  version: 0.7.3
 platform: ruby
 authors:
 - Carsten Bormann
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-11 00:00:00.000000000 Z
+date: 2016-04-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cbor-diag
@@ -104,6 +104,7 @@ files:
 - test-data/dcaf.cddl
 - test-data/dcaf1.cddl
 - test-data/extractor-demo.cddl
+- test-data/grasp-01-extract.cddl
 - test-data/grasp-01-test.cddl
 - test-data/grasp-01.cddl
 - test-data/grasp-v1.cddl
@@ -122,6 +123,7 @@ files:
 - test-data/wrong1a.cddl
 - test-data/wrong2.cddl
 - test-data/wrong2a.cddl
+- test-data/xmlmig.cddl
 - test/test-cddl.rb
 homepage: http://github.com/cabo/cddl
 licenses: