X-Git-Url: https://git.distorted.org.uk/~mdw/sod/blobdiff_plain/fd040f066b906ce63396b9703bc16d32bcc5204e..e895be217c3be6769708da17c9ae87cb22db040e:/test/test.sod

diff --git a/test/test.sod b/test/test.sod
index 192f631..72febd5 100644
--- a/test/test.sod
+++ b/test/test.sod
@@ -1,4 +1,28 @@
-/* -*-sod-*- */
+/* -*-sod-*- *
+ *
+ * Test program for Sod functionality
+ *
+ * (c) 2016 Straylight/Edgeware
+ */
+
+/*----- Licensing notice --------------------------------------------------*
+ *
+ * This file is part of the Sensible Object Design, an object system for C.
+ *
+ * SOD is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * SOD is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with SOD; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
 
 code h: includes {
 #include "sod.h"
@@ -135,36 +159,51 @@ static int check_vec(struct vec *v, ...)
 
 }
 
-[link = SodObject, nick = t1base]
+[link = SodObject, nick = base]
 class T1Base: SodObject {
-  [combination = progn] void aprogn() { STEP(1); }
-  [combination = sum] int asum() { return 1; }
-  [combination = and] int aand() { return 8; }
-  [combination = max] int amax() { return 12; }
+  int plain(int x) { STEP(x); return (x + 1); }
+
+  [combination = progn] void aprogn();
+  [combination = sum] int asum();
+  [combination = and] int aand();
+  [combination = max] int amax();
+  [role = around] int base.asum() { return (CALL_NEXT_METHOD); }
 
   [combination = custom,
+   empty = { sod_ret = 0; },
    decls = { struct item **head = &sod_ret; },
    each = { *head = sod_val; head = &sod_val->next; },
    after = { *head = 0; }]
-  struct item *alist() { return make_item("base"); }
+  struct item *alist();
 
   [combination = custom,
    decls = { int *v; size_t i = 0; }, methty = <int>, count = n,
+   empty = { sod_ret.v = 0; sod_ret.n = 0; },
    before = { v = xmalloc(n*sizeof(int)); },
    each = { v[i++] = sod_val; },
    after = { sod_ret.v = v; sod_ret.n = n; }]
   struct vec avec();
-  int t1base.avec() { return 19; }
 }
 
-[link = T1Base, nick = t1sub]
-class T1Sub: T1Base {
-  void t1base.aprogn() { STEP(0); }
-  int t1base.asum() { return 2; }
-  int t1base.aand() { return 6; }
-  int t1base.amax() { return 17; }
-  struct item *t1base.alist() { return make_item("sub"); }
-  int t1base.avec() { return 4; }
+[link = T1Base, nick = mid]
+class T1Mid: T1Base {
+  int base.plain(int x) { STEP(x - 1); return (CALL_NEXT_METHOD); }
+  void base.aprogn() { STEP(1); }
+  int base.asum() { return 1; }
+  int base.aand() { return 8; }
+  int base.amax() { return 12; }
+  struct item *base.alist() { return make_item("mid"); }
+  int base.avec() { return 19; }
+}
+
+[link = T1Mid, nick = sub]
+class T1Sub: T1Mid {
+  void base.aprogn() { STEP(0); }
+  int base.asum() { return 2; }
+  int base.aand() { return 6; }
+  int base.amax() { return 17; }
+  struct item *base.alist() { return make_item("sub"); }
+  int base.avec() { return 4; }
 }
 
 code c: tests {
@@ -172,17 +211,33 @@ code c: tests {
   { SOD_DECL(T1Base, t1, NO_KWARGS);
     struct item *l;
     struct vec v;
+    STEP(0); T1Base_aprogn(t1); STEP(1);
+    if (T1Base_asum(t1) == 0) STEP(2);
+    if (T1Base_aand(t1) == 1) STEP(3);
+    if (!t1->_vt->base.amax) STEP(4);
+    l = T1Base_alist(t1);
+    if (!l) STEP(5);
+    v = T1Base_avec(t1);
+    if (!v.n) STEP(6);
+    STEP(T1Base_plain(t1, 7)); /* 7, 8 */
+    DONE(9);
+  }
+  prepare("aggregate, mid");
+  { SOD_DECL(T1Mid, t1, NO_KWARGS);
+    struct item *l;
+    struct vec v;
     STEP(0); T1Base_aprogn(t1); /* 1 */
     if (T1Base_asum(t1) == 1) STEP(2);
     if (T1Base_aand(t1) == 8) STEP(3);
     if (T1Base_amax(t1) == 12) STEP(4);
     l = T1Base_alist(t1);
-    if (!check_list(l, "base", (const char *)0)) STEP(5);
+    if (!check_list(l, "mid", (const char *)0)) STEP(5);
     free_list(l);
     v = T1Base_avec(t1);
     if (!check_vec(&v, 19, -1)) STEP(6);
     free_vec(&v);
-    DONE(7);
+    STEP(T1Base_plain(t1, 8)); /* 7, 8, 9 */
+    DONE(10);
   }
   prepare("aggregate, sub");
   { SOD_DECL(T1Sub, t1, NO_KWARGS);
@@ -193,7 +248,7 @@ code c: tests {
     if (T1Base_aand(t1) == 8) STEP(3);
     if (T1Base_amax(t1) == 17) STEP(4);
     l = T1Base_alist(t1);
-    if (!check_list(l, "sub", "base", (const char *)0)) STEP(5);
+    if (!check_list(l, "sub", "mid", (const char *)0)) STEP(5);
     free_list(l);
     v = T1Base_avec(t1);
     if (!check_vec(&v, 4, 19, -1)) STEP(6);
@@ -207,11 +262,20 @@ code c: tests {
 [link = SodObject, nick = t2]
 class T2: SodObject {
   [initarg = x] int x = 0;
+  [initarg = z] t2.x;
 
   initarg int y = 1;
   init { if (!y) STEP(0); }
 }
 
+[link = T2]
+class T2Sub: T2 {
+  [initarg = a] t2.x;
+  [initarg = b] t2.x;
+  [initarg = x] t2.x;
+  [initarg = c] t2.x;
+}
+
 code c: tests {
   prepare("initargs, defaults");
   { SOD_DECL(T2, t, NO_KWARGS);
@@ -223,6 +287,21 @@ code c: tests {
     if (t->t2.x == 42) STEP(1);
     DONE(2);
   }
+  prepare("initargs, inheritance");
+  { SOD_DECL(T2Sub, t, KWARGS(K(c, 1) K(z, 2)));
+    if (t->t2.x == 1) STEP(0);
+    DONE(1);
+  }
+  prepare("initargs, ordering");
+  { SOD_DECL(T2Sub, t, KWARGS(K(a, 1) K(b, 2)));
+    if (t->t2.x == 1) STEP(0);
+    DONE(1);
+  }
+  prepare("initargs, reprioritizing");
+  { SOD_DECL(T2Sub, t, KWARGS(K(x, 1) K(c, 2)));
+    if (t->t2.x == 1) STEP(0);
+    DONE(1);
+  }
 }
 
 /*----- Keyword argument propagation --------------------------------------*/
@@ -254,4 +333,24 @@ code c: tests {
   }
 }
 
+/*----- Metaclass initialization ------------------------------------------*/
+
+[link = SodClass, nick = mycls]
+class MyClass: SodClass {
+  int x = -1, y, z = 2;
+}
+
+[nick = myobj, metaclass = MyClass]
+class MyObject: SodObject {
+  class mycls.x = 0, mycls.y = 1;
+}
+
+code c: tests {
+  prepare("metaclass, init");
+  STEP(MyObject__cls_obj->mycls.x);
+  STEP(MyObject__cls_obj->mycls.y);
+  STEP(MyObject__cls_obj->mycls.z);
+  DONE(3);
+}
+
 /*----- That's all, folks -------------------------------------------------*/