divine 0.0.1 → 0.0.2

data/test/ipv6_test/ruby_test/ruby_test.rb

@@ -0,0 +1,42 @@
+require_relative 'test_ipv6.rb'
+require 'minitest/autorun'
+
+class TestBabelTestBasic < MiniTest::Unit::TestCase
+
+  def test_ipv6
+    puts "Test IPv6"
+    obj_ser = BabelTest::IPV6.new
+    obj_ser.list1  = ["255.102.0.25","ff:fabf:faf:f15f:f1ff:f2f:1f:f2","2001:db8::ff00:1:8329","f::","::1",""]
+    
+    # Should Fail or raise error
+    #obj_ser.ip = "2001:0db8:0000:0000:0000:ff00:0042:8329";
+    #obj_ser.ip = "2001:db8::fff00:42:8329";
+    #obj_ser.ip = "2001:db8:::ff00:42:8329";
+    #obj_ser.ip = "2001:db8:ff00:42:8329";
+    #obj_ser.ip = "::";
+
+    ser = obj_ser.serialize
+    serialize(ser)
+    res = deserialize()
+
+    obj_deser = BabelTest::IPV6.new
+    obj_deser.deserialize res
+    compare(obj_ser, obj_deser)
+    
+  end
+
+  def compare(obj_ser, obj_deser)
+    assert_equal obj_ser.list1, obj_deser.list1
+  end
+
+  def serialize(data)
+    File.open("test/ipv6_test/ruby_test/bin.babel.rb", "w+b") do |f|
+      f.write(data)
+    end
+  end
+
+  def deserialize()
+    mem_buf = File.new('test/ipv6_test/ruby_test/bin.babel.rb').binmode
+  end
+
+end

data/test/ipv6_test/ruby_test/test_ipv6.rb

@@ -0,0 +1,267 @@
+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 IPV6 < BabelBase
+      attr_accessor :list1
+
+      def initialize()
+          super
+          @list1 ||= []
+      end
+
+      def serialize_internal(out)
+        print "+"
+        # Serialize list 'list1'
+      write_int32(list1.size, out)
+      list1.each do |var_100|
+         write_ip_number(var_100, out)
+      end
+      end
+
+      def deserialize(data)
+        print "-"
+        # Deserialize list 'list1'
+      @list1 = []
+      var_101 = read_int32(data)
+      (1..var_101).each do
+         var_102 = read_ip_number(data)
+         @list1 << var_102
+      end
+      end
+  end
+    
+
+end

data/test/unify_test/java_test/test_unify.java

@@ -0,0 +1,171 @@
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.HashMap;
+
+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);
+		String ip = "";
+		for (byte b : ips) {
+			if (ip.length() > 0) {
+				ip += ".";
+			}
+			ip += (b & 0xFF);
+		}
+		return ip;
+	}
+
+	protected void writeInt8(int v, ByteArrayOutputStream out) {
+		if (v > 0xFF) { // Max 255
+			raiseError("Too large 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);
+		}
+		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);
+		}
+		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);
+		}
+		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 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 {
+		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 raiseError(String msg) {
+		throw new IllegalArgumentException("[" + this.getClass().getCanonicalName() + "] " + msg);
+	}
+}
+
+
+class UnifySer extends BabelBase {
+	public int i8 = 0;
+
+	@Override
+	void serializeInternal(ByteArrayOutputStream baos) throws IOException {
+		writeInt8(this.i8, baos);
+	}
+
+	@Override
+	void deserialize(ByteArrayInputStream bais) throws IOException {
+		this.i8 = readInt8(bais);
+	}
+}