divine 0.0.1 → 0.0.2

data/test/basic_complex_test/ruby_test/ruby_test.rb

@@ -0,0 +1,68 @@
+require_relative 'test_babel.rb'
+require 'minitest/autorun'
+
+class TestBabelTestBasic < MiniTest::Unit::TestCase
+
+  def setup
+    
+  end
+
+  def test_basic
+    puts "Basic Test"
+    testbasic_ser = BabelTest::TestBasic.new
+    testbasic_ser.i8 = 0x0F
+    testbasic_ser.i16 = 0X1234
+    testbasic_ser.i32 = 0x567890AB
+    testbasic_ser.str = "abc\n123\t\""
+    testbasic_ser.ip = "192.168.0.1"
+    testbasic_ser.guid = (300..302).to_s
+    
+    ser = testbasic_ser.serialize
+    serialize(ser)
+    res = deserialize()
+
+    testbasic_deser = BabelTest::TestBasic.new
+    testbasic_deser.deserialize res
+
+    assert testbasic_ser.i8 == testbasic_deser.i8
+    assert testbasic_ser.i16 == testbasic_deser.i16
+    assert testbasic_ser.i32 == testbasic_deser.i32
+    assert testbasic_ser.str == testbasic_deser.str
+    assert testbasic_ser.ip == testbasic_deser.ip
+    assert testbasic_ser.guid == testbasic_deser.guid
+  end
+
+  def test_complex
+    testcomplex_ser = BabelTest::TestComplex.new
+    testcomplex_ser.list1 = [0, 1, 255, 0x7FFFFFFF, 0x7FFFFFFF+1, 0xFFFFFFFE, 0xFFFFFFFF]
+    testcomplex_ser.list2 = [0,1, 15,16, 127,128, 254,255]
+    testcomplex_ser.map1[0] = 10
+    testcomplex_ser.map1[10] = 100
+    testcomplex_ser.map2["Hello_1"] = [BabelTest::Entry.new, BabelTest::Entry.new, BabelTest::Entry.new]
+    testcomplex_ser.map2["Hello_2"] = [BabelTest::Entry.new, BabelTest::Entry.new]
+    
+    ser = testcomplex_ser.serialize
+    serialize(ser)
+    res = deserialize()
+
+    testcomplex_deser = BabelTest::TestComplex.new
+    testcomplex_deser.deserialize res
+
+    assert testcomplex_ser.list1.sort == testcomplex_deser.list1.sort
+    assert testcomplex_ser.list2.sort == testcomplex_deser.list2.sort
+    assert testcomplex_ser.map1 == testcomplex_deser.map1
+    testcomplex_ser.map2.keys.each do |k|
+      assert testcomplex_ser.map2[k].length == testcomplex_deser.map2[k].length
+    end
+  end
+
+  def serialize(data)
+    File.open("test/basic_complex_test/ruby_test/bin.babel.rb", "w+b") do |f|
+      f.write(data)
+    end
+  end
+
+  def deserialize()
+    mem_buf = File.new('test/basic_complex_test/ruby_test/bin.babel.rb').binmode
+  end
+end

data/test/basic_complex_test/ruby_test/test_babel.rb

