slow_blink 0.0.2 → 0.0.3

data/test/tc_compact_encoder.rb

@@ -0,0 +1,341 @@
+# Copyright (c) 2016 Cameron Harper
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of
+# this software and associated documentation files (the "Software"), to deal in
+# the Software without restriction, including without limitation the rights to
+# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+# the Software, and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+#  
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+# FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+# IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require "test/unit"
+require 'slow_blink'
+
+class TestCompactEncoder < Test::Unit::TestCase
+
+    include SlowBlink
+
+    def test_putU8
+        input = 0x7f
+        output = "".putU8(input)
+        assert_equal("\x7f", output)
+    end
+
+    def test_putU8_big
+        input = 0x80
+        output = "".putU8(input)
+        assert_equal("\x80\x02", output)
+    end
+
+    def test_putU8_tooBig
+        input = 0x100
+        assert_raise do
+            "".putU8(input)
+        end
+    end
+
+    def test_putU8_null
+        input = nil
+        output = "".putU8(input)
+        assert_equal("\xc0", output)
+    end
+
+    def test_putU16_small
+        input = 0xff
+        output = "".putU16(input)
+        assert_equal("\xbf\x03", output)
+    end
+
+    def test_putU16
+        input = 0xffff
+        output = "".putU16(input)
+        assert_equal("\xC2\xff\xff", output)
+    end
+
+    # Blink Specification 3.1
+    def test_putU8_64unsigned
+        input = 64
+        output = "".putU8(input)
+        assert_equal("\x40", output)
+    end
+
+    # Blink Specification 3.1
+    def test_putI8_64signed
+        input = 64
+        output = "".putI8(input)
+        assert_equal("\x80\x01", output)
+    end
+
+    # Blink Specification 3.1
+    def test_putU16_4711unsigned
+        input = 4711
+        output = "".putU16(input)
+        assert_equal("\xa7\x49", output)
+    end
+
+    # Blink Specification 3.1
+    def test_putU32_4294967295unsigned
+        input = 4294967295
+        output = "".putU32(input)
+        assert_equal("\xc4\xff\xff\xff\xff", output)
+    end
+
+    # Blink Specification 3.1
+    def test_putI8_minus64
+        input = -64
+        output = "".putI8(input)
+        assert_equal("\x40", output)
+    end
+
+    # Blink Specification 3.1
+    def test_putI16_minus4711
+        input = -4711
+        output = "".putI16(input)
+        assert_equal("\x99\xb6", output)
+    end
+
+    # Blink Specification 3.1
+    def test_putI32_minus2147483648
+        input = -2147483648
+        output = "".putI32(input)
+        assert_equal("\xc4\x00\x00\x00\x80", output)
+    end
+
+    def test_putFixed
+        input = "hello world"
+        output = "".putFixed(input)
+        assert_equal("hello world", output)
+    end
+
+    def test_putFixedOptional
+        input = "hello world"
+        output = "".putFixedOptional(input)
+        assert_equal("\x01hello world", output)
+    end
+
+    def test_putFixedOptional_null
+        input = nil
+        output = "".putFixedOptional(input)
+        assert_equal("\xc0", output)
+    end
+
+    def test_putString
+        input = "hello world"
+        output = "".putString(input)
+        assert_equal("\x0bhello world", output)
+    end
+
+    def test_putString_null
+        input = nil
+        output = "".putString(input)
+        assert_equal("\xc0", output)
+    end
+
+    def test_putBinary
+        input = "hello world"
+        output = "".putBinary(input)
+        assert_equal("\x0bhello world", output)
+    end
+
+    def test_putBinary_null
+        input = nil
+        output = "".putBinary(input)
+        assert_equal("\xc0", output)
+    end
+
+    def test_putBool_true
+        input = true
+        output = "".putBool(input)
+        assert_equal("\x01", output)
+    end
+
+    def test_putBool_false
+        input = false
+        output = "".putBool(input)
+        assert_equal("\x00", output)
+    end
+
+    def test_putBool_null
+        input = nil
+        output = "".putBool(input)
+        assert_equal("\xc0", output)
+    end
+
+    def test_putF64
+        input = nil
+        output = "".putF64(input)
+        assert_equal("\xc0", output)
+    end
+
+    # Blink Specification 3.1
+    def test_getU8_64unsigned
+        input = "\x40"
+        output = input.getU8!
+        assert_equal(64, output)
+        assert_equal(0, input.size)
+    end
+
+    # Blink Specification 3.1
+    def test_getI8_64signed
+        input = "\x80\x01"
+        output = input.getI8!
+        assert_equal(64, output)
+        assert_equal(0, input.size)
+    end
+
+    # Blink Specification 3.1
+    def test_getU16_4711unsigned
+        input = "\xa7\x49"
+        output = input.getU16!
+        assert_equal(4711, output)
+        assert_equal(0, input.size)
+    end
+
+    # Blink Specification 3.1
+    def test_getU32_4294967295unsigned
+        input = "\xc4\xff\xff\xff\xff"
+        output = input.getU32!
+        assert_equal(4294967295, output)
+        assert_equal(0, input.size)
+    end
+
+    # Blink Specification 3.1
+    def test_getI8_minus64
+        input = "\x40"
+        output = input.getI8!
+        assert_equal(-64, output)
+        assert_equal(0, input.size)
+    end
+
+    # Blink Specification 3.1
+    def test_getI16_minus4711
+        input = "\x99\xb6"
+        output = input.getI16!
+        assert_equal(-4711, output)
+        assert_equal(0, input.size)
+    end
+
+    # Blink Specification 3.1
+    def test_getI32_minus2147483648
+        input = "\xc4\x00\x00\x00\x80"
+        output = input.getI32!
+        assert_equal(-2147483648, output)
+        assert_equal(0, input.size)
+    end
+
+    def test_getBool_true
+        input = "\x01"
+        output = input.getBool!
+        assert_equal(true, output)
+        assert_equal(0, input.size)
+    end
+
+    def test_getBool_false
+        input = "\x00"
+        output = input.getBool!
+        assert_equal(false, output)
+        assert_equal(0, input.size)
+    end
+
+    def test_getBool_other
+        input = "\x02"
+        assert_raise do
+            input.getBool!
+        end
+        assert_equal(0, input.size)
+    end
+
+    def test_getString
+        input = "\x0bhello world"
+        output = input.getString!
+        assert_equal("hello world", output)
+        assert_equal(0, input.size)
+    end
+    
+    def test_getString_null
+        input = "\xc0"
+        output = input.getString!
+        assert_equal(nil, output)
+        assert_equal(0, input.size)
+    end
+
+    def test_getString_eof
+        input = "\x01"
+        assert_raise do
+            input.getString!
+        end
+    end
+
+    def test_getBinary
+        input = "\x0bhello world"
+        output = input.getBinary!
+        assert_equal("hello world", output)
+        assert_equal(0, input.size)
+    end
+
+    def test_getBinary_null
+        input = "\xc0"
+        output = input.getBinary!
+        assert_equal(nil, output)
+        assert_equal(0, input.size)
+    end
+
+    def test_getBinary_eof
+        input = "\x01"
+        assert_raise do
+            input.getBinary!
+        end
+    end
+    
+    def test_getFixed
+        input = "hello world"
+        output = input.getFixed!("hello world".size)
+        assert_equal("hello world", output)
+        assert_equal(0, input.size)
+    end
+
+    def test_getFixed_eof
+        input = ""
+        assert_raise do
+            input.getFixed!(1)
+        end
+    end
+
+    def test_getFixedOptional
+        input = "\x01hello world"
+        output = input.getFixedOptional!("hello world".size)
+        assert_equal("hello world", output)
+        assert_equal(0, input.size)
+    end
+
+    def test_getFixedOptional_null
+        input = "\xc0"
+        output = input.getFixedOptional!("hello world".size)
+        assert_equal(nil, output)
+        assert_equal(0, input.size)
+    end
+
+    def test_getFixedOptional_eof
+        input = "\x01"
+        assert_raise do
+            input.getFixedOptional!(1)
+        end
+    end
+
+    def test_getU32_13548
+        input = "\x01"
+        assert_raise do
+            input.getFixedOptional!(1)
+        end
+    end
+    
+end

