Add union tests

Author: lucic71

tests/unit/union_addrof_external.c

@@ -0,0 +1,49 @@
+// translation-fail
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+struct header {
+  uint16_t tag;
+  uint16_t port;
+  uint32_t addr;
+  char pad[8];
+};
+
+struct Storage {
+  union {
+    struct header h;
+    char raw[128];
+  } buffer;
+};
+
+static void external_writer(void *out, size_t cap) {
+  unsigned char src[16] = {0};
+  src[0] = 2;
+  src[1] = 0;
+  src[2] = 0x00;
+  src[3] = 0x50;
+  src[4] = 0x7F;
+  src[5] = 0x00;
+  src[6] = 0x00;
+  src[7] = 0x01;
+  size_t n = sizeof(src) < cap ? sizeof(src) : cap;
+  memcpy(out, src, n);
+}
+
+int main(void) {
+  struct Storage s;
+  memset(&s, 0, sizeof(s));
+
+  external_writer((void *)&s.buffer, sizeof(s.buffer));
+
+  assert(s.buffer.h.tag == 2);
+  assert(((unsigned char *)&s.buffer.h.port)[0] == 0x00);
+  assert(((unsigned char *)&s.buffer.h.port)[1] == 0x50);
+
+  assert(s.buffer.raw[0] == 2);
+  assert((unsigned char)s.buffer.raw[3] == 0x50);
+
+  return 0;
+}

tests/unit/union_basic.c

@@ -0,0 +1,18 @@
+#include <assert.h>
+
+union basic {
+  int i;
+  float f;
+};
+
+int main(void) {
+  union basic u;
+
+  u.i = 42;
+  assert(u.i == 42);
+
+  u.f = 3.14f;
+  assert(u.f == 3.14f);
+
+  return 0;
+}

tests/unit/union_cross_arm_cast.c

@@ -0,0 +1,46 @@
+// translation-fail
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+struct header_a {
+  uint16_t tag;
+  char data[14];
+};
+
+struct header_b {
+  uint16_t tag;
+  uint16_t port;
+  uint32_t flags;
+  uint8_t body[16];
+  uint32_t extra;
+};
+
+struct Storage {
+  unsigned int len;
+  union {
+    struct header_a a;
+    struct header_b b;
+    char raw[64];
+  } u;
+};
+
+int main(void) {
+  struct Storage s;
+  memset(&s, 0, sizeof(s));
+
+  s.u.a.tag = 10;
+  s.len = sizeof(struct header_b);
+
+  ((struct header_b *)(void *)&s.u.a)->extra = 0xDEADBEEF;
+
+  assert(s.u.b.extra == 0xDEADBEEF);
+  assert(s.u.b.tag == 10);
+
+  s.u.b.port = 0x1F90;
+  assert(((unsigned char *)&s.u.raw)[2] == 0x90);
+  assert(((unsigned char *)&s.u.raw)[3] == 0x1F);
+
+  return 0;
+}

tests/unit/union_field_alignment.c

@@ -0,0 +1,23 @@
+// translation-fail
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+
+struct chunk {
+  struct chunk *next;
+  union {
+    uint8_t data[1];
+    void *dummy;
+  } x;
+};
+
+int main(void) {
+  struct chunk c;
+  c.next = 0;
+  c.x.data[0] = 0xAB;
+
+  assert(c.x.data[0] == 0xAB);
+  assert(sizeof(c.x) >= sizeof(void *));
+  assert(((uintptr_t)&c.x % _Alignof(void *)) == 0);
+  return 0;
+}

tests/unit/union_flex_array_member.c

@@ -0,0 +1,35 @@
+// translation-fail
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct chunk {
+  size_t dlen;
+  union {
+    uint8_t data[1];
+    void *dummy;
+  } x;
+};
+
+int main(void) {
+  size_t chunk_size = 32;
+  struct chunk *c = (struct chunk *)malloc(sizeof(struct chunk) + chunk_size);
+  c->dlen = chunk_size;
+
+  for (size_t i = 0; i < chunk_size; i++) {
+    c->x.data[i] = (uint8_t)(i & 0xFF);
+  }
+  for (size_t i = 0; i < chunk_size; i++) {
+    assert(c->x.data[i] == (uint8_t)(i & 0xFF));
+  }
+
+  uint8_t *p = &c->x.data[10];
+  assert(*p == 10);
+  *p = 0xAA;
+  assert(c->x.data[10] == 0xAA);
+
+  free(c);
+  return 0;
+}

