divine 0.0.1 → 0.0.2

data/test/binaryTree_test/ruby_test/test_binaryTree.rb

@@ -0,0 +1,303 @@
+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 BinaryTree < BabelBase
+      attr_accessor :root_node
+
+      def initialize()
+          super
+          @root_node ||= []
+      end
+
+      def serialize_internal(out)
+        print "+"
+        # Serialize list 'root_node'
+      write_int32(root_node.size, out)
+      root_node.each do |var_100|
+         var_100.serialize_internal(out)
+      end
+      end
+
+      def deserialize(data)
+        print "-"
+        # Deserialize list 'root_node'
+      @root_node = []
+      var_101 = read_int32(data)
+      (1..var_101).each do
+         var_102 = Node.new
+         var_102.deserialize(data)
+         @root_node << var_102
+      end
+      end
+  end
+    
+
+
+  class Node < BabelBase
+      attr_accessor :i32, :next_node
+
+      def initialize()
+          super
+          @i32 ||= 0
+          @next_node ||= []
+      end
+
+      def serialize_internal(out)
+        print "+"
+        write_int32(i32, out)
+        # Serialize list 'next_node'
+      write_int32(next_node.size, out)
+      next_node.each do |var_103|
+         var_103.serialize_internal(out)
+      end
+      end
+
+      def deserialize(data)
+        print "-"
+        @i32 = read_int32(data)
+        # Deserialize list 'next_node'
+      @next_node = []
+      var_104 = read_int32(data)
+      (1..var_104).each do
+         var_105 = Node.new
+         var_105.deserialize(data)
+         @next_node << var_105
+      end
+      end
+  end
+    
+
+end

data/test/complex_test/complex_test.rb

@@ -0,0 +1,23 @@
+
+require 'divine'
+
+struct 'IPList' do
+  list :list1, :ip_number
+  list :list2, :ip_number
+end
+
+struct 'Complex' do
+  list (:list1) {
+    map(:string) { 
+      list 'IPList'
+    }
+  }
+end
+
+if ARGV[0] == "ruby"
+  Divine::CodeGenerator.new.generate(:ruby, file: 'test_complex.rb', module: 'BabelTest', parent_class: "Object", target_dir: 'test/complex_test/ruby_test')
+elsif ARGV[0] == "js"
+  Divine::CodeGenerator.new.generate(:javascript, file: 'test_complex.js', target_dir: 'test/complex_test/js_test')
+elsif ARGV[0] == "java"
+  Divine::CodeGenerator.new.generate(:java, file: 'test_complex.java', target_dir: 'test/complex_test/java_test')
+end

data/test/complex_test/java_test/JavaTest.java

@@ -0,0 +1,126 @@
+
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import org.junit.*;
+
+public class JavaTest {
+
+	@Test
+	public void testComplexTest() throws IOException {
+                System.out.println("Test Complex Data Structure");
+		Complex complex_ser = buildObject();
+		serialize(complex_ser);
+		byte[] read = deserialize();
+
+		Complex complex_deser = new Complex();
+		complex_deser.deserialize(new ByteArrayInputStream(read));
+
+		compare(complex_ser, complex_deser);
+	}
+
+	public Complex buildObject() {
+		final IPList ipList_1 = new IPList();
+		ipList_1.list1 = new ArrayList<String>() {
+			{
+				add("10.2.2.1");
+				add("127.0.0.1");
+				add("129.36.58.15");
+			}	
+		};
+
+		ipList_1.list2 = new ArrayList<String>() {
+			{
+				add("2001:db8::ff00:1:8329");
+				add("ff:ac:12::5f");
+				add("1::");
+			}
+		};
+		
+		final IPList ipList_2 = new IPList();
+		ipList_2.list1 = new ArrayList<String>() {
+			{
+				add("100.20.20.10");
+				add("17.10.10.1");
+				add("12.36.68.105");
+			}
+		};
+
+		ipList_2.list2 = new ArrayList<String>() {
+			{
+				add("ff:fabf:faf:f15f:f1ff:f2f:1f:f2");
+				add("2001:db8::ff00:1:8329");
+				add("::1");
+			}
+		};
+		
+		Complex com = new Complex();
+		com.list1 = new ArrayList<HashMap<String, ArrayList<IPList>>>() {
+			{
+				add(new HashMap<String, ArrayList<IPList>>() {
+					{
+						put("AA", new ArrayList<IPList>() {
+							{
+								add(ipList_1);
+								add(ipList_2);
+							}
+						});
+					}
+				});
+				add(new HashMap<String, ArrayList<IPList>>() {
+					{
+						put("BB", new ArrayList<IPList>() {
+							{
+								add(ipList_2);
+								add(ipList_1);
+							}
+						});
+					}
+				});
+			}
+		};
+
+		return com;
+	}
+
+	public void compare(Complex obj1, Complex obj2) {
+		org.junit.Assert.assertEquals(obj1.list1.size(), obj2.list1.size());
+		org.junit.Assert.assertEquals(obj1.list1.get(0).get("AA").size(),
+				obj2.list1.get(0).get("AA").size());
+		org.junit.Assert.assertEquals(obj1.list1.get(0).get("AA").get(0).list1
+				.size(), obj2.list1.get(0).get("AA").get(0).list1.size());
+		org.junit.Assert.assertEquals(obj1.list1.get(0).get("AA").get(0).list1
+				.get(2), obj2.list1.get(0).get("AA").get(0).list1.get(2));
+		org.junit.Assert.assertEquals(obj1.list1.get(0).get("AA").get(0).list2
+				.get(1), obj2.list1.get(0).get("AA").get(0).list2.get(1));
+		org.junit.Assert.assertEquals(obj1.list1.get(1).get("BB").get(0).list2
+				.get(0), obj2.list1.get(1).get("BB").get(0).list2.get(0));
+	}
+
+	public void serialize(BabelBase obj) throws IOException {
+		byte[] data = obj.serialize();
+		File file = new File("test/complex_test/java_test/bin.babel");
+		try {
+		    new FileOutputStream(file).write(data);
+		} catch (Exception e) {
+		    e.printStackTrace();
+		}
+	}
+
+	public byte[] deserialize() throws IOException{
+		File file = new File("test/complex_test/java_test/bin.babel");
+		byte[] data = new byte[(int) file.length()];
+		try {
+		    new FileInputStream(file).read(data);
+		} catch (Exception e) {
+		    e.printStackTrace();
+		}
+		return data;
+	}
+
+}