data/test/tc_field.rb

@@ -0,0 +1,53 @@
+require "test/unit"
+require 'slow_blink'
+
+class TestField < Test::Unit::TestCase
+
+    include SlowBlink
+
+    def test_optional
+        input = "Test -> u8 one?"
+        schema = Schema.new(SchemaBuffer.new(input))
+        assert_equal(true, schema.ns[nil].group("Test").field("one").opt?)        
+    end
+
+    def test_not_optional
+        input = "Test -> u8 one"
+        schema = Schema.new(SchemaBuffer.new(input))
+        assert_equal(false, schema.ns[nil].group("Test").field("one").opt?)        
+    end
+
+    def test_with_id
+        input = "Test -> u8 one/42"
+        schema = Schema.new(SchemaBuffer.new(input))
+        assert_equal(42, schema.ns[nil].group("Test").field("one").nameWithID.id)
+    end
+
+    def test_with_hexid
+        input = "Test -> u8 one/0x2a"
+        schema = Schema.new(SchemaBuffer.new(input))
+        assert_equal(42, schema.ns[nil].group("Test").field("one").nameWithID.id)
+    end
+
+    def test_without_id
+        input = "Test -> u8 one"
+        schema = Schema.new(SchemaBuffer.new(input))
+        assert_equal(nil, schema.ns[nil].group("Test").field("one").nameWithID.id)
+    end
+
+    def test_reference
+        input = "Ref = u8 Test -> Ref one"
+        schema = Schema.new(SchemaBuffer.new(input))
+        assert_true(schema.ns[nil].group("Test").field("one").type.is_a? REF)
+        assert_true(schema.ns[nil].group("Test").field("one").type.ref.is_a? U8)
+    end
+
+    def test_duplicate_name
+        input = "Ref = u8 Test -> Ref one, Ref one"
+        
+        assert_raise do
+            Schema.new(SchemaBuffer.new(input))
+        end
+    end
+
+end

