rudy4 0.2.0

data/src/rudy/objproto.d

@@ -0,0 +1,282 @@
+/// Object-protocol boilerplate for RudyTypedData-wrapped structs.
+///
+/// A bare RudyTypedData!() wrapper gives Ruby a pointer-holding T_DATA
+/// object and nothing else:
+///   - `dup`/`clone` shallow-copy the WRAPPER — both handles end up
+///     pointing at the same struct (finding #19),
+///   - `inspect` shows the useless default `#<Class:0x...>`,
+///   - two wrappers holding byte-identical structs are never `==`,
+///   - `Object#hash` is identity-based, so == wrappers don't hash equal
+///     and can't be Hash keys,
+///   - `freeze` sets the flag but nothing enforces it: a mutator writes
+///     straight through into the "frozen" struct (finding #20).
+///
+/// This mixin generates the missing pieces, C-API style:
+///
+///     struct Vec2 { double x, y; }
+///     mixin RudyTypedData!(Vec2, "vec2");
+///     mixin RudyObjectProtocol!(Vec2, "vec2",
+///                               null, null, null,
+///                               vec2_inspect);       // hooks optional
+///     // in Init_*:
+///     vec2_proto_install(klass);
+///
+/// `name` must be the SAME name passed to RudyTypedData — the generated
+/// code references `<name>_get`, `<name>_type` and the class name.
+///
+/// What install() defines on the class:
+///   allocate          rb_data_typed_object_zalloc — a zeroed T in Ruby's
+///                     GC heap; dfree still runs at collection.
+///   initialize_copy   struct-assignment in place (PRIVATE, like Ruby's
+///                     own). Ruby implements dup AND clone through this
+///                     one hook: dup = alloc + initialize_copy, clone =
+///                     alloc + initialize_copy + frozen-state propagation.
+///                     Optional copyHook runs after the struct copy
+///                     (deep-copy malloc'd fields; see struct-copy rules).
+///   == / eql?         default: memcmp over T.sizeof. Non-wrapper other
+///                     -> Qfalse_ (== must not raise). eql? aliases ==.
+///   hash              default: FNV-1a over T.sizeof bytes — memcmp-equal
+///                     structs hash equal, keeping the ==/hash contract.
+///   inspect           "#<ClassName inner>" via inspectHook; with no hook
+///                     install() skips inspect entirely (Ruby's default
+///                     stays).
+///
+/// Custom hooks (all optional, pass null to take the default). Hooks
+/// are ALIAS parameters — pass the symbol BARE (no `&`): GDC 14 rejects
+/// `&fn` as a template value argument entirely (finding #22). Pointer
+/// and ref call conventions both work per hook:
+///   copyHook    (T* dst, const(T*) src)  or  (ref T, ref const(T))
+///   equalsHook  (const(T*) a, const(T*) b)  or  (ref const(T), ref const(T))
+///   hashHook    (const(T*) p)  or  (ref const(T))
+///   inspectHook (const(T*) p)  or  (ref const(T))
+///
+/// Hook users own the ==/hash contract: if equalsHook says two structs
+/// are equal, hashHook must return the same value for both.
+///
+/// Struct-copy rules for initialize_copy (NB):
+///   - pointers embedded in T are copied by VALUE (shallow). Use copyHook
+///     to deep-copy malloc'd fields — free the old buffer first or the
+///     allocate() zeroing leaks it on the fresh wrapper.
+///   - D-GC pointers inside T do NOT survive the copy by D-GC rules: the
+///     struct bytes live in Ruby's GC heap where D's collector cannot
+///     see them, so a new wrapper's struct may point at memory D's GC
+///     considers unreachable. Root such pointers D-side (GC.addRange /
+///     a module-scope anchor) — malloc-owned fields (freed in a custom
+///     dfree) are the safe pattern.
+
+module rudy.objproto;
+
+import rudy.bind.value;
+import rudy.convert;
+import rudy.typeddata;
+
+import core.stdc.string : memcmp;
+import std.string : toStringz;
+
+public:
+
+// Symbols the generated string-mixins reference. String-mixin bodies
+// resolve names at the mixin SITE (the user's module), not here — so
+// every module that instantiates RudyObjectProtocol must be able to see
+// them. `public import` re-exports from any module that imports
+// rudy.objproto.
+public import rudy.bind.value : VALUE, Qfalse_, rb_data_typed_object_zalloc,
+    rb_define_alloc_func, rb_define_private_method, rb_define_method,
+    rb_define_alias, rb_obj_class, rb_class2name, rb_str_new_cstr, rb_str_cat,
+    AnyMethod;
+public import rudy.convert : to_ruby_value;
+public import rudy.typeddata : RbDataType, RudyTypedData;
+
+// ---------------------------------------------------------------- helpers
+
+/// FNV-1a over n bytes — the default hash for memcmp-style ==.
+size_t rudy_fnv1a(const void* p, size_t n) @nogc nothrow pure
+{
+    size_t h = 0xcbf29ce484222325UL;
+    auto b = cast(const ubyte*) p;
+    foreach (i; 0 .. n)
+    {
+        h ^= b[i];
+        h *= 0x100000001b3UL;
+    }
+    return h;
+}
+
+// ---------------------------------------------------------------- mixin
+
+// static-if for string-mixin bodies: pick one code snippet at CT.
+// Lives inside the template below (per-instance) — multiple
+// RudyObjectProtocol instantiations in one module cannot collide.
+// Ruby's Hash#hash values are signed; mask off the sign bit so the
+// unsigned machine word decodes as a non-negative Integer everywhere.
+// Public so generated mixin code (resolved at the mixin site) can use it.
+public enum size_t rudy_hash_mask = 0x7fff_ffff_ffff_ffffUL;
+
+/// memcmp-style byte equality over n bytes — the default == for
+/// memcmp-able structs. Public for the same reason as rudy_hash_mask.
+public bool rudy_bytes_eq(const void* a, const void* b, size_t n)
+{
+    return memcmp(a, b, n) == 0;
+}
+
+/// Hooks are ALIAS template parameters — GDC 14 rejects `&fn` as a
+/// template value argument for typed fp params (finding #22: even
+/// extern(C)-linkage; only default values like typeddata's
+/// `= &rudy_typed_free` parse, because defaults are normal expressions,
+/// not template arguments). Pass hook symbols BARE:
+///
+///   mixin RudyObjectProtocol!(Vec2, "vec2", null, null, null, vec2_inspect);
+///
+/// Hook presence is probed with __traits(compiles, hook(args...)) —
+/// no `!is null` checks (an alias may not support that). Wrong-arity
+/// or non-callable aliases safely take the default path. Both call
+/// conventions are accepted per hook:
+///   size_t hashHook(const(T*) p)          — pointer style
+///   size_t hashHook(ref const(T) p)       — ref style
+/// (the mixin probes ptr-call first, then deref-call, at compile time).
+template RudyObjectProtocol(T,
+                            string name,
+                            alias copyHook = null,
+                            alias equalsHook = null,
+                            alias hashHook = null,
+                            alias inspectHook = null)
+{
+    // staticIf lives INSIDE the template: instantiated per-param, never
+    // collides across multiple instantiations in one module.
+    private template staticIf(bool cond, string yes, string no)
+    {
+        static if (cond)
+            enum string staticIf = yes;
+        else
+            enum string staticIf = no;
+    }
+
+    // Presence probes — compile-time, per hook. Try pointer-style call
+    // first, then ref-style (deref) call.
+    private enum string copyCall =
+        staticIf!(__traits(compiles, copyHook(cast(T*) null, cast(T*) null)),
+            "    copyHook(d, s);",
+        staticIf!(__traits(compiles, copyHook(*cast(T*) null, *cast(T*) null)),
+            "    copyHook(*d, *s);",
+            ""));
+
+    private enum string eqCall =
+        staticIf!(__traits(compiles, equalsHook(cast(const(T)*) null, cast(const(T)*) null)),
+            "    return to_ruby_value(equalsHook(a, b));",
+        staticIf!(__traits(compiles, equalsHook(*cast(const(T)*) null, *cast(const(T)*) null)),
+            "    return to_ruby_value(equalsHook(*a, *b));",
+            ""));
+
+    private enum string hashCall =
+        staticIf!(__traits(compiles, hashHook(cast(const(T)*) null)),
+            "    return to_ruby_value(hashHook(p) & rudy_hash_mask);",
+        staticIf!(__traits(compiles, hashHook(*cast(const(T)*) null)),
+            "    return to_ruby_value(hashHook(*p) & rudy_hash_mask);",
+            ""));
+
+    private enum string inspCall =
+        staticIf!(__traits(compiles, inspectHook(cast(const(T)*) null)),
+            "    string inner = inspectHook(p);",
+        staticIf!(__traits(compiles, inspectHook(*cast(const(T)*) null)),
+            "    string inner = inspectHook(*p);",
+            ""));
+
+    private enum bool hasEquals = eqCall.length > 0;
+    private enum bool hasHash = hashCall.length > 0;
+    private enum bool hasInspect = inspCall.length > 0;
+
+    // ---- generate the extern(C) methods via a string mixin ----------
+
+    private enum string eqBody =
+        "    T* a = " ~ name ~ "_get(self);" ~
+        "    if (!rb_typeddata_is_kind_of(other, &" ~ name ~ "_type))" ~
+        "        return Qfalse_;" ~
+        "    T* b = " ~ name ~ "_get(other);" ~
+        staticIf!(hasEquals,
+            eqCall,
+            "    return to_ruby_value(rudy_bytes_eq(a, b, T.sizeof));");
+
+    private enum string hashBody =
+        "    T* p = " ~ name ~ "_get(self);" ~
+        staticIf!(hasHash,
+            hashCall,
+            "    return to_ruby_value(rudy_fnv1a(p, T.sizeof) & rudy_hash_mask);");
+
+    // inspect: generated ONLY with a hook (else Ruby's default stands).
+    private static if (hasInspect)
+        private enum string inspectFn =
+            "extern (C) VALUE " ~ name ~ "_proto_inspect(VALUE self)" ~
+            "{" ~
+            "    T* p = " ~ name ~ "_get(self);" ~
+            inspCall ~
+            "    VALUE out_ = rb_str_new_cstr(\"#<\");" ~
+            "    VALUE klass = rb_obj_class(self);" ~
+            "    const(char)* cn = rb_class2name(klass);" ~
+            "    size_t cnlen = 0; while (cn[cnlen]) cnlen++;" ~
+            "    rb_str_cat(out_, cn, cast(long) cnlen);" ~
+            "    rb_str_cat(out_, \": \", 2);" ~
+            "    rb_str_cat(out_, inner.ptr, cast(long) inner.length);" ~
+            "    rb_str_cat(out_, \">\", 1);" ~
+            "    return out_;" ~
+            "}";
+    else
+        private enum string inspectFn = "";
+
+    private static if (hasInspect)
+        private enum string inspectDef =
+            "    rb_define_method(klass, \"inspect\", cast(AnyMethod) &" ~
+                    name ~ "_proto_inspect, 0);";
+    else
+        private enum string inspectDef = "";
+
+    // ---- install(): defines everything on the class ------------------
+    //
+    // allocate: zalloc zeroes T INSIDE Ruby's GC heap (prototype
+    // confirmed against the 4.0.7 headers: (klass, size_t size, type)).
+    // The 2010-era binding dropped the size argument and silently worked
+    // through register reuse on x86-64 (finding #21) — T.sizeof is now
+    // passed correctly.
+
+    mixin(
+        "extern (C) VALUE " ~ name ~ "_proto_alloc(VALUE klass)" ~
+        "{" ~
+        "    return cast(VALUE) rb_data_typed_object_zalloc(klass, T.sizeof, &" ~
+                name ~ "_type);" ~
+        "}" ~
+
+        "extern (C) VALUE " ~ name ~ "_proto_icopy(VALUE self, VALUE orig)" ~
+        "{" ~
+        "    T* d = " ~ name ~ "_get(self);" ~
+        "    T* s = " ~ name ~ "_get(orig);" ~
+        "    *d = *s;" ~
+        copyCall ~
+        "    return self;" ~
+        "}" ~
+
+        "extern (C) VALUE " ~ name ~ "_proto_eq(VALUE self, VALUE other)" ~
+        "{" ~
+        eqBody ~
+        "}" ~
+
+        "extern (C) VALUE " ~ name ~ "_proto_hash(VALUE self)" ~
+        "{" ~
+        hashBody ~
+        "}" ~
+
+        inspectFn ~
+
+        "public void " ~ name ~ "_proto_install(VALUE klass)" ~
+        "{" ~
+        "    rb_define_alloc_func(klass, cast(VALUE function(VALUE)) &" ~
+                name ~ "_proto_alloc);" ~
+        "    rb_define_private_method(klass, \"initialize_copy\"," ~
+                " cast(AnyMethod) &" ~ name ~ "_proto_icopy, 1);" ~
+        "    rb_define_method(klass, \"==\", cast(AnyMethod) &" ~
+                name ~ "_proto_eq, 1);" ~
+        "    rb_define_alias(klass, \"eql?\", \"==\");" ~
+        "    rb_define_method(klass, \"hash\", cast(AnyMethod) &" ~
+                name ~ "_proto_hash, 0);" ~
+        inspectDef ~
+        "}"
+    );
+}

