divine 0.0.3 → 0.0.4

data/test/dynamic_int_test/js_test/js_test.js

@@ -0,0 +1,54 @@
+eval(require('fs').readFileSync('test/dynamic_int_test/js_test/test_dynamic_int.js', 'utf8'));
+var fs = require('fs');
+var assert = require('assert');
+
+console.log("Test Dynamic Int");
+
+var obj_ser = buildObject();
+
+var ca = obj_ser.serialize();
+serialize(ca);
+var read = deserialize();
+
+var obj_deser = new DynamicInt();
+obj_deser.deserialize(new DivineDataReader(read));
+compare_list(obj_ser.list1, obj_deser.list1);
+
+
+function buildObject(){
+  var obj  = new DynamicInt();
+  obj.list1   = [127, 16383, 2097151, 268435455, 34359738367, 4398046511103, 562949953421311]//, 9007199254740991];
+  return obj;
+}
+
+function compare_list(lst_1, lst_2){
+  assert.equal(lst_1.length, lst_2.length)
+  for (var i = 0; i < lst_1.length; i++){
+    //console.log("Ser = " + lst_1[i] + ", Deser = " + lst_2[i]);
+    assert.equal(lst_1[i], lst_2[i]);
+  }
+}
+
+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;
+}

data/test/dynamic_int_test/ruby_test/ruby_test.rb

@@ -0,0 +1,55 @@
+require_relative 'test_dynamic_int.rb'
+require 'minitest/autorun'
+
+#
+# Responsible for testing dynamic integer data types
+#
+class TestDynamicInteger < MiniTest::Unit::TestCase
+
+  #
+  # Compare objects after serialize and deserialize operations
+  #
+  def test_signedInt
+    puts "Test Dynamic Int"
+    obj_ser = BabelTest::DynamicInt.new
+    obj_ser.list1  = [127, 16383, 2097151, 268435455, 34359738367, 4398046511103, 562949953421311]#, 72057594037927935, 9223372036854775807]
+    
+    ser = obj_ser.serialize
+    serialize(ser)
+    res = deserialize()
+
+    obj_deser = BabelTest::DynamicInt.new
+    obj_deser.deserialize res
+    compare(obj_ser, obj_deser)
+  end
+
+  #
+  # Make sure that the comming two objects are the same
+  # * *Args* :
+  #  -obj_ser-   --> original object
+  #  -obj_deser- --> obtained object after serialize and deserialize operations
+  #
+  def compare(obj_ser, obj_deser)
+    #puts "Ser = #{obj_ser.list1}, Deser = #{obj_deser.list1}"
+    assert_equal obj_ser.list1, obj_deser.list1
+  end
+
+  #
+  # Write binary data to file
+  # * *Args* :
+  #  -data-   --> bytes to be written
+  #
+  def serialize(data)
+    File.open("test/dynamic_int_test/ruby_test/bin.babel.rb", "w+b") do |f|
+      f.write(data)
+    end
+  end
+  
+  #
+  # Read file in binary mode and return its bytes content
+  #
+  def deserialize()
+    mem_buf = File.new('test/dynamic_int_test/ruby_test/bin.babel.rb').binmode
+  end
+
+end

data/test/ipv6_test/csharp_test/csharp_test.cs

