Merge pull request #97 from kornilova-l/test-union-setters

Test union setters

Author: kornilova203

tests/samples/Union.c

@@ -1,8 +1,55 @@
 #include "Union.h"
 #include <stdlib.h>
+#include <string.h>
 
-void setIntValue(union values *v) { v->i = 10; }
+int union_get_sizeof() { return sizeof(union values); }
 
-void setLongValue(union values *v) { v->l = 10000000000; }
+int union_test_int(union values *v, enum union_op op, int value) {
+    switch (op) {
+    case UNION_SET:
+        v->i = value;
+        return 1;
+    case UNION_TEST:
+        return v->i == value;
+    }
+}
 
-int getUnionSize() { return sizeof(union values); }
+int union_test_long(union values *v, enum union_op op, long value) {
+    switch (op) {
+    case UNION_SET:
+        v->l = value;
+        return 1;
+    case UNION_TEST:
+        return v->l == value;
+    }
+}
+
+int union_test_long_long(union values *v, enum union_op op, long long value) {
+    switch (op) {
+    case UNION_SET:
+        v->ll = value;
+        return 1;
+    case UNION_TEST:
+        return v->ll == value;
+    }
+}
+
+int union_test_double(union values *v, enum union_op op, double value) {
+    switch (op) {
+    case UNION_SET:
+        v->d = value;
+        return 1;
+    case UNION_TEST:
+        return v->d == value;
+    }
+}
+
+int union_test_string(union values *v, enum union_op op, const char *value) {
+    switch (op) {
+    case UNION_SET:
+        v->s = value;
+        return 1;
+    case UNION_TEST:
+        return v->s == value || !strcmp(v->s, value);
+    }
+}

tests/samples/Union.h

@@ -2,10 +2,16 @@ union values {
     long l;
     int i;
     long long ll;
+    double d;
+    const char *s;
 };
 
-void setIntValue(union values *v);
+enum union_op { UNION_SET, UNION_TEST };
 
-void setLongValue(union values *v);
+int union_get_sizeof();
 
-int getUnionSize();
+int union_test_int(union values *v, enum union_op op, int value);
+int union_test_long(union values *v, enum union_op op, long value);
+int union_test_long_long(union values *v, enum union_op op, long long value);
+int union_test_double(union values *v, enum union_op op, double value);
+int union_test_string(union values *v, enum union_op op, const char *value);

tests/samples/Union.scala

@@ -7,13 +7,22 @@ import scala.scalanative.native._
 @native.extern
 object Union {
   type union_values = native.CArray[Byte, native.Nat._8]
-  def setIntValue(v: native.Ptr[union_values]): Unit = native.extern
-  def setLongValue(v: native.Ptr[union_values]): Unit = native.extern
-  def getUnionSize(): native.CInt = native.extern
+  type enum_union_op = native.CUnsignedInt
+  def union_get_sizeof(): native.CInt = native.extern
+  def union_test_int(v: native.Ptr[union_values], op: enum_union_op, value: native.CInt): native.CInt = native.extern
+  def union_test_long(v: native.Ptr[union_values], op: enum_union_op, value: native.CLong): native.CInt = native.extern
+  def union_test_long_long(v: native.Ptr[union_values], op: enum_union_op, value: native.CLongLong): native.CInt = native.extern
+  def union_test_double(v: native.Ptr[union_values], op: enum_union_op, value: native.CDouble): native.CInt = native.extern
+  def union_test_string(v: native.Ptr[union_values], op: enum_union_op, value: native.CString): native.CInt = native.extern
 }
 
 import Union._
 