data/src/rudy/typeddata.d

@@ -0,0 +1,143 @@
+/// Typed-data wrapping for D structs as Ruby objects.
+///
+/// EXPERIMENT 1 (exp_wrap) discovered that `rb_data_object_get` is an inline
+/// C macro (`RDATA(obj)->data`), not an exported symbol — it cannot be called
+/// from D. The workaround used a D-side registry keyed by rb_obj_id.
+///
+/// This module replaces that workaround with the modern TypedData API, all
+/// of whose entry points ARE exported functions:
+///
+/// - `rb_data_typed_object_wrap` — wrap with a `rb_data_type_t` descriptor
+/// - `rb_check_typeddata`        — unwrap with type checking
+/// - `rb_data_typed_object_zalloc` — zero-allocated wrap (like alloc func)
+///
+/// Usage:
+///
+///     struct Matrix { ... }
+///     // 1. define the data type descriptor (one per D struct type)
+///     mixin RudyTypedData!(Matrix, "matrix");  // exposes: matrix_type
+///                                             //           matrix_wrap
+///                                             //           matrix_get
+///     // 2. wrap
+///     VALUE obj = matrix_wrap(m, klass);
+///     // 3. unwrap (raises TypeError if not a Matrix wrapper)
+///     Matrix* m = matrix_get(obj);
+///
+/// dfree is generated automatically: `GC-free-able` structs (allocated by
+/// D's GC) are freed by the GC; C-malloc'd structs are freed with free().
+/// Pass your own free callback to the mixin if you need custom cleanup.
+
+module rudy.typeddata;
+
+import rudy.bind.value;
+import rudy.convert;
+
+public:
+
+// ---------------------------------------------------------------- layout
+
+/// D mirror of ruby.h's rb_data_type_struct (layout-compatible subset).
+///
+/// Field name differences vs the C header (D keyword collisions / style):
+///   C `function` sub-struct -> `function_`   (`function` is a D keyword)
+/// D-side structs only mirror the C layout; Ruby never reads the names.
+struct RbDataFunction
+{
+    RUBY_DATA_FUNC_MARK dmark;
+    RUBY_DATA_FUNC_FREE dfree;
+    extern (C) size_t function(const void*) dsize;
+    RUBY_DATA_FUNC_MARK dcompact;
+    void*[1] reserved;                    // must be zero
+}
+
+struct RbDataType
+{
+    const(char)* wrap_struct_name;
+    RbDataFunction function_;
+    const(RbDataType)* parent;
+    void* data;
+    VALUE flags;
+}
+
+// re-export the callback aliases so users don't need value.d here
+alias RUBY_DATA_FUNC_MARK = rudy.bind.value.RUBY_DATA_FUNC_MARK;
+alias RUBY_DATA_FUNC_FREE = rudy.bind.value.RUBY_DATA_FUNC_FREE;
+
+// ---------------------------------------------------------------- default free
+
+/// Default dfree for structs allocated with D's GC: let D's GC handle it —
+/// nothing to do at Ruby-GC time (pointer stays valid for D's collector).
+extern (C) void rudy_typed_nofree(void* p) {}
+
+/// Default dfree for structs allocated with malloc/calloc: free() them.
+extern (C) void rudy_typed_free(void* p)
+{
+    import core.stdc.stdlib : free;
+    free(p);
+}
+
+// ---------------------------------------------------------------- mixin template
+
+/// Generates a typed-data descriptor + wrap/unwrap pair for struct T.
+///
+///     mixin RudyTypedData!(Matrix, "matrix");
+///     // provides: matrix_type (RbDataType),
+///     //           matrix_wrap(VALUE klass, Matrix*),
+///     //           matrix_get(VALUE obj)
+///
+/// Pass a custom free callback as the third parameter for exotic ownership
+/// models (default: malloc'd → rudy_typed_free; use &rudy_typed_nofree for
+/// D-GC-owned structs).
+///
+/// EXPERIMENT 7 (exp_compact) — finding #11: if the wrapped struct holds
+/// live VALUEs and the descriptor has no dmark, the referents are
+/// collectible while the wrapper is still alive: use-after-free (observed
+/// as a garbage String read back from a freed-and-reused slot). If the
+/// struct holds VALUEs, ALSO pass mark/compact callbacks:
+///
+///     extern (C) void mycell_mark(void* p)
+///     { rb_gc_mark_movable((cast(MyCell*) p).embedded); }
+///     extern (C) void mycell_compact(void* p)
+///     { auto c = cast(MyCell*) p; c.embedded = rb_gc_location(c.embedded); }
+///     mixin RudyTypedData!(MyCell, "mycell", &rudy_typed_free,
+///                          &mycell_mark, &mycell_compact);
+///
+/// dmark uses rb_gc_mark_movable and dcompact rewrites the slot via
+/// rb_gc_location — the movable-objects protocol required by GC.compact.
+///
+/// NB: the generated identifiers need string mixins — D template parameters
+/// do NOT become identifier names in a plain mixin template body.
+template RudyTypedData(T, string name,
+                      RUBY_DATA_FUNC_FREE freeFunc = &rudy_typed_free,
+                      RUBY_DATA_FUNC_MARK markFunc = null,
+                      RUBY_DATA_FUNC_MARK compactFunc = null)
+{
+    private enum cname = name ~ "\0";     // NUL-terminated, static storage
+
+    mixin(
+        "private extern (C) size_t " ~ name ~ "_dsize(const void* p)" ~
+        "{" ~
+        "    return T.sizeof;" ~
+        "}" ~
+
+        // The descriptor. Must outlive every wrapped object.
+        "__gshared RbDataType " ~ name ~ "_type = RbDataType(" ~
+        "    cname.ptr," ~
+        "    RbDataFunction(markFunc, freeFunc, &" ~ name ~ "_dsize, compactFunc, [null])," ~
+        "    null," ~                      // parent
+        "    null," ~                      // data
+        "    0);" ~                        // flags — zero is safest
+
+        /// Wrap a T* in a Ruby object of class `klass`.
+        "VALUE " ~ name ~ "_wrap(VALUE klass, T* ptr)" ~
+        "{" ~
+        "    return rb_data_typed_object_wrap(klass, ptr, &" ~ name ~ "_type);" ~
+        "}" ~
+
+        /// Unwrap — raises TypeError on any non-matching wrapper.
+        "T* " ~ name ~ "_get(VALUE obj)" ~
+        "{" ~
+        "    return cast(T*) rb_check_typeddata(obj, &" ~ name ~ "_type);" ~
+        "}"
+    );
+}

