test(overload): add randomized differential coverage

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

5 files changed, 123 insertions, 0 deletions

diff --git a/tests/ii/overload-methods/case.json b/tests/ii/overload-methods/case.json
new file mode 100644
index 0000000..0967ef4
--- /dev/null
+++ b/tests/ii/overload-methods/case.json
@@ -0,0 +1 @@
+{}
diff --git a/tests/ii/overload-methods/generate.pl b/tests/ii/overload-methods/generate.pl
new file mode 100644
index 0000000..6ea50f2
--- /dev/null
+++ b/tests/ii/overload-methods/generate.pl
@@ -0,0 +1,19 @@
+use strict;
+use warnings;
+use FindBin;
+use lib "$FindBin::Bin/..";
+use Random;
+my ($seed, $count) = @ARGV;
+my $rng = Random->new($seed, "overload-methods");
+my @edges = (
+    '0 0 1 x',
+    '-1000 1000 8 boundary',
+    '1000 -1000 8 z',
+    '0 24 2 equal',
+    '0 23 2 below',
+    '0 25 2 above',
+);
+$rng->emit($count, \@edges, sub {
+    return join ' ', $rng->integer(-1000,1000), $rng->integer(-1000,1000),
+                    $rng->integer(1,8), 'x' x $rng->integer(1,24);
+});
diff --git a/tests/ii/overload-methods/notes.md b/tests/ii/overload-methods/notes.md
new file mode 100644
index 0000000..627e2f7
--- /dev/null
+++ b/tests/ii/overload-methods/notes.md
@@ -0,0 +1,7 @@
+# overload-methods
+
+OVERLOAD is a project extension. Each record exercises NEW with zero arguments, INTEGER, STRING and two INTEGER arguments; overloaded getters with different result types; overloaded setters; nested this.Get/this.Set calls; explicit constructor calls; keyword NEW and DELETE; and parameterless construction of record fields and array elements.
+
+Inputs are A, B, Size and a nonempty ASCII string. The independent C++ oracle models resulting values directly: default construction yields 5, INTEGER construction yields 2*A+3, STRING construction yields length+20, and two-argument construction yields A-B. Default array values sum to 5*Size. Get(INTEGER) adds 3*B; Get(REAL) compares the stored value with B/8; Get(STRING) appends an exclamation mark. Set(STRING) stores length. Set(A) followed by Apply(B) yields A+3*B. Explicit NEW(STRING) rebuilds the receiver's value as length+20.
+
+Each record emits one colon-separated line. A and B stay within [-1000,1000], Size within [1,8], and string length within [1,24] for random records. All arithmetic is safely bounded; REAL comparisons use exactly representable binary fractions. Fixed records include equal, immediately smaller and immediately larger comparison thresholds, zero and range endpoints. The SHA-256 generator adds the requested random count.
diff --git a/tests/ii/overload-methods/program.cps b/tests/ii/overload-methods/program.cps
new file mode 100644
index 0000000..5594cf0
--- /dev/null
+++ b/tests/ii/overload-methods/program.cps
@@ -0,0 +1,75 @@
+CLASS Meter
+    PRIVATE Value : INTEGER
+    PUBLIC OVERLOAD PROCEDURE NEW()
+        Value <- 5
+    ENDPROCEDURE
+    PUBLIC OVERLOAD PROCEDURE NEW(X : INTEGER)
+        Value <- 2 * X + 3
+    ENDPROCEDURE
+    PUBLIC OVERLOAD PROCEDURE NEW(Text : STRING)
+        Value <- LENGTH(Text) + 20
+    ENDPROCEDURE
+    PUBLIC OVERLOAD PROCEDURE NEW(X : INTEGER, Y : INTEGER)
+        Value <- X - Y
+    ENDPROCEDURE
+    PUBLIC OVERLOAD FUNCTION Get() RETURNS INTEGER
+        RETURN Value
+    ENDFUNCTION
+    PUBLIC OVERLOAD FUNCTION Get(X : INTEGER) RETURNS INTEGER
+        RETURN Value + 3 * X
+    ENDFUNCTION
+    PUBLIC OVERLOAD FUNCTION Get(X : REAL) RETURNS BOOLEAN
+        RETURN Value > X
+    ENDFUNCTION
+    PUBLIC OVERLOAD FUNCTION Get(Text : STRING) RETURNS STRING
+        RETURN Text & "!"
+    ENDFUNCTION
+    PUBLIC OVERLOAD PROCEDURE Set(X : INTEGER)
+        Value <- X
+    ENDPROCEDURE
+    PUBLIC OVERLOAD PROCEDURE Set(Text : STRING)
+        Value <- LENGTH(Text)
+    ENDPROCEDURE
+    PUBLIC PROCEDURE Apply(X : INTEGER)
+        CALL this.Set(this.Get(X))
+    ENDPROCEDURE
+ENDCLASS
+TYPE Holder
+    DECLARE Item : Meter
+ENDTYPE
+DECLARE Count : INTEGER
+DECLARE Row : INTEGER
+DECLARE A : INTEGER
+DECLARE B : INTEGER
+DECLARE Size : INTEGER
+DECLARE Text : STRING
+DECLARE I : INTEGER
+DECLARE Total : INTEGER
+INPUT Count
+FOR Row <- 1 TO Count
+    INPUT A
+    INPUT B
+    INPUT Size
+    INPUT Text
+    DECLARE DefaultItem : Meter
+    DECLARE NumberItem : Meter(A)
+    DECLARE TextItem : Meter(Text)
+    DECLARE PairItem : Meter(A, B)
+    DECLARE Wrapped : Holder
+    DECLARE Items : ARRAY[1:Size] OF Meter
+    DECLARE ChangedNumber : Meter(A)
+    DECLARE ChangedText : Meter(Text)
+    DECLARE Rebuilt : Meter(A, B)
+    DECLARE HeapItem : Meter
+    Total <- 0
+    FOR I <- 1 TO Size
+        Total <- Total + Items[I].Get()
+    NEXT I
+    HeapItem <- NEW Meter(A, B)
+    CALL ChangedNumber.Set(Text)
+    CALL ChangedText.Set(A)
+    CALL ChangedText.Apply(B)
+    CALL Rebuilt.NEW(Text)
+    OUTPUT DefaultItem.Get(), ":", NumberItem.Get(), ":", TextItem.Get(), ":", PairItem.Get(), ":", Wrapped.Item.Get(), ":", Total, ":", NumberItem.Get(B), ":", NumberItem.Get(B / 8), ":", NumberItem.Get(Text), ":", HeapItem.Get(), ":", ChangedNumber.Get(), ":", ChangedText.Get(), ":", Rebuilt.Get()
+    DELETE HeapItem
+NEXT Row
diff --git a/tests/ii/overload-methods/reference.cc b/tests/ii/overload-methods/reference.cc
new file mode 100644
index 0000000..1ef1829
--- /dev/null
+++ b/tests/ii/overload-methods/reference.cc
@@ -0,0 +1,21 @@
+#include <cstdint>
+#include <iostream>
+#include <string>
+
+int main() {
+    int count;
+    if (!(std::cin >> count)) return 1;
+    for (int row = 0; row < count; ++row) {
+        std::int64_t a, b, size;
+        std::string text;
+        if (!(std::cin >> a >> b >> size >> text)) return 1;
+        // Model the resulting values directly, without reproducing class dispatch.
+        const auto number = 2 * a + 3;
+        const auto length = text.size();
+        std::cout << 5 << ':' << number << ':' << length + 20 << ':' << a - b
+                  << ':' << 5 << ':' << 5 * size << ':' << number + 3 * b << ':'
+                  << (number > b / 8.0 ? "TRUE" : "FALSE") << ':' << text << "!:"
+                  << a - b << ':';
+        std::cout << length << ':' << a + 3 * b << ':' << length + 20 << '\n';
+    }
+}