data/test/tc_group.rb

@@ -0,0 +1,122 @@
+# Copyright (c) 2016 Cameron Harper
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of
+# this software and associated documentation files (the "Software"), to deal in
+# the Software without restriction, including without limitation the rights to
+# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+# the Software, and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+#  
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+# FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+# IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require "test/unit"
+require 'slow_blink'
+
+class TestGroup < Test::Unit::TestCase
+
+    include SlowBlink
+
+    def test_empty_group_without_id
+        input = "Test"
+        schema = Schema.new(SchemaBuffer.new(input))
+        assert_equal("Test", schema.ns[nil].group("Test").nameWithID.name)
+        assert_equal(nil, schema.ns[nil].group("Test").nameWithID.id)
+        assert_equal([], schema.ns[nil].group("Test").fields)
+        assert_equal({}, schema.tagged)        
+    end
+
+    def test_empty_group_with_id
+        input = "Test/0"
+        schema = Schema.new(SchemaBuffer.new(input))
+        assert_equal("Test", schema.ns[nil].group("Test").nameWithID.name)
+        assert_equal(0, schema.ns[nil].group("Test").nameWithID.id)
+        assert_equal([], schema.ns[nil].group("Test").fields)
+        assert_equal({0 => schema.ns[nil].group("Test")}, schema.tagged)
+    end
+
+    def test_empty_group_with_hexid
+        input = "Test/0x2a"
+        schema = Schema.new(SchemaBuffer.new(input))
+        assert_equal("Test", schema.ns[nil].group("Test").nameWithID.name)
+        assert_equal(42, schema.ns[nil].group("Test").nameWithID.id)
+        assert_equal([], schema.ns[nil].group("Test").fields)
+        assert_equal({42 => schema.ns[nil].group("Test")}, schema.tagged)
+    end
+
+    def test_group_of_one_field
+        input = "Test -> u8 one"
+        schema = Schema.new(SchemaBuffer.new(input))
+        assert_equal(1, schema.ns[nil].group("Test").fields.size)
+    end
+
+    def test_group_of_many_field
+        input = "Test -> u8 one, u8 two, u8 three"
+        schema = Schema.new(SchemaBuffer.new(input))
+        assert_equal(3, schema.ns[nil].group("Test").fields.size)        
+    end
+
+    def test_with_supergroup
+        input = "Test : Super Super -> u8 one, u16 two, u32 three"        
+        schema = Schema.new(SchemaBuffer.new(input))
+        assert_equal(3, schema.ns[nil].group("Test").fields.size)
+        assert_true(schema.ns[nil].group("Test").group_kind_of? schema.ns[nil].group("Super"))
+        assert_true(schema.ns[nil].group("Test").field("one") != nil)
+        assert_true(schema.ns[nil].group("Test").field("two") != nil)
+        assert_true(schema.ns[nil].group("Test").field("three") != nil)
+    end
+
+    def test_without_supergroup
+        input = "Test Super -> u8 one, u16 two, u32 three"        
+        schema = Schema.new(SchemaBuffer.new(input))
+        assert_equal(0, schema.ns[nil].group("Test").fields.size)
+        assert_true(!schema.ns[nil].group("Test").group_kind_of?(schema.ns[nil].group("Super")))
+        assert_true(schema.ns[nil].group("Test").field("one") == nil)
+        assert_true(schema.ns[nil].group("Test").field("two") == nil)
+        assert_true(schema.ns[nil].group("Test").field("three") == nil)
+    end
+
+    def test_with_multiple_supergroup
+
+        input = "Test : Super Super : SuperSuper SuperSuper -> u8 one, u16 two, u32 three"
+        schema = Schema.new(SchemaBuffer.new(input))
+        assert_equal(3, schema.ns[nil].group("Test").fields.size)
+        assert_true(schema.ns[nil].group("Test").group_kind_of? schema.ns[nil].group("Super"))
+        assert_true(schema.ns[nil].group("Test").group_kind_of? schema.ns[nil].group("SuperSuper"))
+        assert_true(schema.ns[nil].group("Test").field("one") != nil)
+        assert_true(schema.ns[nil].group("Test").field("two") != nil)
+        assert_true(schema.ns[nil].group("Test").field("three") != nil)
+    end
+
+    def test_with_mixed_supergroup
+        input = "Test : Super -> u32 three Super -> u8 one, u16 two"
+        schema = Schema.new(SchemaBuffer.new(input))
+        assert_equal(3, schema.ns[nil].group("Test").fields.size)
+        assert_true(schema.ns[nil].group("Test").group_kind_of? schema.ns[nil].group("Super"))
+        assert_true(schema.ns[nil].group("Test").field("one") != nil)
+        assert_true(schema.ns[nil].group("Test").field("two") != nil)
+        assert_true(schema.ns[nil].group("Test").field("three") != nil)
+    end
+
+    def test_supergroup_not_group
+        input = "Test : Thing Thing = u8"
+        assert_raise do
+            Schema.new(SchemaBuffer.new(input))
+        end
+    end
+
+    def test_supergroup_unresolved
+        input = "Test : Thing"
+        assert_raise do
+            Schema.new(SchemaBuffer.new(input))
+        end
+    end
+
+end