tests/unit/union_memset_memcpy.c

@@ -0,0 +1,55 @@
+// translation-fail
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+struct header_a {
+  uint16_t tag;
+  char data[14];
+};
+
+struct header_b {
+  uint16_t tag;
+  uint16_t port;
+  uint32_t addr;
+  char zero[8];
+};
+
+struct Storage {
+  union {
+    struct header_a a;
+    struct header_b b;
+    char raw[256];
+  } buffer;
+};
+
+int main(void) {
+  struct Storage s;
+
+  memset(&s, 0, sizeof(s));
+  assert(s.buffer.a.tag == 0);
+  assert(s.buffer.b.port == 0);
+  assert(s.buffer.raw[0] == 0);
+  assert(s.buffer.raw[255] == 0);
+
+  unsigned char wire[16] = {0};
+  wire[0] = 2;
+  wire[2] = 0x50;
+  wire[3] = 0x00;
+  wire[4] = 0x7F;
+  wire[5] = 0x00;
+  wire[6] = 0x00;
+  wire[7] = 0x01;
+  size_t len = 16;
+  assert(len <= sizeof(s.buffer.raw));
+  memcpy(&s.buffer.raw, wire, len);
+
+  assert(s.buffer.b.tag == 2);
+  assert(((unsigned char *)&s.buffer.b.port)[0] == 0x50);
+
+  memset(&s, 0, sizeof(s));
+  assert(s.buffer.b.tag == 0);
+
+  return 0;
+}

tests/unit/union_nested.c

@@ -0,0 +1,45 @@
+// translation-fail
+#include <assert.h>
+#include <stdint.h>
+#include <string.h>
+
+struct header {
+  uint16_t tag;
+  char data[14];
+};
+
+struct inner {
+  union {
+    struct header h;
+    char raw[128];
+  } buffer;
+};
+
+struct Outer {
+  int kind;
+  int subtype;
+  int proto;
+  unsigned int len;
+  union {
+    struct header h;
+    struct inner nested;
+  } body;
+};
+
+int main(void) {
+  struct Outer ex;
+  memset(&ex, 0, sizeof(ex));
+
+  ex.kind = 2;
+  ex.subtype = 1;
+  ex.proto = 6;
+  ex.len = sizeof(struct header);
+  ex.body.h.tag = 2;
+  ex.body.h.data[0] = 'X';
+
+  assert(ex.body.h.tag == 2);
+  assert(ex.body.h.data[0] == 'X');
+
+  assert(ex.body.nested.buffer.h.tag == 2);
+  return 0;
+}

tests/unit/union_pointer_pun_address.c

@@ -0,0 +1,26 @@
+// translation-fail
+#include <assert.h>
+
+struct node_a {
+  int n;
+};
+
+struct node_b {
+  void *data;
+  struct node_b *next;
+};
+
+int main(void) {
+  struct node_a a = {123};
+
+  union {
+    struct node_a *to_a;
+    struct node_b *to_b;
+  } ptr;
+
+  ptr.to_a = &a;
+  struct node_b *out = ptr.to_b;
+
+  assert((void *)out == (void *)&a);
+  return 0;
+}

tests/unit/union_pointer_pun_writethrough.c

@@ -0,0 +1,17 @@
+// translation-fail
+#include <assert.h>
+
+int main(void) {
+  long x = -1;
+
+  union {
+    unsigned long *to_ulong;
+    long *to_long;
+  } lptr;
+
+  lptr.to_long = &x;
+  *lptr.to_ulong = 42UL;
+
+  assert(x == 42);
+  return 0;
+}

tests/unit/union_struct_dual_use.c

@@ -0,0 +1,35 @@
+// translation-fail
+#include <assert.h>
+#include <string.h>
+
+struct Inner {
+  int a;
+  int b;
+};
+
+static int sum_inner(struct Inner *i) { return i->a + i->b; }
+
+struct Outer {
+  union {
+    struct Inner inner;
+    char raw[16];
+  } u;
+};
+
+int main(void) {
+  struct Inner standalone;
+  standalone.a = 3;
+  standalone.b = 4;
+  assert(sum_inner(&standalone) == 7);
+
+  struct Outer outer;
+  memset(&outer, 0, sizeof(outer));
+  outer.u.inner.a = 3;
+  outer.u.inner.b = 4;
+  assert(sum_inner(&outer.u.inner) == 7);
+
+  assert((unsigned char)outer.u.raw[0] == 3);
+  assert((unsigned char)outer.u.raw[4] == 4);
+
+  return 0;
+}