divine 0.0.2 → 0.0.3

data/test/basic_complex_test/ruby_test/test_babel.rb

@@ -1,368 +0,0 @@
-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/java_test/test_binaryTree.java

@@ -1,301 +0,0 @@
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.regex.Pattern;
-import java.nio.charset.Charset;
-
-abstract class BabelBase  {
-	private static final Charset UTF8 = Charset.forName("UTF-8");
-
-	public byte[] serialize() throws IOException {
-		ByteArrayOutputStream baos = new ByteArrayOutputStream();
-		serializeInternal(baos);
-		baos.close();
-		return baos.toByteArray();
-	}
-
-	abstract void serializeInternal(ByteArrayOutputStream baos) throws IOException;
-
-	abstract void deserialize(ByteArrayInputStream baos) throws IOException;
-
-	protected int readInt8(ByteArrayInputStream data) {
-		return data.read() & 0xff;
-	}
-
-	protected int readInt16(ByteArrayInputStream data) {
-		return (data.read() << 8) | readInt8(data);
-	}
-
-	protected int readInt24(ByteArrayInputStream data) {
-		return (data.read() << 16) | readInt16(data);
-	}
-
-	protected long readInt32(ByteArrayInputStream data) {
-		return (data.read() << 24) | readInt24(data);
-	}
-
-	protected boolean readBool(ByteArrayInputStream data) {
-		return readInt8(data) == 1;
-	}
-
-	protected String readString(ByteArrayInputStream data) throws IOException {
-		// Force utf8
-		return new String(readBytes(readInt16(data), data), UTF8);
-	}
-
-	private byte[] readBytes(int size, ByteArrayInputStream data) throws IOException {
-		byte[] bs = new byte[size];
-		data.read(bs);
-		return bs;
-	}
-
-	protected byte[] readBinary(ByteArrayInputStream data) throws IOException {
-		long c = readInt32(data);
-		if (c > Integer.MAX_VALUE) {
-			throw new IndexOutOfBoundsException("Binary data to big for java");
-		}
-		return readBytes((int) c, data);
-	}
-
-	protected byte[] readShortBinary(ByteArrayInputStream data) throws IOException {
-		return readBytes(readInt8(data), data);
-	}
-
-	protected String readIpNumber(ByteArrayInputStream data) throws IOException {
-		byte[] ips = readShortBinary(data);		
-		if(ips.length == 4){
-			return readIpv4Number(ips);
-		} else{
-			return readIpv6Number(ips);
-		}
-	}
-
-	protected String readIpv4Number(byte[] ips){
-		String ip = "";
-		for (byte b : ips) {
-			if (ip.length() > 0) {
-				ip += ".";
-			}
-			ip += (b & 0xFF);
-		}
-		return ip;
-	}
-
-	protected String readIpv6Number(byte[] ips) throws IOException {
-		String ip = "";
-                int part1, part2;
-		for (int i = 0; i < ips.length; i+=2) {
-			part1   = ips[i] & 0xFF;
-			part2   = ips[i+1] & 0xFF;
-			ip += part1 == 0? "" : Integer.toHexString(part1);
-			ip += (part1 == 0 && part2 == 0)? "" : (part2 < 10 && part1 != 0? "0" + Integer.toHexString(part2): Integer.toHexString(part2));
-			if (i < ips.length-2) {
-				ip += ":";
-			}
-		}
-		ip = ip.replaceAll(":{3,}", "::");
-		return ip;
-	}
-
-	protected void writeInt8(int v, ByteArrayOutputStream out) {
-		if (v > 0xFF) { // Max 255
-			raiseError("Too large int8 number: " + v);
-		}else if(v < 0){
-			raiseError("a negative number passed  to int8 number: " + v);
-		}
-		out.write(v);
-	}
-
-	protected void writeInt16(int v, ByteArrayOutputStream out) {
-		if (v > 0xFFFF) { // Max 65.535 
-			raiseError("Too large int16 number: " + v);
-		}else if(v < 0){
-			raiseError("a negative number passed  to int16 number: " + v);
-		}
-		writeInt8(v >> 8 & 0xFF, out);
-		writeInt8(v & 0xFF, out);
-	}
-
-	protected void writeInt24(int v, ByteArrayOutputStream out) {
-		if (v > 0xFFFFFF) { 	// Max 16.777.215
-			raiseError("Too large int24 number: " + v);
-		}else if(v < 0){	// In Case added to Java declaration
-			raiseError("a negative number passed  to int24 number: " + v);
-		}
-		writeInt8(v >> 16 & 0xFF, out);
-		writeInt16(v & 0xFFFF, out);
-	}
-
-	protected void writeInt32(long v, ByteArrayOutputStream out) {
-		if (v > 0xFFFFFFFFL) { // Max 4.294.967.295
-			raiseError("Too large int32 number: " + v);
-		}else if(v < 0){
-			raiseError("a negative number passed  to int32 number: " + v);
-		}
-		writeInt8((int) ((v >> 24) & 0xFF), out);
-		writeInt24((int) (v & 0xFFFFFF), out);
-	}
-
-	protected void writeBool(boolean v, ByteArrayOutputStream out) {
-		writeInt8(v ? 1 : 0, out);
-	}
-
-	protected void writeString(String v, ByteArrayOutputStream out) throws IOException {
-		byte[] bs = v.getBytes(UTF8);
-		if (bs.length > 0xFFFF) {
-			raiseError("Too large string: " + bs.length + " bytes");
-		}
-		writeInt16(bs.length, out);
-		out.write(bs);
-	}
-
-	protected void writeBinary(byte[] v, ByteArrayOutputStream out) throws IOException {
-		if (v.length > 0xFFFFFFFFL) {
-			raiseError("Too large binary: " + v.length + " bytes");
-		}
-		writeInt32(v.length, out);
-		out.write(v);
-	}
-
-
-	protected void write16Binary(int[] v, ByteArrayOutputStream out) throws IOException {
-		if (v.length > 0xFF) {
-			raiseError("Too large 16_binary: " + (v.length*2) + " bytes");
-		}
-		writeInt8(v.length*2, out);
-		for(int i = 0; i < v.length; i++){
-			this.writeInt16(v[i], out);
-		}
-	}
-
-	protected void writeShortBinary(byte[] v, ByteArrayOutputStream out) throws IOException {
-		if (v.length > 0xFF) {
-			raiseError("Too large short_binary: " + v.length + " bytes");
-		}
-		writeInt8(v.length, out);
-		out.write(v);
-	}
-
-	protected void writeIpNumber(String v, ByteArrayOutputStream out) throws IOException {
-		if(v.contains(":")){
-			writeIpv6Number( v, out);
-		}else{
-			writeIpv4Number( v, out);
-    		}
-	}
-        
-        protected void writeIpv4Number(String v, ByteArrayOutputStream out) throws IOException {
-		byte[] ss = new byte[0];
-		if(!v.isEmpty()){
-			String[] bs = v.split("\\.");
-			ss = new byte[bs.length];
-			for (int i = 0; i < bs.length; i++) {
-				ss[i] = (byte) (Integer.parseInt(bs[i]) & 0xFF);
-			}
-		}
-		if (ss.length == 0 || ss.length == 4) {
-			writeShortBinary(ss, out);
-		} else {
-			raiseError("Unknown IP v4 number " + v); // Only IPv4 for now 
-		}
-	}
-
-        protected void writeIpv6Number(String v, ByteArrayOutputStream out)
-			throws IOException {
-		v = v.replaceAll(" ", "") + " "; // Temporary: To avoid the split problem when we have : at the
-					// end of "v"
-		int[] ss = new int[0];
-		boolean contains_ipv6_letters = Pattern.compile("[0-9a-f]+").matcher(
-				v.trim().toLowerCase()).find();
-		boolean contains_other_letters = Pattern.compile("[^:0-9a-f]+")
-				.matcher(v.trim().toLowerCase()).find();
-		// make sure of v must have only one "::" and no more than two of ":".
-		// e.g. 1::1::1 & 1:::1:205
-		if (!v.trim().isEmpty() && v.split(":{3,}").length == 1
-				&& v.split(":{2}").length <= 2 && !contains_other_letters
-				&& contains_ipv6_letters) {
-			String[] bs = v.split(":");
-			ss = new int[bs.length];
-			for (int i = 0; i < bs.length; i++) {
-				String s = bs[i].trim();
-				if (s.length() <= 4) // to avoid such number 0125f
-					ss[i] = Integer.parseInt(
-							(s.isEmpty() ? "0" : bs[i].trim()), 16);
-				else
-					raiseError("Unknown IPv6 Group " + i + " which is " + s);
-			}
-		}
-		// Check for make sure of the size of the IP groups in case "::" is used
-		// [> 2 & < 8]or not [must == 8]
-		if (!contains_other_letters
-				&& (!v.contains("::") && ss.length == 0 || ss.length == 8)
-				|| (v.contains("::") && ss.length > 2 && ss.length < 8)) {
-			write16Binary(ss, out);
-		} else {
-			raiseError("Unknown IP v6 number " + v);
-		}
-	}
-
-	protected void raiseError(String msg) {
-		throw new IllegalArgumentException("[" + this.getClass().getCanonicalName() + "] " + msg);
-	}
-}
-
-
-class BinaryTree extends BabelBase {
-	public ArrayList<Node> root_node = new ArrayList<Node>();
-
-	@Override
-	void serializeInternal(ByteArrayOutputStream baos) throws IOException {
-		// Serialize list 'root_node'
-		writeInt32(root_node.size(), baos);
-		for(int var_101=0; var_101<root_node.size(); var_101++) {
-			Node var_100 = root_node.get(var_101);
-			var_100.serializeInternal(baos);
-		}
-	}
-
-	@Override
-	public void deserialize(ByteArrayInputStream bais) throws IOException {
-		// Deserialize list 'root_node'
-		this.root_node = new ArrayList<Node>();
-		int var_102 = (int)this.readInt32(bais);
-		for(int var_104=0; var_104<var_102; var_104++) {
-			Node var_103 = new Node();
-			var_103.deserialize(bais);
-			this.root_node.add(var_103);
-		}
-	}
-}
-
-
-class Node extends BabelBase {
-	public long i32 = 0L;
-	public ArrayList<Node> next_node = new ArrayList<Node>();
-
-	@Override
-	void serializeInternal(ByteArrayOutputStream baos) throws IOException {
-		writeInt32(this.i32, baos);
-		// Serialize list 'next_node'
-		writeInt32(next_node.size(), baos);
-		for(int var_106=0; var_106<next_node.size(); var_106++) {
-			Node var_105 = next_node.get(var_106);
-			var_105.serializeInternal(baos);
-		}
-	}
-
-	@Override
-	public void deserialize(ByteArrayInputStream bais) throws IOException {
-		this.i32 = readInt32(bais);
-		// Deserialize list 'next_node'
-		this.next_node = new ArrayList<Node>();
-		int var_107 = (int)this.readInt32(bais);
-		for(int var_109=0; var_109<var_107; var_109++) {
-			Node var_108 = new Node();
-			var_108.deserialize(bais);
-			this.next_node.add(var_108);
-		}
-	}
-}