cauterize 0.0.1.pre13 → 0.0.1.pre14

data/support/c/test/test.c

@@ -1,166 +1,166 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "cauterize.h"
-#include "greatest.h"
-
-GREATEST_MAIN_DEFS();
-
-TEST t_CauterizeInitAppend_works() {
-  CAUTERIZE_STATUS_T s = CA_ERR_GENERAL;
-  struct Cauterize m;
-  uint8_t buffer[64] = { 0 };
-
-  s = CauterizeInitAppend(&m, buffer, sizeof(buffer));
-
-  ASSERT_EQ(CA_OK, s);
-  ASSERT_EQ(m.size, 64);
-  ASSERT_EQ(m.used, 0);
-  ASSERT_EQ(m.pos, 0);
-
-  PASS();
-}
-
-TEST t_CauterizeInitRead_works() {
-  CAUTERIZE_STATUS_T s = CA_ERR_GENERAL;
-  struct Cauterize m;
-  uint8_t buffer[64] = { 0 };
-
-  s = CauterizeInitRead(&m, buffer, 13);
-
-  ASSERT_EQ(CA_OK, s);
-  ASSERT_EQ(m.size, 13);
-  ASSERT_EQ(m.used, 13);
-  ASSERT_EQ(m.pos, 0);
-
-  PASS();
-}
-
-TEST t_CauterizeAppend_works() {
-  CAUTERIZE_STATUS_T s = CA_ERR_GENERAL;
-  struct Cauterize m;
-  uint8_t buffer[64] = { 0 };
-  char data[] = "Hello World";
-
-  s = CauterizeInitAppend(&m, buffer, sizeof(buffer));
-  ASSERT_EQ(CA_OK, s);
-
-  s = CauterizeAppend(&m, (uint8_t*)data, sizeof(data));
-  ASSERT_EQ(CA_OK, s);
-  ASSERT_EQ(m.used, sizeof(data));
-  ASSERT_STR_EQ(data, (char*)m.buffer);
-
-  PASS();
-}
-
-TEST t_CauterizeAppend_works_again() {
-  CAUTERIZE_STATUS_T s = CA_ERR_GENERAL;
-  struct Cauterize m;
-  uint8_t buffer[64] = { 0 };
-
-  char data_1[3] = "ABC";
-  char data_2[] = "DEF";
-
-  s = CauterizeInitAppend(&m, buffer, sizeof(buffer));
-  ASSERT_EQ(CA_OK, s);
-
-  ASSERT_EQ(CA_OK, CauterizeAppend(&m, (uint8_t*)data_1, sizeof(data_1)));
-  ASSERT_EQ(CA_OK, CauterizeAppend(&m, (uint8_t*)data_2, sizeof(data_2)));
-
-  ASSERT_EQ(sizeof(data_1) + sizeof(data_2), m.used);
-  ASSERT_STR_EQ("ABCDEF", (char*)m.buffer);
-
-  PASS();
-}
-
-TEST t_CauterizeAppend_checks_space_needs() {
-  CAUTERIZE_STATUS_T s = CA_ERR_GENERAL;
-  struct Cauterize m;
-  uint8_t buffer[64] = { 0 };
-  char data[] = "Hello World";
-
-  s = CauterizeInitAppend(&m, buffer, sizeof(data) - 5);
-  ASSERT_EQ(CA_OK, s);
-
-  s = CauterizeAppend(&m, (uint8_t*)data, sizeof(data));
-  ASSERT_EQ(CA_ERR_NOT_ENOUGH_SPACE, s);
-  ASSERT_EQ(m.used, 0);
-
-  PASS();
-}
-
-TEST t_CauterizeRead_works() {
-  CAUTERIZE_STATUS_T s = CA_ERR_GENERAL;
-  struct Cauterize m;
-  struct Cauterize n;
-  uint8_t buffer[64] = { 0 };
-  char data[] = "Hello World";
-
-  ASSERT_EQ(CA_OK, CauterizeInitAppend(&m, buffer, sizeof(buffer)));
-  ASSERT_EQ(CA_OK, CauterizeAppend(&m, (uint8_t*)data, sizeof(data)));
-
-  ASSERT_EQ(CA_OK, CauterizeInitRead(&n, buffer, m.used));
-
-  char dest[64] = {0};
-
-  s = CauterizeRead(&n, (uint8_t*)dest, 5);
-  ASSERT_EQ(CA_OK, s);
-  ASSERT_EQ(5, n.pos);
-  ASSERT_STR_EQ("Hello", dest);
-
-  PASS();
-}
-
-TEST t_CauterizeRead_works_again() {
-  CAUTERIZE_STATUS_T s = CA_ERR_GENERAL;
-  struct Cauterize m;
-  struct Cauterize n;
-  uint8_t buffer[64] = { 0 };
-  char data[] = "Hello World";
-
-  ASSERT_EQ(CA_OK, CauterizeInitAppend(&m, buffer, sizeof(buffer)));
-  ASSERT_EQ(CA_OK, CauterizeAppend(&m, (uint8_t*)data, sizeof(data)));
-
-  char dest[64] = {0};
-
-  ASSERT_EQ(CA_OK, CauterizeInitRead(&n, buffer, m.used));
-  ASSERT_EQ(CA_OK, CauterizeRead(&n, (uint8_t*)dest, 5));
-
-  s = CauterizeRead(&n, (uint8_t*)dest, 6);
-  ASSERT_EQ(CA_OK, s);
-  ASSERT_EQ(11, n.pos);
-  ASSERT_STR_EQ(" World", dest);
-
-  PASS();
-}
-
-TEST t_CauterizeRead_checks_data_needs() {
-  CAUTERIZE_STATUS_T s = CA_ERR_GENERAL;
-  struct Cauterize m;
-  struct Cauterize n;
-  uint8_t buffer[32] = { 0 };
-  char data[] = "Hello World";
-
-  ASSERT_EQ(CA_OK, CauterizeInitAppend(&m, buffer, sizeof(buffer)));
-  ASSERT_EQ(CA_OK, CauterizeAppend(&m, (uint8_t*)data, sizeof(data)));
-
-  char dest[64] = {0};
-
-  ASSERT_EQ(CA_OK, CauterizeInitRead(&n, buffer, m.used));
-  s = CauterizeRead(&n, (uint8_t*)dest, sizeof(dest));
-  ASSERT_EQ(CA_ERR_NOT_ENOUGH_DATA, s);
-  ASSERT_EQ(0, n.pos);
-
-  PASS();
-}
-
-GREATEST_SUITE(marshal) {
-/* test_suite.c is generated programatically by the Rakefile */
-#include "test_suite.c"
-}
-
-int main(int argc, char * argv[]) {
-  GREATEST_MAIN_BEGIN();
-  RUN_SUITE(marshal);
-  GREATEST_MAIN_END();
-}
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "cauterize.h"
+#include "greatest.h"
+
+GREATEST_MAIN_DEFS();
+
+TEST t_CauterizeInitAppend_works() {
+  CAUTERIZE_STATUS_T s = CA_ERR_GENERAL;
+  struct Cauterize m;
+  uint8_t buffer[64] = { 0 };
+
+  s = CauterizeInitAppend(&m, buffer, sizeof(buffer));
+
+  ASSERT_EQ(CA_OK, s);
+  ASSERT_EQ(m.size, 64);
+  ASSERT_EQ(m.used, 0);
+  ASSERT_EQ(m.pos, 0);
+
+  PASS();
+}
+
+TEST t_CauterizeInitRead_works() {
+  CAUTERIZE_STATUS_T s = CA_ERR_GENERAL;
+  struct Cauterize m;
+  uint8_t buffer[64] = { 0 };
+
+  s = CauterizeInitRead(&m, buffer, 13);
+
+  ASSERT_EQ(CA_OK, s);
+  ASSERT_EQ(m.size, 13);
+  ASSERT_EQ(m.used, 13);
+  ASSERT_EQ(m.pos, 0);
+
+  PASS();
+}
+
+TEST t_CauterizeAppend_works() {
+  CAUTERIZE_STATUS_T s = CA_ERR_GENERAL;
+  struct Cauterize m;
+  uint8_t buffer[64] = { 0 };
+  char data[] = "Hello World";
+
+  s = CauterizeInitAppend(&m, buffer, sizeof(buffer));
+  ASSERT_EQ(CA_OK, s);
+
+  s = CauterizeAppend(&m, (uint8_t*)data, sizeof(data));
+  ASSERT_EQ(CA_OK, s);
+  ASSERT_EQ(m.used, sizeof(data));
+  ASSERT_STR_EQ(data, (char*)m.buffer);
+
+  PASS();
+}
+
+TEST t_CauterizeAppend_works_again() {
+  CAUTERIZE_STATUS_T s = CA_ERR_GENERAL;
+  struct Cauterize m;
+  uint8_t buffer[64] = { 0 };
+
+  char data_1[3] = "ABC";
+  char data_2[] = "DEF";
+
+  s = CauterizeInitAppend(&m, buffer, sizeof(buffer));
+  ASSERT_EQ(CA_OK, s);
+
+  ASSERT_EQ(CA_OK, CauterizeAppend(&m, (uint8_t*)data_1, sizeof(data_1)));
+  ASSERT_EQ(CA_OK, CauterizeAppend(&m, (uint8_t*)data_2, sizeof(data_2)));
+
+  ASSERT_EQ(sizeof(data_1) + sizeof(data_2), m.used);
+  ASSERT_STR_EQ("ABCDEF", (char*)m.buffer);
+
+  PASS();
+}
+
+TEST t_CauterizeAppend_checks_space_needs() {
+  CAUTERIZE_STATUS_T s = CA_ERR_GENERAL;
+  struct Cauterize m;
+  uint8_t buffer[64] = { 0 };
+  char data[] = "Hello World";
+
+  s = CauterizeInitAppend(&m, buffer, sizeof(data) - 5);
+  ASSERT_EQ(CA_OK, s);
+
+  s = CauterizeAppend(&m, (uint8_t*)data, sizeof(data));
+  ASSERT_EQ(CA_ERR_NOT_ENOUGH_SPACE, s);
+  ASSERT_EQ(m.used, 0);
+
+  PASS();
+}
+
+TEST t_CauterizeRead_works() {
+  CAUTERIZE_STATUS_T s = CA_ERR_GENERAL;
+  struct Cauterize m;
+  struct Cauterize n;
+  uint8_t buffer[64] = { 0 };
+  char data[] = "Hello World";
+
+  ASSERT_EQ(CA_OK, CauterizeInitAppend(&m, buffer, sizeof(buffer)));
+  ASSERT_EQ(CA_OK, CauterizeAppend(&m, (uint8_t*)data, sizeof(data)));
+
+  ASSERT_EQ(CA_OK, CauterizeInitRead(&n, buffer, m.used));
+
+  char dest[64] = {0};
+
+  s = CauterizeRead(&n, (uint8_t*)dest, 5);
+  ASSERT_EQ(CA_OK, s);
+  ASSERT_EQ(5, n.pos);
+  ASSERT_STR_EQ("Hello", dest);
+
+  PASS();
+}
+
+TEST t_CauterizeRead_works_again() {
+  CAUTERIZE_STATUS_T s = CA_ERR_GENERAL;
+  struct Cauterize m;
+  struct Cauterize n;
+  uint8_t buffer[64] = { 0 };
+  char data[] = "Hello World";
+
+  ASSERT_EQ(CA_OK, CauterizeInitAppend(&m, buffer, sizeof(buffer)));
+  ASSERT_EQ(CA_OK, CauterizeAppend(&m, (uint8_t*)data, sizeof(data)));
+
+  char dest[64] = {0};
+
+  ASSERT_EQ(CA_OK, CauterizeInitRead(&n, buffer, m.used));
+  ASSERT_EQ(CA_OK, CauterizeRead(&n, (uint8_t*)dest, 5));
+
+  s = CauterizeRead(&n, (uint8_t*)dest, 6);
+  ASSERT_EQ(CA_OK, s);
+  ASSERT_EQ(11, n.pos);
+  ASSERT_STR_EQ(" World", dest);
+
+  PASS();
+}
+
+TEST t_CauterizeRead_checks_data_needs() {
+  CAUTERIZE_STATUS_T s = CA_ERR_GENERAL;
+  struct Cauterize m;
+  struct Cauterize n;
+  uint8_t buffer[32] = { 0 };
+  char data[] = "Hello World";
+
+  ASSERT_EQ(CA_OK, CauterizeInitAppend(&m, buffer, sizeof(buffer)));
+  ASSERT_EQ(CA_OK, CauterizeAppend(&m, (uint8_t*)data, sizeof(data)));
+
+  char dest[64] = {0};
+
+  ASSERT_EQ(CA_OK, CauterizeInitRead(&n, buffer, m.used));
+  s = CauterizeRead(&n, (uint8_t*)dest, sizeof(dest));
+  ASSERT_EQ(CA_ERR_NOT_ENOUGH_DATA, s);
+  ASSERT_EQ(0, n.pos);
+
+  PASS();
+}
+
+GREATEST_SUITE(marshal) {
+/* test_suite.c is generated programatically by the Rakefile */
+#include "test_suite.c"
+}
+
+int main(int argc, char * argv[]) {
+  GREATEST_MAIN_BEGIN();
+  RUN_SUITE(marshal);
+  GREATEST_MAIN_END();
+}