data/test/dextest_loader.rb

@@ -0,0 +1,6 @@
+# Loads the freshly built dextest.so with the *ruby 4.0.7* interpreter that
+# also provided libruby at link time (extension .so must match ABI).
+require "pathname"
+EXT = Pathname.new(__dir__).parent + ENV.fetch("RUDY_BUILD_DIR", ".build") + "dextest.so"
+raise "extension not built: run `make` first" unless EXT.exist?
+require EXT.to_s

data/test/exitest.rb

@@ -0,0 +1,113 @@
+#!/usr/bin/env ruby
+# Acceptance suite for the missing-API bindings (dexitest).
+# Exercises: rb_yield, rb_block_given_p, rb_yield_values2, rb_block_call,
+# rb_rescue, rb_ensure, rb_define_singleton_method, rb_scan_args,
+# rb_thread_call_without_gvl, variadic def! (D default args -> optional).
+
+require "pathname"
+EXT = Pathname.new(__dir__).parent + ".build" + "dexitest.so"
+raise "extension not built: run `make` first" unless EXT.exist?
+require EXT.to_s
+
+$failures = 0
+$count = 0
+
+def assert(cond, msg)
+  $count += 1
+  if cond then puts "ok #{$count} - #{msg}"
+  else $failures += 1; puts "FAIL #{$count} - #{msg}" end
+end
+
+def assert_equal(expected, actual, msg = nil)
+  assert(expected == actual, "#{msg || 'equal'}: expected #{expected.inspect}, got #{actual.inspect}")
+end
+
+def assert_raises(exp)
+  yield
+  assert(false, "expected #{exp} to be raised")
+rescue exp
+  assert(true, "raised #{exp}")
+rescue => e
+  assert(false, "expected #{exp}, got #{e.class}: #{e.message}")
+end
+
+# ---------------------------------------------------------------- rb_yield
+assert_equal(55, DExitTest.sum_to(10) { |i| i }, "rb_yield: sum 1..10 via block")
+assert_equal(110, DExitTest.sum_to(10) { |i| i * 2 }, "rb_yield: block sees each value")
+
+# ------------------------------------------- rb_block_given_p / yield_values2
+assert_equal(-1, DExitTest.pair_sums(5), "rb_block_given_p: no block -> -1")
+assert_equal(165, DExitTest.pair_sums(5) { |a, b| a + b },
+             "rb_yield_values2: |a, b| pairs (1,10)..(5,50) summed")
+assert_equal(3850, DExitTest.pair_sums(10) { |a, b| a * b },
+             "rb_yield_values2: products summed")
+
+# ---------------------------------------------------------------- rb_block_call
+assert_equal([1, 2, 3], DExitTest.block_collect([1, 2, 3]),
+             "rb_block_call: C-implemented block collects each entry")
+assert_equal(%w[a b c], DExitTest.block_collect(["a", "b", "c"]),
+             "rb_block_call: works on any enumerable responding to each")
+assert_equal([], DExitTest.block_collect([]), "rb_block_call: empty array")
+
+# ---------------------------------------------------------------- rb_rescue
+assert_equal("rescued", DExitTest.div_rescue(1, 0), "rb_rescue: ZeroDivisionError -> handler")
+assert_equal("rescued", DExitTest.div_rescue(1, 0) { |e| "not called" },
+             "rb_rescue: handler result returned, block irrelevant")
+assert_equal(42, DExitTest.safe_rescue, "rb_rescue: success path returns b_proc value")
+
+# ---------------------------------------------------------------- rb_ensure
+assert_equal(true, DExitTest.ensure_success, "rb_ensure: ensure ran after success")
+assert_raises(RuntimeError) { DExitTest.ensure_raises }
+assert(DExitTest.ensure_raised_flag != 0 && DExitTest.ensure_raised_flag != false,
+       "rb_ensure: ensure ran despite raise (got #{DExitTest.ensure_raised_flag.inspect})")
+
+# ------------------------------------------------- rb_define_singleton_method
+obj = Object.new
+DExitTest.make_singleton(obj)
+assert_equal("hi from singleton", obj.dexitest_greet,
+             "rb_define_singleton_method: per-object method")
+assert_raises(NoMethodError) { Object.new.dexitest_greet }
+
+# ---------------------------------------------------------------- rb_scan_args
+n, a, b, rest = DExitTest.scan(1)
+assert_equal([1, 1, nil, []], [n, a, b, rest], 'rb_scan_args "11*": 1 mandatory')
+n, a, b, rest = DExitTest.scan(1, 2)
+assert_equal([2, 1, 2, []], [n, a, b, rest], 'rb_scan_args "11*": 1 mandatory + 1 optional')
+n, a, b, rest = DExitTest.scan(1, 2, 3, 4)
+assert_equal([4, 1, 2, [3, 4]], [n, a, b, rest], 'rb_scan_args "11*": splat rest')
+
+# ---------------------------------------------------------------- GVL
+r = DExitTest.nogvl
+assert(r.is_a?(Integer) && r >= 0, "rb_thread_call_without_gvl: D nap returned")
+
+# prove another Ruby thread ran while the GVL was released
+main_result = Queue.new
+t = Thread.new { main_result << DExitTest.nogvl_parallel }
+sleep 0.01
+DExitTest.tick                       # runs while the D nap holds no GVL
+t.join
+assert_equal(1, main_result.pop, "rb_thread_call_without_gvl: D nap + parallel Ruby thread OK")
+
+# ---------------------------------------------------------------- variadic def!
+assert_equal(33, DExitTest.var_sum(1), "variadic def!: a=1, defaults b=2 c=30")
+assert_equal(33, DExitTest.var_sum(1, 2), "variadic def!: a=1 b=2, default c=30")
+assert_equal(3, DExitTest.var_sum(1, 2, 0), "variadic def!: all three explicit")
+assert_raises(ArgumentError) { DExitTest.var_sum }
+assert_raises(ArgumentError) { DExitTest.var_sum(1, 2, 3, 4) }
+
+assert_equal("hello, world!", DExitTest.var_greet("world"), "variadic def!: string defaults")
+assert_equal("howdy, world?", DExitTest.var_greet("world", "howdy", "?"),
+             "variadic def!: all explicit")
+
+assert_equal(10, DExitTest.var_raw(10), "variadic def!: raw VALUE passthrough, 1 arg")
+assert_equal("abc", DExitTest.var_raw("abc"), "variadic def!: raw VALUE passthrough, string")
+assert_equal(20, DExitTest.var_raw(10, 2), "variadic def!: raw VALUE + explicit optional arg")
+
+puts
+if $failures.zero?
+  puts "PASS: all #{$count} assertions green"
+  exit 0
+else
+  puts "FAIL: #{$failures}/#{$count} assertions failed"
+  exit 1
+end