cauterize 0.0.1.pre1 → 0.0.1.pre5

data/support/cs/test/CauterizeVariableArrayFormatterTest.cs

@@ -0,0 +1,130 @@
+using System;
+using System.IO;
+using System.Text;
+using System.Collections.Generic;
+using System.Linq;
+using Moq;
+using NUnit.Framework;
+using Cauterize;
+
+namespace Cauterize.Test
+{
+    class TestVariableArray : CauterizeVariableArrayTyped<int>
+    {
+        public static Type SizeType = typeof (Byte);
+
+        public TestVariableArray(int size)
+        {
+            Allocate(size);
+        }
+
+        public TestVariableArray(int[] data)
+        {
+            Allocate(data);
+        }
+
+        protected override int MaxSize
+        {
+            get { return Byte.MaxValue; }
+        }
+    }
+
+    [TestFixture]
+    public class CauterizeVariableArrayFormatterTest
+    {
+        [Test]
+        public void TestDeserialize()
+        {
+            var stream = new MemoryStream();
+            var factory = new Mock<CauterizeTypeFormatterFactory>();
+            var sf1 = new Mock<ICauterizeTypeFormatter>();
+            var sf2 = new Mock<ICauterizeTypeFormatter>();
+            factory.Setup(f => f.GetFormatter(It.IsAny<Type>())).Returns((Type t) =>
+                {
+                    if (t == typeof (Byte))
+                    {
+                        return sf1.Object;
+                    }
+                    else if (t == typeof (Int32))
+                    {
+                        return sf2.Object;
+                    }
+                    else
+                    {
+                        return null;
+                    }
+                });
+            sf1.Setup(sf => sf.Deserialize(stream, typeof (Byte))).Returns((Byte) 25);
+            var counter = 0;
+            sf2.Setup(sf => sf.Deserialize(stream, typeof(Int32))).Returns((Stream str, Type t) =>
+                {
+                    var ret = 0;
+                    if (counter == 4)
+                    {
+                        ret = 101;
+                    }
+                    else if (counter == 12)
+                    {
+                        ret = 321;
+                    }
+                    counter++;
+                    return ret;
+                });
+            var formatter = new CauterizeVariableArrayFormatter(factory.Object);
+            var result = (TestVariableArray) formatter.Deserialize(stream, typeof (TestVariableArray));
+            Assert.AreEqual(0, result[0]);
+            Assert.AreEqual(101, result[4]);
+            Assert.AreEqual(321, result[12]);
+            Assert.AreEqual(0, result[13]);
+        }
+
+        [Test]
+        public void TestSerialize()
+        {
+            var stream = new MemoryStream();
+            var testObj = new TestVariableArray(4);
+            testObj[1] = 15;
+            testObj[3] = 16;
+            var sf1 = new Mock<ICauterizeTypeFormatter>();
+            var sf2 = new Mock<ICauterizeTypeFormatter>();
+            var factory = new Mock<CauterizeTypeFormatterFactory>();
+            factory.Setup(f => f.GetFormatter(It.IsAny<Type>())).Returns((Type t) =>
+                {
+                    if (t == typeof(Byte))
+                    {
+                        return sf1.Object;
+                    }
+                    else if (t == typeof (Int32))
+                    {
+                        return sf2.Object;
+                    }
+                    else
+                    {
+                        return null;
+                    }
+                });
+            sf1.Setup(sf => sf.Serialize(stream, (Byte)4));
+            var counter = 0;
+            sf2.Setup(sf => sf.Serialize(stream, It.IsAny<Int32>())).Callback((Stream str, object value) =>
+                {
+                    if (counter == 1)
+                    {
+                        Assert.AreEqual(15, value);
+                    } 
+                    else if (counter == 3)
+                    {
+                        Assert.AreEqual(16, value);
+                    }
+                    else
+                    {
+                        Assert.AreEqual(0, value);
+                    }
+                    counter++;
+                });
+            var formatter = new CauterizeVariableArrayFormatter(factory.Object);
+            formatter.Serialize(stream, testObj);
+            sf1.VerifyAll();
+            sf2.VerifyAll();
+        }
+    }
+}

data/support/cs/test/OrderAttributeTest.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Text;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using Cauterize;
+
+namespace Cauterize.Test
+{
+    public class HasSomeAttrs
+    {
+        [Order(0)]
+        public int IntAttr { get; set; }
+
+        [Order(1)]
+        public string StringAttr { get; set; }
+
+        /* something unused for #2 */
+
+        [Order(3)]
+        public float FloatAttr { get; set; }
+    }
+
+    [TestFixture]
+    public class OrderAttributeTest
+    {
+        [Test]
+        public void TestItAllowsIterationOfAttributesInOrder()
+        {
+            var attrs = OrderAttribute.GetSortedProperties(typeof (HasSomeAttrs));
+            Assert.AreEqual("IntAttr", attrs.ElementAt(0).Name);
+            Assert.AreEqual("StringAttr", attrs.ElementAt(1).Name);
+            Assert.AreEqual("FloatAttr", attrs.ElementAt(2).Name);
+
+            var thirdAttr = OrderAttribute.GetPropertyByOrder(typeof (HasSomeAttrs), 3);
+            Assert.AreEqual("FloatAttr", thirdAttr.Name);
+        }
+    }
+}