data/support/cs/src/CauterizeException.cs

@@ -1,15 +1,15 @@
-using System;
-
-namespace Cauterize 
-{
-    public class CauterizeException : Exception
-    {
-        public CauterizeException(string message) : base(message)
-        {
-        }
-
-        public CauterizeException(string message, Exception innerException) : base(message, innerException)
-        {
-        }
-    }
-}
+using System;
+
+namespace Cauterize 
+{
+    public class CauterizeException : Exception
+    {
+        public CauterizeException(string message) : base(message)
+        {
+        }
+
+        public CauterizeException(string message, Exception innerException) : base(message, innerException)
+        {
+        }
+    }
+}

data/support/cs/src/CauterizeFixedArrayFormatter.cs

@@ -15,9 +15,9 @@ namespace Cauterize
             var arrayType = arrayField.FieldType.GetElementType();
             if (arrayType == typeof (Byte))
             {
-                var arraySize = (int) t.GetField("MySize").GetValue(null);
+                var arraySize = (ulong) t.GetField("MySize").GetValue(null);
                 var arrayData = new byte[arraySize];
-                serializationStream.Read(arrayData, 0, arraySize);
+                serializationStream.Read(arrayData, 0, (int)arraySize);
                 var ret = t.GetConstructor(new Type[] {typeof (Byte[])}).Invoke(new object[] {arrayData});
                 return ret;
             }