@@ -0,0 +1,73 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.IO;
+using divine;
+using NUnit.Framework;
+
+namespace test_signed_int
+{
+    [TestFixture]
+    class divine
+    {
+        [Test]
+        public static void Main(String[] args)
+        {
+	    System.Console.Write("Test IPv6 \n");
+            IPV6 ser = buildObj();
+            serialize(ser);
+            byte[] res = deserialize();
+
+            IPV6 deser = new IPV6();
+            deser.deserialize(new MemoryStream(res));
+
+            compare(ser, deser);            
+        }
+
+        public static IPV6 buildObj() {
+		IPV6 obj = new IPV6();
+		obj.list1.Add("255.102.0.25");
+		obj.list1.Add("ff:fabf:faf:f15f:f1ff:f2f:1f:f2");
+		obj.list1.Add("2001:db8::ff00:1:8329");
+		obj.list1.Add("f::");
+		obj.list1.Add("::1");
+		obj.list1.Add("");
+            return obj;
+	    }
+
+        public static void compare(IPV6 obj1, IPV6 obj2)
+        {
+            for (int i = 0; i < obj1.list1.Count; i++)
+            {
+                //System.Console.Write("Ser = " + obj1.list1[i] + ", Deser = " + obj2.list1[i] + "\n");
+                Assert.AreEqual(obj1.list1[i].ToLower(), obj2.list1[i].ToLower());
+            }
+        }
+
+        public static void serialize(Divine obj)
+        {
+            try
+            {
+                byte[] data = obj.serialize();
+                File.WriteAllBytes("test/ipv6_test/csharp_test/bin.babel.csharp", data);                
+            }
+            catch (System.IO.IOException ex)
+            {
+                throw ex;
+            }
+	    }
+
+	    public static byte[] deserialize(){
+            try
+            {
+                byte[] data = File.ReadAllBytes("test/ipv6_test/csharp_test/bin.babel.csharp");
+                return data;
+            }
+            catch (System.IO.IOException ex)
+            {
+                throw ex;
+            }
+	    }
+            
+    }
+}

data/test/ipv6_test/ipv6_test.rb

@@ -5,10 +5,15 @@ struct 'IPV6' do
   list :list1, :ip_number
 end
 
+# Draw ERD for prev. structs
+Divine::GraphGenerator.new.draw("test/ipv6_test/")
+
 if ARGV[0] == "ruby"
   Divine::CodeGenerator.new.generate(:ruby, file: 'test_ipv6.rb', module: 'BabelTest', parent_class: "Object", target_dir: "test/ipv6_test/ruby_test")
 elsif ARGV[0] == "js"
   Divine::CodeGenerator.new.generate(:javascript, file: 'test_ipv6.js', target_dir: "test/ipv6_test/js_test")
 elsif ARGV[0] == "java"
   Divine::CodeGenerator.new.generate(:java, file: 'test_ipv6.java', target_dir: "test/ipv6_test/java_test")
+elsif ARGV[0] == "csharp"
+  Divine::CodeGenerator.new.generate(:csharp, file: 'test_ipv6.cs', target_dir: "test/ipv6_test/csharp_test")
 end

data/test/ipv6_test/java_test/JavaTest.java

@@ -51,7 +51,7 @@ public class JavaTest {
 		org.junit.Assert.assertEquals(obj1.list1.get(1), obj2.list1.get(1));
 	}
 