data/support/cs/test/SerializedRepresentationAttributeTest.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Text;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using Cauterize;
+
+namespace Cauterize.Test
+{
+    [SerializedRepresentation(typeof(Int16))]
+    public enum MyEnum
+    {
+        Value1 = 1,
+        Value2 = 2,
+        Value3 = 3
+    }
+
+    [SerializedRepresentation(typeof(Int64))]
+    public enum MyEnum2
+    {
+        Value21 = 21,
+        Value22 = 22,
+        Value23 = 23
+    }
+
+    [TestFixture]
+    public class RepresentationAttributeTest
+    {
+        [Test]
+        public void TestItHasARetrievalRepresentationType()
+        {
+            var representationType = SerializedRepresentationAttribute.GetRepresentation(typeof (MyEnum));
+            Assert.That(representationType, Is.EqualTo(typeof(Int16)));
+
+            representationType = SerializedRepresentationAttribute.GetRepresentation(typeof (MyEnum2));
+            Assert.That(representationType, Is.EqualTo(typeof(Int64)));
+        }
+    }
+}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cauterize
 version: !ruby/object:Gem::Version
-  version: 0.0.1.pre1
+  version: 0.0.1.pre5
   prerelease: 6
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-30 00:00:00.000000000 Z
+date: 2013-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -107,27 +107,33 @@ files:
 - README.md
 - Rakefile
 - bin/cauterize
-- c/src/cauterize.c
-- c/src/cauterize.h
-- c/src/cauterize_debug.h
-- c/src/cauterize_util.h
-- c/test/greatest.h
-- c/test/test.c
 - cauterize.gemspec
 - example/Cauterize
 - example/build.sh
 - lib/cauterize/base_type.rb
 - lib/cauterize/builders.rb
 - lib/cauterize/builders/c/buildable.rb
+- lib/cauterize/builders/c/builtin.rb
 - lib/cauterize/builders/c/composite.rb
 - lib/cauterize/builders/c/enumeration.rb
 - lib/cauterize/builders/c/fixed_array.rb
 - lib/cauterize/builders/c/group.rb
 - lib/cauterize/builders/c/scalar.rb
 - lib/cauterize/builders/c/variable_array.rb
+- lib/cauterize/builders/cs/buildable.rb
+- lib/cauterize/builders/cs/builtin.rb
+- lib/cauterize/builders/cs/composite.rb
+- lib/cauterize/builders/cs/csarray.rb
+- lib/cauterize/builders/cs/enumeration.rb
+- lib/cauterize/builders/cs/fixed_array.rb
+- lib/cauterize/builders/cs/group.rb
+- lib/cauterize/builders/cs/scalar.rb
+- lib/cauterize/builders/cs/variable_array.rb
+- lib/cauterize/builtin.rb
 - lib/cauterize/c_builder.rb
 - lib/cauterize/cauterize.rb
 - lib/cauterize/composite.rb
+- lib/cauterize/cs_builder.rb
 - lib/cauterize/enumeration.rb
 - lib/cauterize/fixed_array.rb
 - lib/cauterize/formatter.rb
@@ -138,16 +144,26 @@ files:
 - lib/cauterize/version.rb
 - spec/base_type_spec.rb
 - spec/builders/c/buildable_spec.rb
+- spec/builders/c/builtin_spec.rb
 - spec/builders/c/composite_spec.rb
 - spec/builders/c/enumeration_spec.rb
 - spec/builders/c/fixed_array_spec.rb
 - spec/builders/c/group_spec.rb
 - spec/builders/c/scalar_spec.rb
 - spec/builders/c/variable_array_spec.rb
+- spec/builders/cs/buildable_spec.rb
+- spec/builders/cs/composite_spec.rb
+- spec/builders/cs/enumeration_spec.rb
+- spec/builders/cs/fixed_array_spec.rb
+- spec/builders/cs/group_spec.rb
+- spec/builders/cs/scalar_spec.rb
+- spec/builders/cs/variable_array_spec.rb
 - spec/builders_spec.rb
+- spec/builtin_spec.rb
 - spec/c_builder_spec.rb
 - spec/cauterize_spec.rb
 - spec/composite_spec.rb
+- spec/cs_builder_spec.rb
 - spec/enumeration_spec.rb
 - spec/fixed_array_spec.rb
 - spec/group_spec.rb
@@ -159,6 +175,38 @@ files:
 - spec/support/shared_examples_for_stubbed_functions.rb
 - spec/test_main.c
 - spec/variable_array_spec.rb
