ndtypes 0.2.0dev4

data/ext/ruby_ndtypes/ndtypes/libndtypes/tests/test_parse_roundtrip.c

@@ -0,0 +1,350 @@
+/*
+ * BSD 3-Clause License
+ *
+ * Copyright (c) 2017-2018, plures
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+#include <stdio.h>
+#include "test.h"
+
+
+/* Same as test_parse, but can only contain the canonical datashape forms. */
+const char *parse_roundtrip_tests[] = {
+  "2395344366 * Any",
+  "10 * 2395344366 * Any",
+  "10 * 10 * 2395344366 * Any",
+  "L * Any",
+  "10 * L * Any",
+  "10 * 10 * L * Any",
+  "var * Any",
+  "... * Any",
+  "10 * Any",
+  "Any",
+  "10 * ScalarKind",
+  "ScalarKind",
+  "10 * bool",
+  "bool",
+  "10 * SignedKind",
+  "SignedKind",
+  "10 * int8",
+  "int8",
+  "10 * int16",
+  "int16",
+  "10 * int32",
+  "int32",
+  "10 * int64",
+  "int64",
+  "10 * UnsignedKind",
+  "UnsignedKind",
+  "10 * uint8",
+  "uint8",
+  "10 * uint16",
+  "uint16",
+  "10 * uint32",
+  "uint32",
+  "10 * uint64",
+  "uint64",
+  "10 * FloatKind",
+  "FloatKind",
+  "10 * float32",
+  "float32",
+  "10 * float64",
+  "float64",
+  "10 * ComplexKind",
+  "ComplexKind",
+  "10 * complex64",
+  "complex64",
+  "10 * complex128",
+  "complex128",
+  "10 * char('ascii')",
+  "char('ascii')",
+  "10 * char('utf8')",
+  "char('utf8')",
+  "10 * char('utf16')",
+  "char('utf16')",
+  "10 * char('utf32')",
+  "char('utf32')",
+  "10 * char('ucs2')",
+  "char('ucs2')",
+  "10 * string",
+  "string",
+  "10 * FixedStringKind",
+  "FixedStringKind",
+  "10 * fixed_string(729742655, 'ascii')",
+  "fixed_string(729742655, 'ascii')",
+  "10 * fixed_string(3952068488)",
+  "fixed_string(3952068488)",
+  "10 * fixed_string(2949183030, 'utf16')",
+  "fixed_string(2949183030, 'utf16')",
+  "10 * fixed_string(375133997, 'utf32')",
+  "fixed_string(375133997, 'utf32')",
+  "10 * fixed_string(969064578, 'ucs2')",
+  "fixed_string(969064578, 'ucs2')",
+  "10 * bytes(align=16)",
+  "bytes(align=16)",
+  "10 * FixedBytesKind",
+  "FixedBytesKind",
+  "10 * fixed_bytes(size=1904128700, align=4)",
+  "fixed_bytes(size=1904128700, align=4)",
+  "10 * categorical(63)",
+  "categorical(63)",
+  "10 * categorical(10, 63)",
+  "categorical(10, 63)",
+  "10 * categorical(8, 10)",
+  "categorical(8, 10)",
+  "10 * categorical(18514)",
+  "categorical(18514)",
+  "10 * categorical(10, 18514)",
+  "categorical(10, 18514)",
+  "10 * categorical(-176354404)",
+  "categorical(-176354404)",
+  "10 * categorical(-176354404, 10)",
+  "categorical(-176354404, 10)",
+  "10 * categorical(500601201)",
+  "categorical(500601201)",
+  "10 * categorical(10, 500601201)",
+  "categorical(10, 500601201)",
+  "10 * categorical(135)",
+  "categorical(135)",
+  "10 * categorical(10, 135)",
+  "categorical(10, 135)",
+  "10 * categorical(22234)",
+  "categorical(22234)",
+  "10 * categorical(10, 22234)",
+  "categorical(10, 22234)",
+  "10 * categorical(3761672407)",
+  "categorical(3761672407)",
+  "10 * categorical(10, 3761672407)",
+  "categorical(10, 3761672407)",
+  "10 * categorical(2339269771)",
+  "categorical(2339269771)",
+  "10 * categorical(10, 2339269771)",
+  "categorical(10, 2339269771)",
+  "10 * categorical(1.2)",
+  "categorical(-1.2e+33)",
+  "10 * categorical(10, 1.05e+10)",
+  "categorical(10, 1.05e+10)",
+  "10 * categorical(1.05e+300)",
+  "categorical(-1.05e+300)",
+  "10 * categorical(10, 1.05e+300)",
+  "categorical(10, 1.05e+300)",
+  "10 * categorical('jRAMoBPQ')",
+  "categorical('jRAMoBPQ')",
+  "10 * categorical(10, 'jRAMoBPQ')",
+  "categorical(10, 'jRAMoBPQ')",
+  "10 * categorical(127)",
+  "categorical(127)",
+  "10 * categorical(10, 127)",
+  "categorical(10, 127)",
+  "10 * categorical(-128)",
+  "categorical(-128)",
+  "10 * categorical(10, -128)",
+  "categorical(10, -128)",
+  "10 * categorical(32767)",
+  "categorical(32767)",
+  "10 * categorical(10, 32767)",
+  "categorical(10, 32767)",
+  "10 * categorical(-32768)",
+  "categorical(-32768)",
+  "10 * categorical(10, -32768)",
+  "categorical(10, -32768)",
+  "10 * categorical(2147483647)",
+  "categorical(2147483647)",
+  "10 * categorical(10, 2147483647)",
+  "categorical(10, 2147483647)",
+  "10 * categorical(-2147483648)",
+  "categorical(-2147483648)",
+  "10 * categorical(10, -2147483648)",
+  "categorical(10, -2147483648)",
+  "10 * categorical(9223372036854775807)",
+  "categorical(9223372036854775807)",
+  "10 * categorical(10, 9223372036854775807)",
+  "categorical(10, 9223372036854775807)",
+  "10 * categorical(-9223372036854775808)",
+  "categorical(-9223372036854775808)",
+  "10 * categorical(-9223372036854775808, 10)",
+  "categorical(-9223372036854775808, 10)",
+  "10 * categorical(255)",
+  "categorical(255)",
+  "10 * categorical(10, 255)",
+  "categorical(10, 255)",
+  "10 * categorical(65535)",
+  "categorical(65535)",
+  "10 * categorical(10, 65535)",
+  "categorical(10, 65535)",
+  "10 * categorical(4294967295)",
+  "categorical(4294967295)",
+  "10 * categorical(10, 4294967295)",
+  "categorical(10, 4294967295)",
+  "10 * categorical(1.1755e-38)",
+  "categorical(1.1755e-38)",
+  "10 * categorical(10, 1.1755e-38)",
+  "categorical(10, 1.1755e-38)",
+  "10 * categorical(2.22508e-308)",
+  "categorical(2.22508e-308)",
+  "10 * categorical(10, 2.22508e-308)",
+  "categorical(10, 2.22508e-308)",
+  "10 * categorical(3.40282e+38)",
+  "categorical(3.40282e+38)",
+  "10 * categorical(10, 3.40282e+38)",
+  "categorical(10, 3.40282e+38)",
+  "10 * categorical(1.79769e+308)",
+  "categorical(1.79769e+308)",
+  "10 * categorical(10, 1.79769e+308)",
+  "categorical(10, 1.79769e+308)",
+  "10 * categorical('')",
+  "categorical('')",
+  "10 * categorical(10, '')",
+  "categorical(10, '')",
+  "10 * categorical('xyz')",
+  "categorical('xyz')",
+  "10 * categorical(10, 'xyz')",
+  "categorical(10, 'xyz')",
+  "10 * ref(Any)",
+  "ref(Any)",
+  "10 * (...)",
+  "10 * (Any)",
+  "(Any)",
+  "10 * (int64, Any)",
+  "(int64, Any)",
+  "10 * (int64, int64, Any)",
+  "(int64, int64, Any)",
+  "(Any) -> complex64",
+  "Any -> complex64",
+  "10 * (Any, ...)",
+  "(Any, ...)",
+  "10 * {...}",
+  "{...}",
+  "10 * {a : Any}",
+  "{a : Any}",
+  "10 * {x : int64, a : Any}",
+  "{x : int64, a : Any}",
+  "10 * {x : int64, x : int64, a : Any}",
+  "{x : int64, x : int64, a : Any}",
+  "10 * {a : int64}",
+  "{a : int64}",
+  "10 * {a : int64, ...}",
+  "{a : int64, ...}",
+  "(...) -> Any",
+  "() -> (...)",
+  "void -> (int64)",
+  "void -> void",
+  "(Any) -> Any",
+  "Any -> Any",
+  "() -> (Any)",
+  "(int64, Any) -> Any",
+  "int64, Any -> Any",
+  "int64, Any -> float32, (complex128, string)",
+  "() -> (int64, Any)",
+  "(int64, int64, Any) -> Any",
+  "int64, int64, (bytes, ...) -> float32, float64",
+  "() -> (int64, int64, Any)",
+  "(Any, ...) -> Any",
+  "() -> (Any, ...)",
+  "10 * Up",
+  "Up",
+  "10 * X(Any)",
+  "X(Any)",
+
+  /* BEGIN RANDOM */
+  "fixed_bytes(size=1342281600, align=16)",
+  "var * var * var * (...)",
+  "categorical(-84, 18772, 49062, 1619552300, 'a', 'l')",
+  "categorical(24, 44038, 1763886348, 2840608325, 1.2e-32, 'jOt')",
+  "categorical(-2049848438, 94, 3577056037, 3599739756, 1.2e-32)",
+  "categorical(2753441703, 1.2e-32)",
+  "1286044356 * LbR6JPFI * 2096958782 * uint8",
+  "categorical(-25910, 4265882500, 1.2e-32, 'xM3Mys0XqH')",
+  "var * var * FixedBytesKind",
+  "var * var * var * fixed_bytes(size=2816010912, align=16)",
+  "36 * 16 * fixed_bytes(size=912328236, align=2)",
+  "var * var * var * ZcTmBXnKPi",
+  "categorical(946986991, 43, 'omhwkoWVWw')",
+  "var * float32",
+  "var * var * var * uint16",
+  "var * var * var * ScalarKind",
+  "fixed_bytes(size=280180300, align=2)",
+  "fixed_string(1901614748, 'utf32')",
+  "var * M7",
+  "var * bytes(align=2)",
+  "fixed_bytes(size=1882259712, align=16)",
+  "categorical(-83, -58, 1.2e-32)",
+  "3739637665 * 1476113530 * 1701021063 * IKd * 450514382 * WXn",
+  "ref(AilcKv4su1(FixedBytesKind))",
+  "var * QoFb",
+  "var * fixed_string(1233383142, 'utf32')",
+  "fixed_bytes(size=2882797900, align=2)",
+  "fixed_bytes(size=1233209904, align=8)",
+  "WhRsMHHXYp(categorical(145))",
+  "var * var * bytes(align=2)",
+  "categorical(-85, -49, -26791, 8094, 1780, 1.2e-32, 'pX')",
+  "D6nfBg_(categorical(16278, 26651, 147170982, 1.2e-32, 'ylR7'))",
+  "categorical(482331467, 3229733591, -1.2e-32, 1.2e-32)",
+  /* END RANDOM */
+
+  /* BEGIN MANUALLY GENERATED */
+  "()",
+  "{}",
+  "() -> ()",
+  "(...) -> ()",
+  "(...) -> (...)",
+  "(int64, ...) -> complex128",
+  "() -> int32",
+  "(int32) -> int32",
+  "(int32, float64) -> int32",
+  "(...) -> int32",
+  "(int32, ...) -> int32",
+  "(int32, float32, ...) -> int32",
+
+  "10 * defined_t",
+  "defined_t",
+
+  "10 * foo_t",
+  "foo_t",
+
+  "() -> void",
+  "(int32, ...) -> void",
+
+  "<int64",
+  ">int64",
+  "2 * 10 * >float64",
+
+  /* Fortran */
+  "!2 * 3 * uint8",
+  "!2 * 3 * {a : !10 * 20 * int64, b : !10 * 2 * float64}",
+
+  /* Overflow */
+  "9223372036854775807 * uint8",
+  "1 * 1 * 9223372036854775807 * uint8",
+
+  /* END MANUALLY GENERATED */
+
+  NULL
+};