data/test/tc_incr_annote.rb

@@ -0,0 +1,27 @@
+# Copyright (c) 2016 Cameron Harper
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of
+# this software and associated documentation files (the "Software"), to deal in
+# the Software without restriction, including without limitation the rights to
+# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+# the Software, and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+#  
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+# FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+# IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require "test/unit"
+require 'slow_blink'
+
+class TestIncrAnnote < Test::Unit::TestCase
+
+    include SlowBlink
+
+end

data/test/{integration/tc_inputs.rb → tc_inputs.rb}

@@ -23,25 +23,21 @@ testClass = Class.new(Test::Unit::TestCase) do
             output = nil
 
             # run and intercept stderr output
-            #err = capture_stderr do
+            err = capture_stderr do
 
-                output = SlowBlink::Schema.parse(inputs[__method__][:buffer], filename: inputs[__method__][:fileName])
-                puts output
-                
+                SlowBlink::Schema.new(SlowBlink::SchemaBuffer.new(inputs[__method__][:buffer], filename: inputs[__method__][:fileName]))
             
-            #end
+            end
 
             # there should have been no messages to stderr
-            #assert_equal("", err.string, "unexpected error messages")
+            assert_equal("", err.string, "unexpected error messages")
 
             # if there were messages, forward them to stderr
-            #if err.string != ""
+            if err.string != ""
 
-                #STDERR.puts err.string
+                STDERR.puts err.string
 
-            #end
-
-            #puts output.to_s
+            end
 
         end
 

data/test/tc_model.rb

@@ -0,0 +1,65 @@
+# Copyright (c) 2016 Cameron Harper
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of
+# this software and associated documentation files (the "Software"), to deal in
+# the Software without restriction, including without limitation the rights to
+# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+# the Software, and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+#  
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+# FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+# IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require "test/unit"
+require 'slow_blink'
+
+class TestModel < Test::Unit::TestCase
+
+    include SlowBlink
+
+    def test_think_blink
+        rawSchema = <<-eos
+        OrderExecuted/0x4c ->
+            string Symbol,
+            u64 OrderId,
+            u32 Price,
+            u32 Qty,
+            u8 MatchId
+        eos
+        schema = Schema.new(SchemaBuffer.new(rawSchema))        
+        model = Message::Model.new(schema)
+    end
+
+    def test_from_compact
+        rawSchema = <<-eos
+        OrderExecuted/0x4c ->
+            string Symbol,
+            u64 OrderId,
+            u32 Price,
+            u32 Qty,
+            u8 MatchId
+        eos
+        schema = Schema.new(SchemaBuffer.new(rawSchema))
+    
+        input = "\x0b\x4c\x05hello\x00\x01\x02\x03"
+        model = Message::Model.new(schema)
+        
+        message = model.decode_compact(input)
+        
+        assert_equal("hello", message["Symbol"])
+        assert_equal(0, message["OrderId"])
+        assert_equal(1, message["Price"])
+        assert_equal(2, message["Qty"])
+        assert_equal(3, message["MatchId"])        
+    end
+
+
+
+end