--- /dev/null
+// initializers
+
+void testi(int *recieved, int *wanted, int length) {
+ for (int i = 0; i < length; i++)
+ expecti(recieved[i], wanted[i]);
+}
+
+void tests(short *recieved, short *wanted, int length) {
+ for (int i = 0; i < length; i++)
+ expects(recieved[i], wanted[i]);
+}
+
+void testarray(void) {
+ int a[] = { 1, 2, 3 };
+ int b[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+ int c[3][3] = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
+ int d[3][3] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+ int e[] = { 1, 0, 0, 2, 0, 0, 3, 0, 0, 4, 0, 0 };
+ int f[4][3] = { { 1 }, { 2 }, { 3 }, { 4 } };
+
+ expecti(a[0], 1);
+ expecti(a[1], 2);
+ expecti(a[2], 3);
+
+ testi(b, c, 9);
+ testi(c, d, 9);
+ testi(e, f, 12);
+
+ short g[] = {
+ 1, 0, 0, 0, 0,
+ 0, 2, 3, 0, 0,
+ 0, 0, 4, 5, 6
+ };
+
+ short h[4][3][2] = {
+ { 1 },
+ { 2, 3 },
+ { 4, 5, 6 }
+ };
+
+ tests(g, h, 15);
+}
+
+void teststruct(void) {
+ int a[] = {
+ 1, 0, 0, 0,
+ 2, 0, 0, 0
+ };
+
+ struct {
+ int a[3];
+ int b;
+ } data[] = { { 1 }, 2 };
+
+ testi(&data, a, 8);
+}
+
+void testnesting(void) {
+ struct {
+ struct {
+ struct {
+ int a;
+ int b;
+ } a;
+
+ struct {
+ char a[8];
+ } b;
+ } a;
+ } data = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+
+ expecti(data.a.a.a, 1);
+ expecti(data.a.a.b, 2);
+ expecti(data.a.b.a[0], 3);
+ expecti(data.a.b.a[1], 4);
+ expecti(data.a.b.a[2], 5);
+ expecti(data.a.b.a[3], 6);
+ expecti(data.a.b.a[4], 7);
+ expecti(data.a.b.a[5], 8);
+ expecti(data.a.b.a[6], 9);
+ expecti(data.a.b.a[7], 10);
+}
+
+void testdesignated(void) {
+ struct { int a, b, c; } a = {
+ .a = 1024,
+ .b = 2048,
+ .c = 4096,
+ };
+
+ struct { int a, b, c; } b = {
+ .c = 4096,
+ .b = 2048,
+ .a = 1024
+ };
+
+ struct { int a, b, c; } c = {
+ .b = 2048,
+ 4096, // should be c
+ .a = 1024
+ };
+
+ expecti(a.a, 1024);
+ expecti(a.b, 2048);
+ expecti(a.c, 4096);
+ expecti(b.a, 1024);
+ expecti(b.b, 2048);
+ expecti(b.c, 4096);
+ expecti(c.a, 1024);
+ expecti(c.b, 2048);
+ expecti(c.c, 4096);
+
+ // array designated initializers
+ int array[3] = { [1] = 1024 };
+ expecti(array[0], 0);
+ expecti(array[1], 1024);
+ expecti(array[2], 0);
+
+ // for structs too
+ struct {
+ int a, b;
+ } data[2] = { [1] = { 1, 2 } };
+
+ expecti(data[1].a, 1);
+ expecti(data[1].b, 2);
+ expecti(data[0].a, 0);
+ expecti(data[0].b, 0);
+
+ // splatted too
+ struct {
+ int a, b;
+ } data2[3] = { [1] = 10, 20, 30, 40 };
+ expecti(data2[0].a, 0);
+ expecti(data2[0].b, 0);
+ expecti(data2[1].a, 10);
+ expecti(data2[1].b, 20);
+ expecti(data2[2].a, 30);
+ expecti(data2[2].b, 40);
+
+ struct {
+ struct {
+ int a, b;
+ } c[3];
+ } again[] = {
+ [1].c[0].b = 10, 20, 30, 40, 50,
+ [0].c[2].b = 60, 70
+ };
+ expecti(10, again[1].c[0].b);
+ expecti(20, again[1].c[1].a);
+ expecti(30, again[1].c[1].b);
+ expecti(40, again[1].c[2].a);
+ expecti(50, again[1].c[2].b);
+ expecti(60, again[0].c[2].b);
+ expecti(70, again[1].c[0].a);
+
+ int A[][3] = { [0][0] = 10, [1][0] = 20 };
+ struct { int a, b[3]; } B = { .a = 10, .b[0] = 20, .b[1] = 30 };
+
+ expecti(A[0][0], 10);
+ expecti(A[1][0], 20);
+ expecti(B.a, 10);
+ expecti(B.b[0], 20);
+ expecti(B.b[1], 30);
+ expecti(B.b[2], 0);
+}
+
+void testorder(void) {
+ int order[4] = { [2] = 30, [0] = 10, 20 };
+
+ expecti(order[0], 10);
+ expecti(order[1], 20);
+ expecti(order[2], 30);
+}
+
+void testzero(void) {
+ struct { int a, b; } a = { 1024 };
+ struct { int a, b; } b = { .b = 1024 };
+
+ expecti(a.a, 1024);
+ expecti(a.b, 0);
+ expecti(b.a, 0);
+ expecti(b.b, 1024);
+}
+
+void testtypedef(void) {
+ typedef int array[];
+ array a = { 1, 2, 3 };
+ array b = { 4, 5, 6 };
+
+ expecti(sizeof(a) / sizeof(*a), 3);
+ expecti(sizeof(b) / sizeof(*b), 3);
+
+ expecti(a[0], 1);
+ expecti(a[1], 2);
+ expecti(a[2], 3);
+ expecti(b[0], 4);
+ expecti(b[1], 5);
+ expecti(b[2], 6);
+}
+
+int main(void) {
+ testarray();
+ testnesting();
+ teststruct();
+ testdesignated();
+ testzero();
+ testtypedef();
+ testorder();
+
+ int primitive = { 1024 };
+ expecti(primitive, 1024);
+
+ // test odd string initializers
+ char f[] = "abc"; expectstr(f, "abc");
+ char g[] = { "cba" }; expectstr(g, "cba");
+
+ return 0;
+}