divine 0.0.1 → 0.0.2

data/test/binaryTree_test/java_test/JavaTest.java

@@ -0,0 +1,114 @@
+
+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 testBinaryTree() throws IOException {
+                System.out.println("Test Binary Tree");
+		BinaryTree binartTree_ser = buildObj();
+
+    		serialize(binartTree_ser);
+		byte[] read = deserialize();
+
+		BinaryTree binartTree_deser = new BinaryTree();
+		binartTree_deser.deserialize(new ByteArrayInputStream(read));
+
+		compareBinaryTree(binartTree_ser, binartTree_deser);
+	}
+
+	public BinaryTree buildObj() {
+		final Node root = new Node();
+		root.i32 = 0;
+
+		final Node n1_L = new Node();
+		n1_L.i32 = 1;
+
+		final Node n1_R = new Node();
+		n1_R.i32 = 2;
+
+		final Node n2_L_L = new Node();
+		n2_L_L.i32 = 3;
+
+		final Node n2_L_R = new Node();
+		n2_L_R.i32 = 4;
+
+		final Node n2_R_L = new Node();
+		n2_R_L.i32 = 5;
+
+		final Node n2_R_R = new Node();
+		n2_R_R.i32 = 6;
+
+		root.next_node = new ArrayList<Node>() {
+			{
+				add(n1_L);
+				add(n1_R);
+			}
+		};
+
+		n1_L.next_node = new ArrayList<Node>() {
+			{
+				add(n2_L_L);
+				add(n2_L_R);
+			}
+		};
+
+		n1_R.next_node = new ArrayList<Node>() {
+			{
+				add(n2_R_L);
+				add(n2_R_R);
+			}
+		};
+
+		BinaryTree bt = new BinaryTree();
+		bt.root_node = new ArrayList<Node>() {
+			{
+				add(root);
+			}
+		};
+
+		return bt;
+	}
+
+	public void compareBinaryTree(BinaryTree bt1, BinaryTree bt2) {
+		org.junit.Assert.assertEquals(bt1.root_node.size(), bt2.root_node
+				.size());
+		org.junit.Assert.assertEquals(bt1.root_node.get(0).i32, bt2.root_node
+				.get(0).i32);
+		org.junit.Assert.assertEquals(bt1.root_node.get(0).next_node.size(),
+				bt2.root_node.get(0).next_node.size());
+		org.junit.Assert.assertEquals(
+				bt1.root_node.get(0).next_node.get(0).next_node.get(0).i32,
+				bt2.root_node.get(0).next_node.get(0).next_node.get(0).i32);
+	}
+
+	public void serialize(BabelBase obj) throws IOException {
+		byte[] data = obj.serialize();
+		File file = new File("test/binaryTree_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/binaryTree_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;
+	}
+
+}

data/test/binaryTree_test/java_test/test_binaryTree.java

@@ -0,0 +1,301 @@
+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);
+		}
+	}
+}

data/test/binaryTree_test/js_test/js_test.js

@@ -0,0 +1,76 @@
+eval(require('fs').readFileSync('test/binaryTree_test/js_test/test_binaryTree.js', 'utf8')); 
+var assert = require('assert');
+var fs = require('fs');
+console.log("Test Binary Tree");
+
+var binaryTree_ser = buildTree();
+var ca = binaryTree_ser.serialize();
+serialize(ca);
+var read = deserialize();
+var binaryTree_deser = new BinaryTree();
+binaryTree_deser.deserialize(new BabelDataReader(read));
+compareBinaryTree(binaryTree_ser, binaryTree_deser);
+
+
+function buildTree(){
+    var root = new Node();
+    root.i32 = 0;
+    
+    var n1_L = new Node();
+    n1_L.i32 = 1;
+
+    var n1_R = new Node();
+    n1_R.i32 = 2;
+
+    var n2_L_L = new Node();
+    n2_L_L.i32 = 3;
+
+    var n2_L_R = new Node();
+    n2_L_R.i32 = 4;
+
+    var n2_R_L = new Node();
+    n2_R_L.i32 = 5;
+
+    var n2_R_R = new Node();
+    n2_R_R.i32 = 6;
+
+    root.next_node = [n1_L, n1_R];
+    n1_L.next_node = [n2_L_L, n2_L_R];
+    n1_R.next_node = [n2_R_L, n2_R_R];
+    
+    var bt = new BinaryTree();
+    bt.root_node = [root];
+    return bt;
+}
+
+function compareBinaryTree(bt1, bt2){
+  assert.equal( bt1.root_node.length, bt2.root_node.length);
+  assert.equal( bt1.root_node[0].i32, bt2.root_node[0].i32);
+  assert.equal( bt1.root_node[0].next_node.length, bt2.root_node[0].next_node.length);
+  assert.equal( bt1.root_node[0].next_node[0].next_node[0].i32, bt2.root_node[0].next_node[0].next_node[0].i32);
+}
+
+function serialize(obj){
+  var bBuffer = new Buffer(obj);
+  fs.writeFileSync(__dirname +  '/bin.babel.js', bBuffer, function (err) {
+    if (err) {
+      return console.log(err);
+    }
+  });
+}
+
+function deserialize(){
+  var data = fs.readFileSync(__dirname +  '/bin.babel.js');
+  data = toArray(data);
+  return data;
+  
+}
+
+function toArray(buffer) {
+    var view = new Uint8Array(buffer.length);
+    for (var i = 0; i < buffer.length; ++i) {
+        view[i] = buffer[i];
+    }
+    return view;
+}
+