+object UnionEnums {
+  final val enum_union_op_UNION_SET: enum_union_op = 0.toUInt
+  final val enum_union_op_UNION_TEST: enum_union_op = 1.toUInt
+}
+
 object UnionHelpers {
 
   implicit class union_values_pos(val p: native.Ptr[union_values]) extends AnyVal {
@@ -23,5 +32,9 @@ object UnionHelpers {
     def i_=(value: native.CInt): Unit = !p.cast[native.Ptr[native.CInt]] = value
     def ll: native.Ptr[native.CLongLong] = p.cast[native.Ptr[native.CLongLong]]
     def ll_=(value: native.CLongLong): Unit = !p.cast[native.Ptr[native.CLongLong]] = value
+    def d: native.Ptr[native.CDouble] = p.cast[native.Ptr[native.CDouble]]
+    def d_=(value: native.CDouble): Unit = !p.cast[native.Ptr[native.CDouble]] = value
+    def s: native.Ptr[native.CString] = p.cast[native.Ptr[native.CString]]
+    def s_=(value: native.CString): Unit = !p.cast[native.Ptr[native.CString]] = value
   }
 }

tests/samples/src/test/scala/org/scalanative/bindgen/samples/UnionTests.scala

@@ -6,18 +6,113 @@ import org.scalanative.bindgen.samples.UnionHelpers._
 
 object UnionTests extends TestSuite {
   val tests = Tests {
-    'getValues - {
-      Zone {implicit zone =>
+    'sizeof - {
+      assert(Union.union_get_sizeof() == sizeof[Union.union_values])
+    }
+
+    'get - {
+      Zone { implicit zone =>
         val unionPtr = alloc[Union.union_values]
-        Union.setIntValue(unionPtr)
-        assert(!unionPtr.i == 10)
-        Union.setLongValue(unionPtr)
-        assert(!unionPtr.l == 10000000000L)
+
+        for (value <- Seq(Int.MinValue, -1, 0, 1, Int.MaxValue)) {
+          Union.union_test_int(unionPtr,
+                               UnionEnums.enum_union_op_UNION_SET,
+                               value)
+          assert(!unionPtr.i == value)
+        }
+
+        for (value <- Seq(Long.MinValue, -1, 0, 1, Long.MaxValue)) {
+          Union.union_test_long(unionPtr,
+                                UnionEnums.enum_union_op_UNION_SET,
+                                value)
+          assert(!unionPtr.l == value)
+        }
+
+        val llValues = Seq[CLongLong](
+          Long.MinValue - 100, -1, 0, 1, Long.MaxValue + 100)
+        for (value <- llValues) {
+          Union.union_test_long_long(unionPtr,
+                                     UnionEnums.enum_union_op_UNION_SET,
+                                     value)
+          assert(!unionPtr.ll == value)
+        }
+
+        for (value <- Seq(Double.MinValue, -1, 0, 1, Double.MaxValue)) {
+          Union.union_test_double(unionPtr,
+                                  UnionEnums.enum_union_op_UNION_SET,
+                                  value)
+          assert(!unionPtr.d == value)
+        }
+
+        for (value <- Seq("", "bindgen")) {
+          val s = toCString(value)
+          Union.union_test_string(unionPtr,
+                                  UnionEnums.enum_union_op_UNION_SET,
+                                  s)
+          assert(fromCString(!unionPtr.s) == value)
+        }
+
+        Union.union_test_string(unionPtr,
+                                UnionEnums.enum_union_op_UNION_SET,
+                                null)
+        assert(!unionPtr.s == null)
       }
     }
 
-    'unionSize - {
-      assert(Union.getUnionSize() == sizeof[Union.union_values])
+    'set - {
+      Zone { implicit zone =>
+        val unionPtr = alloc[Union.union_values]
+
+        for (value <- Seq(Int.MinValue, -1, 0, 1, Int.MaxValue)) {
+          !unionPtr.i = value
+          assert(
+            Union.union_test_int(unionPtr,
+                                 UnionEnums.enum_union_op_UNION_TEST,
+                                 value) == 1)
+        }
+
+        for (value <- Seq(Long.MinValue, -1, 0, 1, Long.MaxValue)) {
+          !unionPtr.l = value
+          assert(
+            Union.union_test_long(unionPtr,
+                                  UnionEnums.enum_union_op_UNION_TEST,
+                                  value) == 1)
+        }
+
+        val llValues = Seq[CLongLong](
+          Long.MinValue - 100, -1, 0, 1, Long.MaxValue + 100)
+        for (value <- llValues) {
+          !unionPtr.ll = value
+          assert(
+            Union.union_test_long_long(unionPtr,
+                                       UnionEnums.enum_union_op_UNION_TEST,
+                                       value) == 1)
+        }
+
+        for (value <- Seq(Double.MinValue, -1, 0, 1, Double.MaxValue)) {
+          !unionPtr.d = value
+          assert(
+            Union.union_test_double(unionPtr,
+                                    UnionEnums.enum_union_op_UNION_TEST,
+                                    value) == 1)
+        }
+
+        for (value <- Seq("", "bindgen")) {
+          val s = toCString(value)
+          !unionPtr.s = s
+          val expected = toCString(value)
+          assert(
+            Union.union_test_string(unionPtr,
+                                    UnionEnums.enum_union_op_UNION_TEST,
+                                    expected) == 1)
+        }
+
+        !unionPtr.s = null
+        assert(
+          Union.union_test_string(unionPtr,
+                                  UnionEnums.enum_union_op_UNION_TEST,
+                                  null) == 1)
+      }
     }
   }
 }