@@ -0,0 +1,368 @@
+module BabelTest
+
+
+  class BabelBase < Object
+    public
+    def serialize
+      out = []
+      serialize_internal(out)
+      out.flatten.pack("C*")
+    end
+
+    protected
+    ### Read methods ###
+    def read_int8(data)
+      data.getbyte
+    end
+
+    def read_int16(data)
+      (data.getbyte << 8) | read_int8(data)
+    end
+
+    def read_int24(data)
+      (data.getbyte << 16) | read_int16(data)
+    end
+
+    def read_int32(data)
+      (data.getbyte << 24) | read_int24(data)
+    end
+
+    def read_bool(data)
+      read_int8(data) == 1
+    end
+
+    def read_string(data)
+      data.read(read_int16(data)).force_encoding('UTF-8')
+    end
+
+    def read_binary(data)
+      data.read(read_int32(data))
+    end
+
+    def read_short_binary(data)
+      data.read(read_int8(data))
+    end
+
+    def read_ip_number(data)
+      ips = read_short_binary(data)
+      if ips.size == 4
+        read_ipv4_number(ips)
+      else
+        read_ipv6_number(ips)
+      end
+    end
+
+    def read_ipv4_number(ips)
+      ips.bytes.to_a.join('.')
+    end
+
+    def read_ipv6_number(ips)
+      ipv6 = []
+      ips.bytes.each_slice(2) do |t|
+        fst = t[0]
+        lst = t[1]
+        tmp = ""
+        tmp = fst.to_s 16 if fst != 0
+        if fst != 0 and lst < 10
+          tmp << "0#{lst.to_s 16}"
+        elsif fst != 0 and lst > 10 or fst == 0 and lst > 0
+          tmp << lst.to_s(16)
+        end
+        ipv6.push(tmp)
+      end
+      ipv6.join(':').gsub(/:{2,}/, "::")
+    end
+    
+    ### Write methods ###
+    def write_int8(v, out)
+      v = v.to_i
+      raise_error "Too large int8 number: #{v}" if v > 0xFF  # Max 255
+      raise_error "a negative number passed  to int8 number: #{v}" if v < 0
+      out << v
+    end
+
+    def write_int16(v, out)
+      v = v.to_i
+      raise_error "Too large int16 number: #{v}" if v > 0xFFFF # Max 65.535 
+      raise_error "a negative number passed  to int16 number: #{v}" if v < 0
+      write_int8( v >> 8 & 0xFF, out)
+      write_int8( v & 0xFF, out)
+    end
+
+    def write_int24(v, out)
+      v = v.to_i
+      raise_error "Too large int24 number: #{v}" if v > 0xFFFFFF # Max 16.777.215
+      raise_error "a negative number passed  to int24 number: #{v}" if v < 0 # In Case added to ruby declaration
+      write_int8( v >> 16 & 0xFF, out)
+      write_int16( v & 0xFFFF, out)
+    end
+
+    def write_int32(v, out)
+      v = v.to_i
+      raise_error "Too large int32 number: #{v}" if v > 0xFFFFFFFF # Max 4.294.967.295
+      raise_error "a negative number passed  to int32 number: #{v}" if v < 0
+      write_int8( v >> 24 & 0xFF, out)
+      write_int24( v & 0xFFFFFF, out)
+    end
+
+    def write_bool(v, out)
+      write_int8(v ? 1 : 0, out)
+    end
+
+    def write_string(v, out)
+      s = force_to_utf8_string(v)
+      raise_error "Too large string: #{s.bytesize} bytes" if s.bytesize > 0xFFFF
+      write_int16(s.bytesize, out)
+      out << s.bytes.to_a
+    end
+
+    def write_binary(v, out)
+      if v.is_a?(Array)
+        raise_error "Too large binary: #{v.size} (#{v.class.name})" unless v.size < 0xFFFFFFFF 
+        write_int32(v.size, out)
+        v.each do |x|
+          write_int8(x, out)
+        end
+      elsif v.is_a?(String)
+        raise_error "Too large binary: #{v.size} (#{v.class.name})" unless v.size < 0xFFFFFFFF 
+        write_int32(v.size, out)
+        out << v.bytes.to_a
+      else 
+        raise_error "Unsupported binary 'nil'" if v == nil
+        raise_error "Unsupported binary of type '#{v.class.name}'"
+      end
+    end
+
+    def write_16_binary(v, out)
+      if v.is_a?(Array)
+        raise_error "Too large 16 binary: #{v.size} (#{v.class.name})" unless v.size*2 < 0xFF
+        write_int8(v.size * 2, out) # IPv6 consists of 8 parts each of them has zise of 2 bytes
+        v.each do |x|
+          write_int16(x, out)
+        end
+      else 
+        raise_error "Unsupported binary 'nil'" if v == nil
+        raise_error "Unsupported binary of type '#{v.class.name}'"
+      end
+    end
+
+    def write_short_binary(v, out)
+      if v.is_a?(Array)
+        raise_error "Too large short_binary: #{v.size} (#{v.class.name})" unless v.size < 0xFF
+        write_int8(v.size, out)
+        v.each do |x|
+          write_int8(x, out)
+        end
+      elsif v.is_a?(String)
+        raise_error "To large short_binary: #{v.size} (#{v.class.name})" unless v.size < 0xFF
+        write_int8(v.size, out)
+        out << v.bytes.to_a
+      else 
+        raise_error "Unsupported binary 'nil'" if v == nil
+        raise_error "Unsupported binary of type '#{v.class.name}'"
+      end
+    end
+
+    def write_ip_number(v, out)
+      if v.is_a?(Array)
+        if v.size == 4
+          write_ipv4_number(v, out);
+        else
+          write_ipv6_number(v, out);
+        end
+      elsif v.is_a?(String)
+        if v.include?":"
+          write_ipv6_number(v, out);
+        else
+          write_ipv4_number(v, out);
+        end
+      else
+        raise_error "Unknown IP number '#{v}'"
+      end
+    end
+
+    def write_ipv4_number(v,out)
+      if v.is_a?(Array)
+        raise_error "Unknown IP v4 number #{v}" unless v.size == 0 || v.size == 4 # Only IPv4 for now 
+        write_short_binary(v, out)
+      elsif v.is_a?(String)
+        ss = v.split(/\./).map do |s|
+          s.to_i
+        end
+        write_ipv4_number(ss, out)
+      else
+        raise_error "Unknown IP number '#{v}'"
+      end
+    end
+
+    def write_ipv6_number(v, out)
+      if v.is_a?(Array)
+        write_16_binary(v, out)
+      elsif v.is_a?(String)
+        v = v.gsub(" ","") + " " # Temporary: To avoid the split problem when we have : at the end of "v" 
+        raise_error "Unknown IPv6 number #{v}" unless v.strip.empty? ||
+                                                       v.strip.match(/[^:0-9a-f]+/i) == nil &&  #Should not contains numbers or letters 0-9a-f
+                                                       v.strip.match(/[0-9a-f]+/i) != nil &&   #Should contains numbers or letters 0-9a-f
+                                                       v.match(":{3,}") == nil && 
+                                                       v.split("::").size <= 2
+        ss = v.split(/:/).map do |s|
+          s = s.strip
+	  raise_error "Unknown IPv6 Group #{s}" unless s.size <= 4
+          s.to_i 16
+        end
+        ss = [] if v.strip.empty?
+        raise_error "Unknown IPv6 number #{v}" unless (!v.include?("::") && ss.size == 0 || ss.size == 8) || 
+						       (v.include?("::") && ss.size > 2 && ss.size < 8)
+	write_ipv6_number(ss, out)
+      else
+        raise_error "Unknown IPv6 number '#{v}'"
+      end
+    end
+
+    private
+    def raise_error(msg)
+      raise "[#{self.class.name}] #{msg}" 
+    end
+    
+    def force_to_utf8_string(string)
+      if string.encoding != Encoding::UTF_8
+        string = string.encode(Encoding::UTF_8)
+      end
+      return string
+    end
+  end
+    
+
+
+  class Entry < BabelBase
+
+      def serialize_internal(out)
+        print "+"
+      end
+
+      def deserialize(data)
+        print "-"
+      end
+  end
+    
+
+
+  class TestBasic < BabelBase
+      attr_accessor :i8, :i16, :i32, :str, :ip, :guid
+
+      def initialize()
+          super
+          @i8 ||= 0
+          @i16 ||= 0
+          @i32 ||= 0
+          @str ||= ""
+          @ip ||= ""
+          @guid ||= []
+      end
+
+      def serialize_internal(out)
+        print "+"
+        write_int8(i8, out)
+        write_int16(i16, out)
+        write_int32(i32, out)
+        write_string(str, out)
+        write_ip_number(ip, out)
+        write_binary(guid, out)
+      end
+
+      def deserialize(data)
+        print "-"
+        @i8 = read_int8(data)
+        @i16 = read_int16(data)
+        @i32 = read_int32(data)
+        @str = read_string(data)
+        @ip = read_ip_number(data)
+        @guid = read_binary(data)
+      end
+  end
+    
+
+
+  class TestComplex < BabelBase
+      attr_accessor :list1, :list2, :map1, :map2
+
+      def initialize()
+          super
+          @list1 ||= []
+          @list2 ||= []
+          @map1 ||= {}
+          @map2 ||= {}
+      end
+
+      def serialize_internal(out)
+        print "+"
+        # Serialize list 'list1'
+      write_int32(list1.size, out)
+      list1.each do |var_100|
+         write_int32(var_100, out)
+      end
+        # Serialize list 'list2'
+      write_int32(list2.size, out)
+      list2.each do |var_101|
+         write_int8(var_101, out)
+      end
+        # Serialize map 'map1'
+      write_int32(map1.size, out)
+      map1.each_pair do |var_102, var_103|
+         write_int8(var_102, out)
+         write_int32(var_103, out)
+      end
+        # Serialize map 'map2'
+      write_int32(map2.size, out)
+      map2.each_pair do |var_104, var_105|
+         write_string(var_104, out)
+         write_int32(var_105.size, out)
+         var_105.each do |var_106|
+            var_106.serialize_internal(out)
+         end
+      end
+      end
+
+      def deserialize(data)
+        print "-"
+        # Deserialize list 'list1'
+      @list1 = []
+      var_107 = read_int32(data)
+      (1..var_107).each do
+         var_108 = read_int32(data)
+         @list1 << var_108
+      end
+        # Deserialize list 'list2'
+      @list2 = []
+      var_109 = read_int32(data)
+      (1..var_109).each do
+         var_10a = read_int8(data)
+         @list2 << var_10a
+      end
+        # Deserialize map 'map1'
+      @map1 = {}
+      var_10b = read_int32(data)
+      (1..var_10b).each do
+         var_10c = read_int8(data)
+         var_10d = read_int32(data)
+         @map1[var_10c] = var_10d
+      end
+        # Deserialize map 'map2'
+      @map2 = {}
+      var_10e = read_int32(data)
+      (1..var_10e).each do
+         var_10f = read_string(data)
+         var_110 = []
+         var_111 = read_int32(data)
+         (1..var_111).each do
+            var_112 = Entry.new
+            var_112.deserialize(data)
+            var_110 << var_112
+         end
+         @map2[var_10f] = var_110
+      end
+      end
+  end
+    
+
+end

data/test/binaryTree_test/binaryTree_test.rb

@@ -0,0 +1,19 @@
+
+require 'divine'
+
+struct 'Node' do
+  int32 :i32
+  list  :next_node, :Node  # List of nodes with size equals to 2, just to refer to the next left and right nodes in the tree
+end
+
+struct 'BinaryTree' do
+  list :root_node, :Node   # List of root node of size equals to 1.
+end
+
+if ARGV[0] == "ruby"
+  Divine::CodeGenerator.new.generate(:ruby, file: 'test_binaryTree.rb', module: 'BabelTest', parent_class: "Object", target_dir: 'test/binaryTree_test/ruby_test')
+elsif ARGV[0] == "js"
+  Divine::CodeGenerator.new.generate(:javascript, file: 'test_binaryTree.js', target_dir: 'test/binaryTree_test/js_test')
+elsif ARGV[0] == "java"
+  Divine::CodeGenerator.new.generate(:java, file: 'test_binaryTree.java', target_dir: 'test/binaryTree_test/java_test')
+end