+- support/c/src/cauterize.c
+- support/c/src/cauterize.h
+- support/c/src/cauterize_debug.h
+- support/c/src/cauterize_util.h
+- support/c/test/greatest.h
+- support/c/test/test.c
+- support/cs/src/CauterizeCompositeFormatter.cs
+- support/cs/src/CauterizeContainerFormatter.cs
+- support/cs/src/CauterizeEnumFormatter.cs
+- support/cs/src/CauterizeException.cs
+- support/cs/src/CauterizeFixedArrayFormatter.cs
+- support/cs/src/CauterizeFormatter.cs
+- support/cs/src/CauterizeGroupFormatter.cs
+- support/cs/src/CauterizePrimitiveFormatter.cs
+- support/cs/src/CauterizeTypeFormatterFactory.cs
+- support/cs/src/CauterizeTypes.cs
+- support/cs/src/CauterizeVariableArrayFormatter.cs
+- support/cs/src/ICauterizeTypeFormatter.cs
+- support/cs/src/OrderAttribute.cs
+- support/cs/src/PrimitiveSupport.cs
+- support/cs/src/SerializedRepresentationAttribute.cs
+- support/cs/test/CauterizeCompositeFormatterTest.cs
+- support/cs/test/CauterizeEnumFormatterTest.cs
+- support/cs/test/CauterizeFixedArrayFormatterTest.cs
+- support/cs/test/CauterizeFormatterTest.cs
+- support/cs/test/CauterizeGroupFormatterTest.cs
+- support/cs/test/CauterizeIntegrationTest.cs
+- support/cs/test/CauterizePrimitiveFormatterTest.cs
+- support/cs/test/CauterizeTypeFormatterFactoryTest.cs
+- support/cs/test/CauterizeVariableArrayFormatterTest.cs
+- support/cs/test/OrderAttributeTest.cs
+- support/cs/test/SerializedRepresentationAttributeTest.cs
 homepage: https://github.com/sw17ch/cauterize
 licenses: []
 post_install_message: 
@@ -173,7 +221,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -3059868182157898473
+      hash: -69308014069678082
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -182,23 +230,33 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: Tools to generate structures and mashalers suitable for static-memory environments.
 test_files:
 - spec/base_type_spec.rb
 - spec/builders/c/buildable_spec.rb
+- spec/builders/c/builtin_spec.rb
 - spec/builders/c/composite_spec.rb
 - spec/builders/c/enumeration_spec.rb
 - spec/builders/c/fixed_array_spec.rb
 - spec/builders/c/group_spec.rb
 - spec/builders/c/scalar_spec.rb
 - spec/builders/c/variable_array_spec.rb
+- spec/builders/cs/buildable_spec.rb
+- spec/builders/cs/composite_spec.rb
+- spec/builders/cs/enumeration_spec.rb
+- spec/builders/cs/fixed_array_spec.rb
+- spec/builders/cs/group_spec.rb
+- spec/builders/cs/scalar_spec.rb
+- spec/builders/cs/variable_array_spec.rb
 - spec/builders_spec.rb
+- spec/builtin_spec.rb
 - spec/c_builder_spec.rb
 - spec/cauterize_spec.rb
 - spec/composite_spec.rb
+- spec/cs_builder_spec.rb
 - spec/enumeration_spec.rb
 - spec/fixed_array_spec.rb
 - spec/group_spec.rb

data/c/src/cauterize.h

@@ -1,46 +0,0 @@
-#ifndef CAUTERIZE_H
-#define CAUTERIZE_H
-
-#include <stdint.h>
-#include <stddef.h>
-
-typedef uint32_t CAUTERIZE_STATUS_T;
-
-#define CA_OK                    (0)
-#define CA_ERR_ASSERT            (1)
-#define CA_ERR_NOT_ENOUGH_SPACE  (2)
-#define CA_ERR_NOT_ENOUGH_DATA   (3)
-#define CA_ERR_INVALID_LENGTH    (4)
-#define CA_ERR_INVALUD_TYPE_TAG  (5)
-#define CA_ERR_GENERAL           (UINT32_MAX)
-
-struct Cauterize {
-  size_t size; // Size of the buffer in bytes
-  size_t used; // Number of used bytes in the buffer
-  size_t pos; // The next byte to be read
-  uint8_t * buffer; // Buffer to hold data
-};
-
-CAUTERIZE_STATUS_T CauterizeInitAppend(
-    struct Cauterize * m,
-    uint8_t * buffer,
-    size_t length);
-
-CAUTERIZE_STATUS_T CauterizeInitRead(
-    struct Cauterize * m,
-    uint8_t * buffer,
-    size_t used);
-
-CAUTERIZE_STATUS_T CauterizeAppend(
-    struct Cauterize * m,
-    uint8_t * src,
-    size_t length);
-
-CAUTERIZE_STATUS_T CauterizeRead(
-    struct Cauterize * m,
-    uint8_t * dst,
-    size_t length);
-
-#define CA_MAX(a,b) ((a) > (b) ? (a) : (b))
-
-#endif /* CAUTERIZE_H */

data/c/src/cauterize_util.h

@@ -1,7 +0,0 @@
-#ifndef CAUTERIZE_UTIL_H
-#define CAUTERIZE_UTIL_H
-
-#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
-#define MIN(a, b) (((a) < (b)) ? (a) : (b))
-
-#endif /* CAUTERIZE_UTIL_H */