data/support/cs/src/CauterizeTypes.cs

@@ -1,11 +1,16 @@
 using System;
+using System.Diagnostics;
+using System.Linq;
+using Cauterize.Common;
 
 namespace Cauterize
 {
-    public class CauterizeInfo {
+    public class CauterizeInfo
+    {
         public string Name;
         public string GeneratedVersion;
         public string GeneratedDate;
+
         public int ModelHashLength;
         public byte[] ModelHash;
     }
@@ -31,7 +36,7 @@ namespace Cauterize
         {
             var enumProp = OrderAttribute.GetPropertyByOrder(GetType(), 0);
             var value = enumProp.GetValue(this, null);
-            var index = (int) value + 1;
+            var index = (int)value + 1;
             var prop = OrderAttribute.GetPropertyByOrder(GetType(), index);
             if (prop != null)
             {
@@ -46,21 +51,22 @@ namespace Cauterize
 
     public abstract class CauterizeFixedArray
     {
+        public abstract object[] ObjectArray();
     }
 
     public abstract class CauterizeFixedArrayTyped<T> : CauterizeFixedArray
     {
         private T[] _data;
 
-        protected abstract int Size { get; }
-        
+        protected abstract ulong Size { get; }
+
         protected void Allocate(T[] data)
         {
-            Allocate(data.Length);
+            Allocate((ulong)data.Length);
             Array.Copy(data, _data, data.Length);
         }
 
-        protected void Allocate(int size)
+        protected void Allocate(ulong size)
         {
             if (size != Size)
             {
@@ -91,27 +97,36 @@ namespace Cauterize
 
         public T[] GetArray()
         {
-          return _data;
+            return _data;
+        }
+
+        public override object[] ObjectArray()
+        {
+            var objArr = new object[_data.Length];
+            Array.Copy(_data, objArr, objArr.Length);
+            return objArr;
         }
     }
 
     public abstract class CauterizeVariableArray
     {
+        public abstract object[] ObjectArray();
     }
 
+    [DebuggerDisplay("{DebuggerDisplay}")]
     public abstract class CauterizeVariableArrayTyped<T> : CauterizeVariableArray
     {
         private T[] _data;
 
-        protected abstract int MaxSize { get; }
-        
+        protected abstract ulong MaxSize { get; }
+
         protected void Allocate(T[] data)
         {
-            Allocate(data.Length);
+            Allocate((ulong)data.Length);
             Array.Copy(data, _data, data.Length);
         }
 
-        protected void Allocate(int size)
+        protected void Allocate(ulong size)
         {
             if (size > MaxSize)
             {
@@ -125,6 +140,18 @@ namespace Cauterize
             return array._data;
         }
 
+        public string DebuggerDisplay
+        {
+            get
+            {
+                var result = this.ToString();
+                var bytes = _data as byte[];
+                if (bytes != null)
+                    result = StringExtensions.BytesToString(bytes) + " " + result;
+                return result;
+            }
+        }
+
         public override string ToString()
         {
             var result = "[";
@@ -142,7 +169,14 @@ namespace Cauterize
 
         public T[] GetArray()
         {
-          return _data;
+            return _data;
+        }
+
+        public override object[] ObjectArray()
+        {
+            var objArr = new object[_data.Length];
+            Array.Copy(_data, objArr, objArr.Length);
+            return objArr;
         }
     }
 }