-	public void serialize(BabelBase obj) throws IOException {
+	public void serialize(Divine obj) throws IOException {
 		byte[] data = obj.serialize();
 		File file = new File("test/ipv6_test/java_test/bin.babel");
 		try {

data/test/ipv6_test/ruby_test/ruby_test.rb

@@ -1,10 +1,16 @@
 require_relative 'test_ipv6.rb'
 require 'minitest/autorun'
 
-class TestBabelTestBasic < MiniTest::Unit::TestCase
-
-  def test_ipv6
-    puts "Test IPv6"
+#
+# Responsible for testing IP data types
+#
+class TestIP < MiniTest::Unit::TestCase
+
+  #
+  # Compare objects after serialize and deserialize operations
+  #
+  def test_ip
+    puts "Test IP"
     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",""]
     
@@ -25,16 +31,30 @@ class TestBabelTestBasic < MiniTest::Unit::TestCase
     
   end
 
+  #
+  # Make sure that the comming two objects are the same
+  # * *Args* :
+  #  -obj_ser-   --> original object
+  #  -obj_deser- --> obtained object after serialize and deserialize operations
+  #
   def compare(obj_ser, obj_deser)
     assert_equal obj_ser.list1, obj_deser.list1
   end
 
+  #
+  # Write binary data to file
+  # * *Args* :
+  #  -data-   --> bytes to be written
+  #
   def serialize(data)
     File.open("test/ipv6_test/ruby_test/bin.babel.rb", "w+b") do |f|
       f.write(data)
     end
   end
 
+  #
+  # Read file in binary mode and return its bytes content
+  #
   def deserialize()
     mem_buf = File.new('test/ipv6_test/ruby_test/bin.babel.rb').binmode
   end

data/test/signed_int_test/csharp_test/csharp_test.cs

@@ -0,0 +1,86 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.IO;
+using divine;
+using NUnit.Framework;
+
+namespace test_signed_int
+{
+    [TestFixture]
+    class divine
+    {
+        [Test]
+        public static void Main(String[] args)
+        {
+	    System.Console.Write("Test Signed Int  \n");
+            SignedInt ser = buildObj();
+            serialize(ser);
+            byte[] res = deserialize();
+
+            SignedInt deser = new SignedInt();
+            deser.deserialize(new MemoryStream(res));
+
+            compare(ser, deser);
+   
+            //System.Console.Read();
+            
+        }
+
+        public static SignedInt buildObj() {
+		SignedInt obj = new SignedInt();
+		obj.list1.Add(-1);
+		obj.list1.Add(-2);
+		obj.list1.Add(-3);
+		obj.list1.Add(int.MaxValue);
+		obj.list1.Add(int.MinValue);
+
+		obj.list2.Add(-1);
+		obj.list2.Add(-2);
+		obj.list2.Add(-3);
+		obj.list2.Add( (long) Math.Pow(2, 53) -1 );
+		obj.list2.Add( (long) (Math.Pow(2, 53) - Math.Pow(2, 54)) );
+            return obj;
+	    }
+
+        public static void compare(SignedInt obj1, SignedInt obj2)
+        {
+            for (int i = 0; i < obj1.list1.Count; i++)
+            {
+                //System.Console.Write("Ser = " + obj1.list1[i] + ", Deser = " + obj2.list1[i] + "\n");
+                Assert.AreEqual(obj1.list1[i], obj2.list1[i]);
+            }
+            for (int i = 0; i < obj1.list2.Count; i++)
+            {
+                //System.Console.Write("Ser = " + obj1.list2[i] + ", Deser = " + obj2.list2[i] + "\n");
+                Assert.AreEqual(obj1.list2[i], obj2.list2[i]);
+            }
+        }
+
+        public static void serialize(Divine obj)
+        {
+            try
+            {
+                byte[] data = obj.serialize();
+                File.WriteAllBytes("test/signed_int_test/csharp_test/bin.babel.csharp", data);                
+            }
+            catch (System.IO.IOException ex)
+            {
+                throw ex;
+            }
+	    }
+
+	    public static byte[] deserialize(){
+            try
+            {
+                byte[] data = File.ReadAllBytes("test/signed_int_test/csharp_test/bin.babel.csharp");
+                return data;
+            }
+            catch (System.IO.IOException ex)
+            {
+                throw ex;
+            }
+	    }
+            
+    }
+}

data/test/signed_int_test/java_test/JavaTest.java

@@ -59,7 +59,7 @@ public class JavaTest {
 		}
 	}
 
-	public void serialize(BabelBase obj) throws IOException {
+	public void serialize(Divine obj) throws IOException {
 		byte[] data = obj.serialize();
 		File file = new File("test/signed_int_test/java_test/bin.babel");
 		try {

data/test/signed_int_test/ruby_test/ruby_test.rb

@@ -1,8 +1,14 @@
 require_relative 'test_signed_int.rb'
 require 'minitest/autorun'
 
+#
+# Responsible for testing signed integer data types
+#
 class TestBabelTestBasic < MiniTest::Unit::TestCase
 
+  #
+  # Compare objects after serialize and deserialize operations
+  #
   def test_signedInt
     puts "Test Signed Int"
     obj_ser = BabelTest::SignedInt.new
@@ -19,17 +25,31 @@ class TestBabelTestBasic < MiniTest::Unit::TestCase
     
   end
 
+  #
+  # Make sure that the comming two objects are the same
+  # * *Args* :
+  #  -obj_ser-   --> original object
+  #  -obj_deser- --> obtained object after serialize and deserialize operations
+  #
   def compare(obj_ser, obj_deser)
     #puts "Ser = #{obj_ser.list1}, Deser = #{obj_deser.list1}"
     assert_equal obj_ser.list1, obj_deser.list1
   end
 
+  #
+  # Write binary data to file
+  # * *Args* :
+  #  -data-   --> bytes to be written
+  #
   def serialize(data)
     File.open("test/signed_int_test/ruby_test/bin.babel.rb", "w+b") do |f|
       f.write(data)
     end
   end
-
+  
+  #
+  # Read file in binary mode and return its bytes content
+  #
   def deserialize()
     mem_buf = File.new('test/signed_int_test/ruby_test/bin.babel.rb').binmode
   end

data/test/signed_int_test/signed_int_test.rb

@@ -6,10 +6,16 @@ struct 'SignedInt' do
   list :list2, :sint64
 end
 
+# Draw ERD for prev. struct
+Divine::GraphGenerator.new.draw("test/signed_int_test/")
+
 if ARGV[0] == "ruby"
   Divine::CodeGenerator.new.generate(:ruby, file: 'test_signed_int.rb', module: 'BabelTest', parent_class: "Object", target_dir: "test/signed_int_test/ruby_test")
 elsif ARGV[0] == "js"
   Divine::CodeGenerator.new.generate(:javascript, file: 'test_signed_int.js', target_dir: "test/signed_int_test/js_test")
 elsif ARGV[0] == "java"
   Divine::CodeGenerator.new.generate(:java, file: 'test_signed_int.java', target_dir: "test/signed_int_test/java_test")
+elsif ARGV[0] == "csharp"
+  Divine::CodeGenerator.new.generate(:csharp, file: 'test_signed_int.cs', target_dir: "test/signed_int_test/csharp_test")
+
 end

data/test/unify_test/unify_test.rb

@@ -1,25 +1,38 @@
 require 'minitest/autorun'
 
+#
+# Responsible for equality testing to the produced byte files for all languages
+#
 class TestUnify < MiniTest::Unit::TestCase
 
+  #
+  # Make sure that the produced byte files from all languages in every test are the same.
+  #
   def test_unify
     puts "Unify Test: Compare the produced binary files"
     paths = [
              	"test/binaryTree_test/",
              	"test/complex_test/",
         	"test/ipv6_test/",
-		"test/signed_int_test/"
+		"test/signed_int_test/",
+		"test/dynamic_int_test/"
             ]
     paths.each do |path|
-      ruby = readFile("#{path}ruby_test/bin.babel.rb")
-      js   = readFile("#{path}js_test/bin.babel.js")
-      java = readFile("#{path}java_test/bin.babel")
+      ruby   = readFile("#{path}ruby_test/bin.babel.rb")
+      js     = readFile("#{path}js_test/bin.babel.js")
+      java   = readFile("#{path}java_test/bin.babel")
+      csharp = readFile("#{path}csharp_test/bin.babel.csharp")
 	    
       assert_equal ruby, js
       assert_equal ruby, java
+      assert_equal ruby, csharp
     end
   end
 
+  #
+  # Read certain file in binary mode and return its content bytes
+  # * *Args* :
+    #  - +file+ -> path to file name
   def readFile(file)
     data = File.new(file).binmode
     data.read(data.size).each_byte.to_a