data/ext/ruby_ndtypes/ndtypes/libndtypes/tests/test_record.c

@@ -0,0 +1,231 @@
+/*
+ * BSD 3-Clause License
+ *
+ * Copyright (c) 2017-2018, plures
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdalign.h>
+#include <stddef.h>
+#include <string.h>
+#include <assert.h>
+#include "ndtypes.h"
+#include "test.h"
+
+
+#ifdef __clang__
+  #pragma clang diagnostic ignored "-Wgnu-alignof-expression"
+#endif
+
+
+/*********************************************************************/
+/*                 struct packing and alignment                      */
+/*********************************************************************/
+
+#ifdef __GNUC__
+typedef struct {
+    uint8_t u1;
+    int64_t i1 __attribute__((packed, aligned(1))); // align >= 1
+    uint8_t u2;
+    int64_t i2 __attribute__((packed, aligned(1))); // align >= 1
+    uint8_t u3;
+} packed_no_trailing_padding_t;
+
+typedef struct __attribute__((aligned(2))) {
+    char u1;
+    int64_t i1 __attribute__((packed, aligned(1))); // align >= 1
+    char u2;
+    int64_t i2 __attribute__((packed, aligned(1))); // align >= 1
+    char u3;
+} packed_with_trailing_padding_t;
+
+typedef struct {
+    char u1 __attribute__((aligned(16)));   // align >= 16
+    int64_t i1 __attribute__((aligned(8))); // align >= max(1, alignof(int64_t))
+    char u2;
+} aligned_t;
+
+
+int
+test_struct_align_pack(void)
+{
+    static const char *s1 =
+       "{u1: uint8, i1: int64 |pack=1|, u2: uint8, i2: int64 |pack=1|, u3: uint8}";
+    static const char *s1_abbrev =
+       "{u1: uint8, i1: int64, u2: uint8, i2: int64, u3: uint8, pack=1}";
+    static const char *s2 =
+       "{u1: uint8, i1: int64 |pack=1|, u2: uint8, i2: int64 |pack=1|, u3: uint8, align=2}";
+    static const char *s3 =
+       "{u1: uint8 |align=16|, i1: int64 |align=8|, u2 : uint8}";
+    packed_no_trailing_padding_t packed_no_trail;
+    packed_with_trailing_padding_t packed_with_trail;
+    aligned_t aligned;
+    ndt_context_t *ctx;
+    ndt_t *t;
+
+    ctx = ndt_context_new();
+    if (ctx == NULL) {
+        fprintf(stderr, "error: out of memory");
+        return -1;
+    }
+
+    t = ndt_from_string(s1, ctx);
+    if (t == NULL) {
+        fprintf(stderr, "test_struct_align_pack: parse: FAIL: %s\n",
+                ndt_context_msg(ctx));
+        ndt_context_del(ctx);
+        return -1;
+    }
+    if (ndt_is_abstract(t)) {
+        fprintf(stderr,
+            "test_struct_align_pack: parse: FAIL: unexpected abstract type\n");
+        ndt_context_del(ctx);
+        return -1;
+    }
+
+    if (t->datasize != sizeof(packed_no_trail) ||
+        t->align != alignof(packed_no_trail) ||
+        t->Concrete.Record.offset[0] != offsetof(packed_no_trailing_padding_t, u1) ||
+        t->Concrete.Record.align[0] !=  alignof(packed_no_trail.u1) ||
+        t->Concrete.Record.offset[1] != offsetof(packed_no_trailing_padding_t, i1) ||
+        t->Concrete.Record.align[1] !=  alignof(packed_no_trail.i1) ||
+        t->Concrete.Record.offset[2] != offsetof(packed_no_trailing_padding_t, u2) ||
+        t->Concrete.Record.align[2] !=  alignof(packed_no_trail.u2) ||
+        t->Concrete.Record.offset[3] != offsetof(packed_no_trailing_padding_t, i2) ||
+        t->Concrete.Record.align[3] !=  alignof(packed_no_trail.i2) ||
+        t->Concrete.Record.offset[4] != offsetof(packed_no_trailing_padding_t, u3) ||
+        t->Concrete.Record.align[4] !=  alignof(packed_no_trail.u3)) {
+        fprintf(stderr, "test_struct_align_pack: packed_no_trail: FAIL");
+        ndt_context_del(ctx);
+    }
+    ndt_del(t);
+
+
+    t = ndt_from_string(s1_abbrev, ctx);
+    if (t == NULL) {
+        fprintf(stderr, "test_struct_align_pack: parse: FAIL: %s\n",
+                ndt_context_msg(ctx));
+        ndt_context_del(ctx);
+        return -1;
+    }
+    if (ndt_is_abstract(t)) {
+        fprintf(stderr,
+            "test_struct_align_pack: parse: FAIL: unexpected abstract type\n");
+        ndt_context_del(ctx);
+        return -1;
+    }
+
+    if (t->datasize != sizeof(packed_no_trail) ||
+        t->align != alignof(packed_no_trail) ||
+        t->Concrete.Record.offset[0] != offsetof(packed_no_trailing_padding_t, u1) ||
+        t->Concrete.Record.align[0] !=  alignof(packed_no_trail.u1) ||
+        t->Concrete.Record.offset[1] != offsetof(packed_no_trailing_padding_t, i1) ||
+        t->Concrete.Record.align[1] !=  alignof(packed_no_trail.i1) ||
+        t->Concrete.Record.offset[2] != offsetof(packed_no_trailing_padding_t, u2) ||
+        t->Concrete.Record.align[2] !=  alignof(packed_no_trail.u2) ||
+        t->Concrete.Record.offset[3] != offsetof(packed_no_trailing_padding_t, i2) ||
+        t->Concrete.Record.align[3] !=  alignof(packed_no_trail.i2) ||
+        t->Concrete.Record.offset[4] != offsetof(packed_no_trailing_padding_t, u3) ||
+        t->Concrete.Record.align[4] !=  alignof(packed_no_trail.u3)) {
+        fprintf(stderr, "test_struct_align_pack: packed_no_trail_abbrev: FAIL\n");
+        ndt_context_del(ctx);
+    }
+    ndt_del(t);
+
+
+    t = ndt_from_string(s2, ctx);
+    if (t == NULL) {
+        fprintf(stderr, "test_struct_align_pack: parse: FAIL: %s\n",
+                ndt_context_msg(ctx));
+        ndt_context_del(ctx);
+        return -1;
+    }
+    if (ndt_is_abstract(t)) {
+        fprintf(stderr,
+            "test_struct_align_pack: parse: FAIL: unexpected abstract type\n");
+        ndt_context_del(ctx);
+        return -1;
+    }
+
+    if (t->datasize != sizeof(packed_with_trail) ||
+        t->align != alignof(packed_with_trail) ||
+        t->Concrete.Record.offset[0] != offsetof(packed_with_trailing_padding_t, u1) ||
+        t->Concrete.Record.align[0] !=  alignof(packed_with_trail.u1) ||
+        t->Concrete.Record.offset[1] != offsetof(packed_with_trailing_padding_t, i1) ||
+        t->Concrete.Record.align[1] !=  alignof(packed_with_trail.u1) ||
+        t->Concrete.Record.offset[2] != offsetof(packed_with_trailing_padding_t, u2) ||
+        t->Concrete.Record.align[2] !=  alignof(packed_with_trail.u2) ||
+        t->Concrete.Record.offset[3] != offsetof(packed_with_trailing_padding_t, i2) ||
+        t->Concrete.Record.align[3] !=  alignof(packed_with_trail.i2) ||
+        t->Concrete.Record.offset[4] != offsetof(packed_with_trailing_padding_t, u3) ||
+        t->Concrete.Record.align[4] !=  alignof(packed_with_trail.u3)) {
+        fprintf(stderr, "test_struct_align_pack: packed_with_trail: FAIL");
+        ndt_context_del(ctx);
+    }
+    ndt_del(t);
+
+
+    t = ndt_from_string(s3, ctx);
+    if (t == NULL) {
+        fprintf(stderr, "test_struct_align_pack: parse: FAIL: %s\n",
+                ndt_context_msg(ctx));
+        ndt_context_del(ctx);
+        return -1;
+    }
+    if (ndt_is_abstract(t)) {
+        fprintf(stderr,
+            "test_struct_align_pack: parse: FAIL: unexpected abstract type\n");
+        ndt_context_del(ctx);
+        return -1;
+    }
+
+    if (t->datasize != sizeof(aligned) ||
+        t->align != alignof(aligned) ||
+        t->Concrete.Record.offset[0] != offsetof(aligned_t, u1) ||
+        t->Concrete.Record.align[0] !=  alignof(aligned.u1) ||
+        t->Concrete.Record.offset[1] != offsetof(aligned_t, i1) ||
+        t->Concrete.Record.align[1] !=  alignof(aligned.i1) ||
+        t->Concrete.Record.offset[2] != offsetof(aligned_t, u2) ||
+        t->Concrete.Record.align[2] != alignof(aligned.u2)) {
+        fprintf(stderr, "test_struct_align_pack: aligned: FAIL");
+        ndt_context_del(ctx);
+    }
+    ndt_del(t);
+
+    fprintf(stderr, "test_struct_align_pack (4 test cases)\n");
+
+    ndt_context_del(ctx);
+    return 0;
+}
+#endif
+
+