diff --git a/whalesong/repl-prototype/htdocs/tests-base.js b/whalesong/repl-prototype/htdocs/tests-base.js
new file mode 100644
index 0000000..30fe3e2
--- /dev/null
+++ b/whalesong/repl-prototype/htdocs/tests-base.js
@@ -0,0 +1,4275 @@
+jQuery(document).ready(function() {
+ "use strict";
+
+ var repl; // Will be initialized at the bottom
+ // of this file.
+ var outputSpan = $("");
+ var report = $("#report");
+
+ var testsRunCount = 0;
+ var failureCount = 0;
+
+ var noteRedFailure = function(e) {
+ failureCount++;
+ $("#failure-index").css("display", "inline");
+ $("#failure-index").append($("").attr("href", "#fail" + failureCount)
+ .text("" + failureCount)).append(' ');
+ var failMsgText = " FAIL" + ((e.message || e || '') ?
+ ": " + (e.message || e || '') : "");
+ report.append($("").text(failMsgText)
+ .css("color", "red")
+ .css("white-space", "pre")
+ .append($("").attr("name", "fail" + failureCount)));
+ report.css("background-color", "#eeaaaa");
+ };
+
+
+ var runTests = function(after) {
+ runAsyncTests(0, after);
+ };
+
+ var asyncTests = [];
+ var queueAsyncTest = function(name, f) {
+ asyncTests.push({name: name, f: f});
+ };
+
+ var runAsyncTests = function(i, k) {
+ if (i < asyncTests.length) {
+ runAsyncTest(asyncTests[i].name,
+ asyncTests[i].f,
+ function() {
+ setTimeout(function() {
+ runAsyncTests(i+1, k);
+ }, 10);
+ });
+ } else {
+ k();
+ }
+ };
+
+ var runAsyncTest = function(name, f, k) {
+ report.append("running " + name + "... ");
+ var success = function() {
+ report.append(" ok").append($("
"));
+ testsRunCount++;
+ k();
+ };
+ var fail = function(e) {
+ noteRedFailure(e);
+ testsRunCount++;
+ report.append($("
"));
+ k();
+ };
+ try {
+ f(success, fail);
+ } catch(e) {
+ fail(e);
+ }
+ };
+
+
+ var queueTest = function(name, code, expectedText) {
+ queueAsyncTest(name, function(success, fail) {
+ var checkOutput = function(err) {
+ var observedText = outputSpan.text().replace(/\n$/, "");
+ if (observedText === expectedText) {
+ success();
+ } else {
+ fail("not the same: " + observedText +
+ ", " +
+ expectedText);
+ }
+ };
+ // Reinitialize outputSpan.
+ outputSpan = jQuery("");
+ repl.reset(function() {
+ repl.compileAndExecuteProgram(name, code, checkOutput,
+ checkOutput);
+ });
+ });
+ };
+
+ var queueErrorTest = function(name, code, expectedErrorText) {
+ queueAsyncTest(name, function(success, fail) {
+ var checkOutput = function(err) {
+ var errText = ((err && err.message) || err) + '';
+ if (errText === expectedErrorText) {
+ success();
+ } else {
+ fail("not the same: " + errText +
+ ", " + expectedErrorText);
+ }
+ };
+ repl.reset(function() {
+ repl.compileAndExecuteProgram(name, code, checkOutput, checkOutput);
+ });
+ });
+ };
+
+
+
+ //////////////////////////////////////////////////////////////////////
+
+
+ queueTest("local",
+ "(local [(define x 42)] x)",
+ "42");
+ queueTest("local",
+ "(local [(define x 42) (define y 3)] (+ x y))",
+ "45");
+ queueTest("local",
+ "(local [] 1)",
+ "1");
+
+ queueTest("test simple function application program",
+ "(define (double x) (+ x x)) (double 25)",
+ "50");
+
+ queueTest("test simple function application program 2",
+ "(define (double x) (+ x x)) (double (double 25))",
+ "100");
+
+ queueTest("simple structures 1",
+ "(define-struct foo (x y)) (foo-x (make-foo 3 4))",
+ "3");
+
+ queueTest("simple structures 2",
+ "(define-struct foo (x y)) (foo-y (make-foo 3 4))",
+ "4");
+
+ queueTest("simple structures predicate 1",
+ "(define-struct foo (x y)) (foo? (make-foo 3 4))",
+ "true");
+
+ queueTest("simple structures predicate 2",
+ "(define-struct foo (x y)) (foo? 'foo)",
+ "false");
+
+ queueTest("division",
+ "(/ 18 2)",
+ "9");
+
+
+ queueTest("symbol string",
+ "(symbol->string 'hello)",
+ "\"hello\"");
+
+ queueTest("string->symbol",
+ "(string->symbol \"hello\")",
+ "'hello");
+
+ // queueTest("formatting lists",
+ // "(format \"~a\" '(1 2))",
+ // "\"(list 1 2)\"");
+
+
+ queueTest("symbols that should not leak js implementation",
+ "'constructor",
+ "'constructor");
+
+ queueTest("symbols that should not leak js implementation 2",
+ "'hasOwnProperty",
+ "'hasOwnProperty");
+
+ queueTest("symbols that should not leak js implementation 3",
+ "'__proto__",
+ "'__proto__");
+
+
+ queueTest("simple set!",
+ "(define x 42) (set! x 16) x",
+ "16")
+
+
+ queueErrorTest("test mis-application 1",
+ "(define (double x) (+ x x)) (double double)",
+ "+: expects a number as 1st argument, but given: #; other arguments were: #");
+
+ queueErrorTest("test mis-application 2",
+ "(define (double x) (+ x x)) (double double 25)",
+ "double: expects 1 argument, but given 2: # 25");
+
+ queueErrorTest("test a error in map",
+ '(map add1 (list "1"))',
+ 'add1: expects a number as 1st argument, but given: "1"');
+
+
+ queueErrorTest("test non-boolean in if test position",
+ "(if 3 'four 'five)",
+ 'if: expected a boolean value, but found: 3');
+
+ queueErrorTest("test if not enough args",
+ "(if)",
+ "if: expected a test, a consequence, and an alternative, but all three were not found");
+
+ queueErrorTest("test if not enough args",
+ "(if true)",
+ "if: expected a test, a consequence, and an alternative, but all three were not found");
+
+ queueErrorTest("test if not enough args",
+ "(if true false)",
+ "if: expected a test, a consequence, and an alternative, but all three were not found");
+
+ queueErrorTest("test if too many args",
+ "(if true false true false)",
+ "if: expected only a test, a consequence, and an alternative, but found more than three of these");
+
+
+ queueErrorTest("test non-boolean in 'or'",
+ "(or 42 4)",
+ 'or: expected a boolean value, but found: 42');
+
+ queueErrorTest("test non-boolean in 'or', second position",
+ "(or #f 4)",
+ 'or: expected a boolean value, but found: 4');
+
+ queueErrorTest("test and empty",
+ "(and)",
+ "and: expected at least 2 arguments, but given 0");
+
+ queueErrorTest("test and empty",
+ "(and 1)",
+ "and: expected at least 2 arguments, but given 1");
+
+ queueErrorTest("test and empty",
+ "(and 'foo)",
+ "and: expected at least 2 arguments, but given 1");
+
+ queueErrorTest("test or empty",
+ "(or)",
+ "or: expected at least 2 arguments, but given 0");
+
+ queueErrorTest("test or only one arg",
+ "(or 1)",
+ "or: expected at least 2 arguments, but given 1");
+
+ queueErrorTest("test and empty",
+ "(or 'noo)",
+ "or: expected at least 2 arguments, but given 1");
+
+ queueErrorTest("test non-boolean in 'and'",
+ "(and 'blah 4)",
+ "and: expected a boolean value, but found: blah");
+
+ queueErrorTest("test non-boolean in 'and', second position",
+ "(and #t 'not-bool)",
+ "and: expected a boolean value, but found: not-bool");
+
+ queueErrorTest("beside given 1 arg",
+ "(beside 5)",
+ "beside: expects at least 2 arguments, but given 1: 5");
+
+ queueErrorTest("beside given 3 non-image args",
+ "(beside 2 3 3)",
+ "beside: expects an image as 1st argument, but given: 2; other arguments were: 3 3");
+
+ queueErrorTest("beside given bad args, correct number",
+ "(beside 1 1)",
+ "beside: expects an image as 1st argument, but given: 1; other arguments were: 1");
+
+ queueErrorTest("beside given 0 args",
+ "(beside)",
+ "beside: expects at least 2 arguments, but given 0");
+
+ queueErrorTest("beside/align give too few args",
+ "(beside/align 3 3)",
+ "beside/align: expects at least 3 arguments, but given 2: 3 3");
+ queueErrorTest("beside/align given bad args",
+ "(beside/align 3 3 3 3 3 3)",
+ "beside/align: expects a y-place as 1st argument, but given: 3; other arguments were: 3 3 3 3 3");
+
+ queueErrorTest("beside/align given bad args, correct number",
+ "(beside/align 1 1 1)",
+ "beside/align: expects a y-place as 1st argument, but given: 1; other arguments were: 1 1");
+
+ queueErrorTest("above given 0 args",
+ "(above)",
+ "above: expects at least 2 arguments, but given 0");
+
+ queueErrorTest("above given bad args",
+ "(above 2 1 1)",
+ "above: expects an image as 1st argument, but given: 2; other arguments were: 1 1");
+
+ queueErrorTest("above given bad args, correct number",
+ "(above 1 1)",
+ "above: expects an image as 1st argument, but given: 1; other arguments were: 1");
+
+ queueErrorTest("above/align given no args",
+ "(above/align)",
+ "above/align: expects at least 3 arguments, but given 0");
+
+ queueErrorTest("above/align given bad args, correct number",
+ "(above/align 1 1 1)",
+ "above/align: expects a x-place as 1st argument, but given: 1; other arguments were: 1 1");
+
+ queueErrorTest("above/align given too many args, all bad",
+ "(above/align 1 1 1 1 1)",
+ "above/align: expects a x-place as 1st argument, but given: 1; other arguments were: 1 1 1 1");
+
+ queueErrorTest("rotate given no args",
+ "(rotate)",
+ "rotate: expects 2 arguments, but given 0");
+
+ queueErrorTest("rotate given correct number of bad args",
+ "(rotate 1 1)",
+ "rotate: expects an image as 2nd argument, but given: 1; other arguments were: 1");
+
+ queueErrorTest("rotate given too many args",
+ "(rotate 1 1 1 1 1 1)",
+ "rotate: expects 2 arguments, but given 6: 1 1 1 1 1 1");
+
+ queueErrorTest("crop given no args",
+ "(crop)",
+ "crop: expects 5 arguments, but given 0");
+
+ queueErrorTest("crop given correct # args, but bad args",
+ "(crop 1 1 1 1 1)",
+ "crop: expects an image as 5th argument, but given: 1; other arguments were: 1 1 1 1");
+
+ queueErrorTest("frame given no args",
+ "(frame)",
+ "frame: expects 1 argument, but given 0");
+
+ queueErrorTest("frame given correct number args, but bad args",
+ "(frame 1)",
+ "frame: expects an image as 1st argument, but given: 1");
+
+ queueErrorTest("frame given too many args",
+ "(frame 1 1)",
+ "frame: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("flip-vertical given no args",
+ "(flip-vertical)",
+ "flip-vertical: expects 1 argument, but given 0");
+
+ queueErrorTest("flip-vertical given correct amount of args, but bad args",
+ "(flip-vertical 1)",
+ "flip-vertical: expects an image as 1st argument, but given: 1");
+
+ queueErrorTest("flip-vertical given too many args",
+ "(flip-vertical 1 1)",
+ "flip-vertical: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("flip-horizontal given no args",
+ "(flip-horizontal)",
+ "flip-horizontal: expects 1 argument, but given 0");
+
+ queueErrorTest("flip-horizontal given correct amount of args, but bad args",
+ "(flip-horizontal 1)",
+ "flip-horizontal: expects an image as 1st argument, but given: 1");
+
+ queueErrorTest("flip-horizontal given too many args",
+ "(flip-horizontal 1 1)",
+ "flip-horizontal: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("text given no args",
+ "(text)",
+ "text: expects 3 arguments, but given 0");
+
+ queueErrorTest("text given correct # args, but bad args",
+ "(text 1 1 1)",
+ "text: expects a string as 1st argument, but given: 1; other arguments were: 1 1");
+
+ queueErrorTest("text given too many args",
+ "(text 1 1 1 1)",
+ "text: expects 3 arguments, but given 4: 1 1 1 1");
+
+ queueErrorTest("text/font given bad number of args",
+ "(text/font 1)",
+ "text/font: expects 8 arguments, but given 1: 1");
+
+ queueErrorTest("text/font given bad but correct amount of args",
+ "(text/font 1 1 1 1 1 1 1 1)",
+ "text/font: expects a string as 1st argument, but given: 1; other arguments were: 1 1 1 1 1 1 1");
+
+ queueErrorTest("bitmap/url given bad amount of args",
+ "(bitmap/url)",
+ "image-url: expects 1 argument, but given 0");
+
+ queueErrorTest("bitmap/url given correct amount of args, but bad as",
+ "(bitmap/url 1)",
+ "image-url: expects a string as 1st argument, but given: 1");
+
+ queueErrorTest("video-url given bad amount of args",
+ "(video-url)",
+ "video-url: expects 1 argument, but given 0");
+
+ queueErrorTest("video-url given correct arg amount, but bad as",
+ "(video-url 1)",
+ "video-url: expects a string as 1st argument, but given: 1");
+
+ queueErrorTest("image-width given no args",
+ "(image-width)",
+ "image-width: expects 1 argument, but given 0");
+
+ queueErrorTest("image-width given correct arg amount, but bad as",
+ "(image-width 1)",
+ "image-width: expects an image as 1st argument, but given: 1");
+
+ queueErrorTest("image-height given no args",
+ "(image-height)",
+ "image-height: expects 1 argument, but given 0");
+
+ queueErrorTest("image-height given correct arg amount, but bad as",
+ "(image-height 1)",
+ "image-height: expects an image as 1st argument, but given: 1");
+
+ queueErrorTest("image-baseline given no args",
+ "(image-baseline)",
+ "image-baseline: expects 1 argument, but given 0");
+
+ queueErrorTest("image-baseline given correct arg amount, but bad as",
+ "(image-baseline 1)",
+ "image-baseline: expects an image as 1st argument, but given: 1");
+
+ queueErrorTest("color-list->image bad arg amount",
+ "(color-list->image)",
+ "color-list->image: expects 5 arguments, but given 0");
+
+ queueErrorTest("color-list->bitmap bad arg a",
+ "(color-list->bitmap 1 1 1 1 1)",
+ "color-list->bitmap: expects 3 arguments, but given 5: 1 1 1 1 1");
+
+ queueErrorTest("color-list->bitmap bad arg amount",
+ "(color-list->bitmap)",
+ "color-list->bitmap: expects 3 arguments, but given 0");
+
+ queueErrorTest("color-list->image bad arg a",
+ "(color-list->image 1 1 1 1 1)",
+ "color-list->image: expects a list of image as 1st argument, but given: 1");
+
+ queueErrorTest("mode? no args",
+ "(mode?)",
+ "mode?: expects 1 argument, but given 0");
+
+ queueErrorTest("mode? too many args",
+ "(mode? 1 1)",
+ "mode?: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("image-color? no args",
+ "(image-color?)",
+ "image-color?: expects 1 argument, but given 0");
+
+ queueErrorTest("image-color? too many args",
+ "(image-color? 1 1)",
+ "image-color?: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("name->color no args",
+ "(name->color)",
+ "name->color: expects 1 argument, but given 0");
+
+ queueErrorTest("name->color too many args",
+ "(name->color 1 1)",
+ "name->color: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("x-place? no args",
+ "(x-place?)",
+ "x-place?: expects 1 argument, but given 0");
+
+ queueErrorTest("x-place? too many args",
+ "(x-place? 1 1)",
+ "x-place?: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("y-place? no args",
+ "(y-place?)",
+ "y-place?: expects 1 argument, but given 0");
+
+ queueErrorTest("y-place? too many args",
+ "(y-place? 1 1)",
+ "y-place?: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("angle? no args",
+ "(angle?)",
+ "angle?: expects 1 argument, but given 0");
+
+ queueErrorTest("angle? too many args",
+ "(angle? 1 1)",
+ "angle?: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("side-count? no args",
+ "(side-count?)",
+ "side-count?: expects 1 argument, but given 0");
+
+ queueErrorTest("side-count? too many args",
+ "(side-count? 1 1)",
+ "side-count?: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("step-count? no args",
+ "(step-count?)",
+ "step-count?: expects 1 argument, but given 0");
+
+ queueErrorTest("step-count? too many args",
+ "(step-count? 1 1)",
+ "step-count?: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("on-tick bad args amount",
+ "(on-tick)",
+ "on-tick: expects 1 or 2 arguments, but given 0");
+
+ queueErrorTest("on-tick 1 arg",
+ "(on-tick 1)",
+ "on-tick: expects a function name as 1st argument, but given: 1");
+
+ queueErrorTest("on-tick 2 args",
+ "(on-tick 1 2)",
+ "on-tick: expects a function name as 1st argument, but given: 1; other arguments were: 2");
+
+
+ queueErrorTest("on-tap bad arg amount",
+ "(on-tap)",
+ "on-tap: expects 1 argument, but given 0");
+
+ queueErrorTest("on-tap bad arg a",
+ "(on-tap 1)",
+ "on-tap: expects a function name as 1st argument, but given: 1");
+
+ queueErrorTest("on-tilt bad arg amount",
+ "(on-tilt)",
+ "on-tilt: expects 1 argument, but given 0");
+
+ queueErrorTest("on-tilt bad arg a",
+ "(on-tilt 1)",
+ "on-tilt: expects a function name as 1st argument, but given: 1");
+
+ queueErrorTest("on-key bad arg amount",
+ "(on-key)",
+ "on-key: expects 1 argument, but given 0");
+
+ queueErrorTest("on-key bad arg a",
+ "(on-key 1)",
+ "on-key: expects a function name as 1st argument, but given: 1");
+
+
+ queueErrorTest("stop-when bad arg amount",
+ "(stop-when)",
+ "stop-when: expects 1 argument, but given 0");
+
+ queueErrorTest("stop-when bad arg a",
+ "(stop-when 1)",
+ "stop-when: expects a function name as 1st argument, but given: 1");
+ /*
+ queueErrorTest("stop-when! bad arg amount",
+ "(stop-when!)",
+ "stop-when!: expects 2 arguments, but given 0");
+
+ queueErrorTest("stop-when! bad arg a",
+ "(stop-when! 1 1)",
+ "stop-when!: expects a function name as 1st argument, but given: 1; other arguments were: 1");
+ */
+ queueErrorTest("on-redraw bad arg amount",
+ "(on-redraw)",
+ "on-redraw: expects 1 argument, but given 0");
+
+ queueErrorTest("on-redraw bad arg a",
+ "(on-redraw 1)",
+ "on-redraw: expects a function name as 1st argument, but given: 1");
+
+
+
+ queueErrorTest("on-draw bad arg amount",
+ "(on-draw)",
+ "on-draw: expects 1 or 2 arguments, but given 0");
+
+ queueErrorTest("on-draw bad arg a",
+ "(on-draw 1)",
+ "on-draw: expects a function name as 1st argument, but given: 1");
+
+ queueErrorTest("on-draw bad arg as",
+ "(on-draw 1 2)",
+ "on-draw: expects a function name as 1st argument, but given: 1; other arguments were: 2");
+
+ queueErrorTest("initial-effect bad arg amount (no args)",
+ "(initial-effect)",
+ "initial-effect: expects 1 argument, but given 0");
+
+ queueErrorTest("initial-effect too many args",
+ "(initial-effect 1 2)",
+ "initial-effect: expects 1 argument, but given 2: 1 2");
+
+ queueErrorTest("big-bang given no arguments",
+ "(big-bang)",
+ "big-bang: expects at least 1 argument, but given 0");
+
+ queueErrorTest("big-bang given wrong type of arg as 2nd arg",
+ "(big-bang 1 1)",
+ "big-bang: expects a handler as 2nd argument, but given: 1; other arguments were: 1");
+
+ queueErrorTest("make-struct-type wrong number of args",
+ "(make-struct-type)",
+ "make-struct-type: expects 4 or 5 or 6 or 7 or 8 or 9 or 10 arguments, but given 0");
+
+ queueErrorTest("make-struct-type give wrong arg type",
+ "(make-struct-type 1 1 1 1)",
+ "make-struct-type: expects a symbol as 1st argument, but given: 1; other arguments were: 1 1 1");
+
+ queueErrorTest("make-struct-field-accessor wrong number of args",
+ "(make-struct-field-accessor)",
+ "make-struct-field-accessor: expects 2 or 3 arguments, but given 0");
+
+ queueErrorTest("make-struct-field-accessor given wrong arg type",
+ "(make-struct-field-accessor 1 1 1)",
+ "make-struct-field-accessor: expects an accessor procedure that requires a field index as 1st argument, but given: 1; other arguments were: 1 1");
+
+ queueErrorTest("make-struct-field-accessor given 2 wrong args",
+ "(make-struct-field-accessor 1 1)",
+ "make-struct-field-accessor: expects an accessor procedure that requires a field index as 1st argument, but given: 1; other arguments were: 1");
+
+ queueErrorTest("make-struct-field-mutator given 2 args, bad a",
+ "(make-struct-field-mutator 1 1)",
+ "make-struct-field-mutator: expects a mutator procedure that requires a field index as 1st argument, but given: 1; other arguments were: 1");
+
+ queueErrorTest("make-struct-field-mutator given no args",
+ "(make-struct-field-mutator)",
+ "make-struct-field-mutator: expects 2 or 3 arguments, but given 0");
+
+ queueErrorTest("make-struct-field-mutator given 3 args, bad a",
+ "(make-struct-field-mutator 1 1 1)",
+ "make-struct-field-mutator: expects a mutator procedure that requires a field index as 1st argument, but given: 1; other arguments were: 1 1");
+
+ queueErrorTest("procedure-arity given no args",
+ "(procedure-arity)",
+ "procedure-arity: expects 1 argument, but given 0");
+
+ queueErrorTest("procedure-arity given bad arg a",
+ "(procedure-arity 1)",
+ "procedure-arity: expects a function name as 1st argument, but given: 1");
+
+ queueErrorTest("procedure-arity given way too many args",
+ "(procedure-arity 1 1 1 1 1 1 1 1 1 1)",
+ "procedure-arity: expects 1 argument, but given 10: 1 1 1 1 1 1 1 1 1 1");
+
+ queueErrorTest("apply given no args",
+ "(apply)",
+ "apply: expects at least 2 arguments, but given 0");
+
+ queueErrorTest("apply given bad arg as",
+ "(apply 1 1)",
+ "apply: expects a function name as 1st argument, but given: 1; other arguments were: 1");
+
+ queueErrorTest("apply given bad arg a for second arg",
+ "(apply add1 1)",
+ "apply: expects a list as 2nd argument, but given: 1; other arguments were: #");
+
+ queueErrorTest("compose given bad arg a",
+ "(compose 1)",
+ "compose: expects a function name as 1st argument, but given: 1");
+
+ queueErrorTest("compose given bad 2nd arg a",
+ "(compose add1 1)",
+ "compose: expects a function name as 2nd argument, but given: 1; other arguments were: #");
+
+ queueErrorTest("current-inexact-milliseconds given too many args",
+ "(current-inexact-milliseconds 1)",
+ "current-inexact-milliseconds: expects 0 arguments, but given 1: 1");
+
+ queueErrorTest("current-seconds given too many args",
+ "(current-seconds 1)",
+ "current-seconds: expects 0 arguments, but given 1: 1");
+
+ queueErrorTest("not given no args",
+ "(not)",
+ "not: expects 1 argument, but given 0");
+
+ queueErrorTest("not given too many args",
+ "(not 1 1)",
+ "not: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("random given too many args",
+ "(random 1 1)",
+ "random: expects 0 or 1 arguments, but given 2: 1 1");
+
+ queueErrorTest("random given bad arg a",
+ "(random add1)",
+ "random: expects a non-negative exact integer as 1st argument, but given: #");
+
+ queueErrorTest("sleep given bad arg a",
+ "(sleep add1)",
+ "sleep: expects a non-negative real number as 1st argument, but given: #");
+
+ queueErrorTest("sleep given too many args",
+ "(sleep 1 2)",
+ "sleep: expects 0 or 1 arguments, but given 2: 1 2");
+
+ queueErrorTest("identity given no args",
+ "(identity)",
+ "identity: expects 1 argument, but given 0");
+
+ queueErrorTest("identity given too many args",
+ "(identity 2 2)",
+ "identity: expects 1 argument, but given 2: 2 2");
+
+ queueErrorTest("raise given no args",
+ "(raise)",
+ "raise: expects 1 argument, but given 0");
+
+ queueErrorTest("raise given too many args",
+ "(raise 1 1)",
+ "raise: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("error given no args",
+ "(error)",
+ "error: expects at least 1 argument, but given 0");
+
+ queueErrorTest("error given bad a",
+ "(error 1)",
+ "error: expects a symbol or string as 1st argument, but given: 1");
+
+ queueErrorTest("make-exn given no args",
+ "(make-exn)",
+ "make-exn: expects 2 arguments, but given 0");
+
+ queueErrorTest("make-exn given bad arg as",
+ "(make-exn 1 1)",
+ "exn: expects argument of type continuation mark set, but given: 1");
+
+ queueErrorTest("* given bad arg",
+ "(* add1)",
+ "*: expects a number as 1st argument, but given: #");
+
+ queueErrorTest("/ given insufficient number of arguments",
+ "(/ 1)",
+ "/: expects at least 2 arguments, but given 1: 1");
+
+ queueErrorTest("/ given bad arg 1st position",
+ "(/ add1 1)",
+ "/: expects a number as 1st argument, but given: #; other arguments were: 1");
+
+ queueErrorTest("/ given bad arg 2nd position",
+ "(/ 1 add1)",
+ "/: expects a number as 2nd argument, but given: #; other arguments were: 1");
+
+ queueErrorTest("/ given bad arg 3rd position",
+ "(/ 1 2 add1)",
+ "/: expects a number as 3rd argument, but given: #; other arguments were: 1 2");
+
+ queueErrorTest("- given bad arg",
+ "(- add1)",
+ "-: expects a number as 1st argument, but given: #");
+
+ queueErrorTest("+ given bad arg",
+ "(+ add1)",
+ "+: expects a number as 1st argument, but given: #");
+
+ queueErrorTest("/ given no arguments",
+ "(/)",
+ "/: expects at least 2 arguments, but given 0");
+
+ queueErrorTest("/ given only one argument",
+ "(/ 5)",
+ "/: expects at least 2 arguments, but given 1: 5");
+
+ queueErrorTest("- given no args",
+ "(-)",
+ "-: expects at least 1 argument, but given 0");
+
+ queueErrorTest("= given no args",
+ "(=)",
+ "=: expects at least 2 arguments, but given 0");
+
+ queueErrorTest("= given bad 2nd arg",
+ "(= 1 sub1)",
+ "=: expects a number as 2nd argument, but given: #; other arguments were: 1");
+
+ queueErrorTest("= given bad first arg",
+ "(= sub1 1)",
+ "=: expects a number as 1st argument, but given: #; other arguments were: 1");
+
+ queueErrorTest("=~ given no args",
+ "(=~)",
+ "=~: expects 3 arguments, but given 0");
+
+ queueErrorTest("=~ given bad as",
+ "(=~ add1 sub1 add1)",
+ "=~: expects a real as 1st argument, but given: #; other arguments were: # #");
+
+ queueErrorTest("sub1 given no args",
+ "(sub1)",
+ "sub1: expects 1 argument, but given 0");
+
+ queueErrorTest("sub1 given a bad arg",
+ "(sub1 add1)",
+ "sub1: expects a number as 1st argument, but given: #");
+
+ queueErrorTest("sub1 given too many args",
+ "(sub1 1 1 1)",
+ "sub1: expects 1 argument, but given 3: 1 1 1");
+
+ queueErrorTest("add1 given too many args",
+ "(add1 1 1 1)",
+ "add1: expects 1 argument, but given 3: 1 1 1");
+
+ queueErrorTest("add1 given no args",
+ "(add1)",
+ "add1: expects 1 argument, but given 0");
+
+ queueErrorTest("add1 given a bad arg",
+ "(add1 add1)",
+ "add1: expects a number as 1st argument, but given: #");
+
+
+ queueErrorTest("< given no args",
+ "(<)",
+ "<: expects at least 2 arguments, but given 0");
+
+ queueErrorTest("< given 1 bad arg",
+ "(< add1 1)",
+ "<: expects a number as 1st argument, but given: #; other arguments were: 1");
+
+ queueErrorTest("< given 1 bad arg (2nd arg)",
+ "(< 1 add1)",
+ "<: expects a number as 2nd argument, but given: #; other arguments were: 1");
+
+ queueErrorTest("< given too few args",
+ "(< 1)",
+ "<: expects at least 2 arguments, but given 1: 1");
+
+ queueErrorTest("> given no args",
+ "(>)",
+ ">: expects at least 2 arguments, but given 0");
+
+ queueErrorTest("> given 1 bad arg",
+ "(> add1 1)",
+ ">: expects a number as 1st argument, but given: #; other arguments were: 1");
+
+ queueErrorTest("> given 1 bad arg (2nd arg)",
+ "(> 1 add1)",
+ ">: expects a number as 2nd argument, but given: #; other arguments were: 1");
+
+ queueErrorTest("> given too few args",
+ "(> 1)",
+ ">: expects at least 2 arguments, but given 1: 1");
+
+
+ queueErrorTest("<= given no args",
+ "(<=)",
+ "<=: expects at least 2 arguments, but given 0");
+
+ queueErrorTest("<= given bad arg (first arg))",
+ "(<= add1 1)",
+ "<=: expects a number as 1st argument, but given: #; other arguments were: 1");
+
+ queueErrorTest("<= given 1 bad arg (2nd arg)",
+ "(<= 1 add1)",
+ "<=: expects a number as 2nd argument, but given: #; other arguments were: 1");
+
+ queueErrorTest("<= given too few args",
+ "(<= 1)",
+ "<=: expects at least 2 arguments, but given 1: 1");
+
+ queueErrorTest(">= given no args",
+ "(>=)",
+ ">=: expects at least 2 arguments, but given 0");
+
+ queueErrorTest(">= given bad arg (first arg))",
+ "(>= add1 1)",
+ ">=: expects a number as 1st argument, but given: #; other arguments were: 1");
+
+ queueErrorTest(">= given 1 bad arg (2nd arg)",
+ "(>= 1 add1)",
+ ">=: expects a number as 2nd argument, but given: #; other arguments were: 1");
+
+ queueErrorTest(">= given too few args",
+ "(>= 1)",
+ ">=: expects at least 2 arguments, but given 1: 1");
+
+ queueErrorTest("abs given no args",
+ "(abs)",
+ "abs: expects 1 argument, but given 0");
+
+ queueErrorTest("abs given 1 bad arg",
+ "(abs add1)",
+ "abs: expects a real as 1st argument, but given: #");
+
+ queueErrorTest("abs given too many args",
+ "(abs 1 1)",
+ "abs: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("quotient given no args",
+ "(quotient)",
+ "quotient: expects 2 arguments, but given 0");
+
+ queueErrorTest("quotient given 1 bad arg (first arg))",
+ "(quotient add1 1)",
+ "quotient: expects an integer as 1st argument, but given: #; other arguments were: 1");
+
+ queueErrorTest("quotient given 1 bad arg (2nd arg)",
+ "(quotient 1 add1)",
+ "quotient: expects an integer as 2nd argument, but given: #; other arguments were: 1");
+
+ queueErrorTest("quotient given too many args",
+ "(quotient 1 1 1)",
+ "quotient: expects 2 arguments, but given 3: 1 1 1");
+
+ queueErrorTest("remainder given no args",
+ "(remainder)",
+ "remainder: expects 2 arguments, but given 0");
+
+ queueErrorTest("remainder given 1 bad arg (first arg))",
+ "(remainder add1 1)",
+ "remainder: expects an integer as 1st argument, but given: #; other arguments were: 1");
+
+ queueErrorTest("remainder given 1 bad arg (2nd arg)",
+ "(remainder 1 add1)",
+ "remainder: expects an integer as 2nd argument, but given: #; other arguments were: 1");
+
+ queueErrorTest("remainder given too many args",
+ "(remainder 1 1 1)",
+ "remainder: expects 2 arguments, but given 3: 1 1 1");
+
+ queueErrorTest("modulo given no args",
+ "(modulo)",
+ "modulo: expects 2 arguments, but given 0");
+
+ queueErrorTest("modulo given 1 bad arg (first arg))",
+ "(modulo add1 1)",
+ "modulo: expects an integer as 1st argument, but given: #; other arguments were: 1");
+
+ queueErrorTest("modulo given 1 bad arg (2nd arg)",
+ "(modulo 1 add1)",
+ "modulo: expects an integer as 2nd argument, but given: #; other arguments were: 1");
+
+ queueErrorTest("modulo given too many args",
+ "(modulo 1 1 1)",
+ "modulo: expects 2 arguments, but given 3: 1 1 1");
+
+ queueErrorTest("max given no args",
+ "(max)",
+ "max: expects at least 1 argument, but given 0");
+
+ queueErrorTest("max given 1 bad arg",
+ "(max add1)",
+ "max: expects a real as 1st argument, but given: #");
+
+ queueErrorTest("max given 1 good 1 bad arg",
+ "(max 1 add1)",
+ "max: expects a real as 2nd argument, but given: #; other arguments were: 1");
+
+ queueErrorTest("min given no args",
+ "(min)",
+ "min: expects at least 1 argument, but given 0");
+
+ queueErrorTest("min given 1 bad arg",
+ "(min add1)",
+ "min: expects a real as 1st argument, but given: #");
+
+ queueErrorTest("min given 1 good 1 bad arg",
+ "(min 1 add1)",
+ "min: expects a real as 2nd argument, but given: #; other arguments were: 1");
+
+ queueErrorTest("gcd given no args",
+ "(gcd)",
+ "gcd: expects at least 1 argument, but given 0");
+
+ queueErrorTest("gcd given 1 bad arg",
+ "(gcd add1)",
+ "gcd: expects an integer as 1st argument, but given: #");
+
+ queueErrorTest("gcd given 1 good 1 bad arg",
+ "(gcd 1 add1)",
+ "gcd: expects an integer as 2nd argument, but given: #; other arguments were: 1");
+
+ queueErrorTest("lcm given no args",
+ "(lcm)",
+ "lcm: expects at least 1 argument, but given 0");
+
+ queueErrorTest("lcm given 1 bad arg",
+ "(lcm add1)",
+ "lcm: expects an integer as 1st argument, but given: #");
+
+ queueErrorTest("lcm given 1 good 1 bad arg",
+ "(lcm 1 add1)",
+ "lcm: expects an integer as 2nd argument, but given: #; other arguments were: 1");
+
+ queueErrorTest("floor given no args",
+ "(floor)",
+ "floor: expects 1 argument, but given 0");
+
+ queueErrorTest("floor given 1 bad arg",
+ "(floor add1)",
+ "floor: expects a real as 1st argument, but given: #");
+
+ queueErrorTest("floor given too many args",
+ "(floor 1 1 1)",
+ "floor: expects 1 argument, but given 3: 1 1 1");
+
+ queueErrorTest("ceiling given no args",
+ "(ceiling)",
+ "ceiling: expects 1 argument, but given 0");
+
+ queueErrorTest("ceiling given 1 bad arg",
+ "(ceiling add1)",
+ "ceiling: expects a real as 1st argument, but given: #");
+
+ queueErrorTest("ceiling given too many args",
+ "(ceiling 1 1 1)",
+ "ceiling: expects 1 argument, but given 3: 1 1 1");
+
+ queueErrorTest("round given no args",
+ "(round)",
+ "round: expects 1 argument, but given 0");
+
+ queueErrorTest("round given 1 bad arg",
+ "(round add1)",
+ "round: expects a real as 1st argument, but given: #");
+
+ queueErrorTest("round given too many args",
+ "(round 1 1 1)",
+ "round: expects 1 argument, but given 3: 1 1 1");
+
+ queueErrorTest("numerator given no args",
+ "(numerator)",
+ "numerator: expects 1 argument, but given 0");
+
+ queueErrorTest("numerator given 1 bad arg",
+ "(numerator add1)",
+ "numerator: expects a rational number as 1st argument, but given: #");
+
+ queueErrorTest("numerator given too many args",
+ "(numerator 1 1 1)",
+ "numerator: expects 1 argument, but given 3: 1 1 1");
+
+ queueErrorTest("denominator given no args",
+ "(denominator)",
+ "denominator: expects 1 argument, but given 0");
+
+ queueErrorTest("denominator given 1 bad arg",
+ "(denominator add1)",
+ "denominator: expects a rational number as 1st argument, but given: #");
+
+ queueErrorTest("denominator given too many args",
+ "(denominator 1 1 1)",
+ "denominator: expects 1 argument, but given 3: 1 1 1");
+
+ queueErrorTest("expt given no args",
+ "(expt)",
+ "expt: expects 2 arguments, but given 0");
+
+ queueErrorTest("expt given bad first arg, valid 2nd arg",
+ "(expt add1 1)",
+ "expt: expects a number as 1st argument, but given: #; other arguments were: 1");
+
+ queueErrorTest("expt given valid 1st arg, bad 2nd arg",
+ "(expt 1 add1)",
+ "expt: expects a number as 2nd argument, but given: #; other arguments were: 1");
+
+ queueErrorTest("expt given too many args",
+ "(expt 1 1 1)",
+ "expt: expects 2 arguments, but given 3: 1 1 1");
+
+ queueErrorTest("exp given no args",
+ "(exp)",
+ "exp: expects 1 argument, but given 0");
+
+ queueErrorTest("exp given 1 bad arg",
+ "(exp add1)",
+ "exp: expects a number as 1st argument, but given: #");
+
+ queueErrorTest("exp given too many bad args",
+ "(exp 1 1)",
+ "exp: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("log given no args",
+ "(log)",
+ "log: expects 1 argument, but given 0");
+
+ queueErrorTest("log given 1 bad arg",
+ "(log add1)",
+ "log: expects a number as 1st argument, but given: #");
+
+ queueErrorTest("log given too many args",
+ "(log 1 1)",
+ "log: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("sin given no args",
+ "(sin)",
+ "sin: expects 1 argument, but given 0");
+
+ queueErrorTest("sin given 1 bad arg",
+ "(sin add1)",
+ "sin: expects a number as 1st argument, but given: #");
+
+ queueErrorTest("sin given too many args",
+ "(sin 1 1)",
+ "sin: expects 1 argument, but given 2: 1 1");
+ //next trig func
+
+ queueErrorTest("cos given no args",
+ "(cos)",
+ "cos: expects 1 argument, but given 0");
+
+ queueErrorTest("cos given 1 bad arg",
+ "(cos add1)",
+ "cos: expects a number as 1st argument, but given: #");
+
+ queueErrorTest("cos given too many args",
+ "(cos 1 1)",
+ "cos: expects 1 argument, but given 2: 1 1");
+ //next trig func
+
+ queueErrorTest("tan given no args",
+ "(tan)",
+ "tan: expects 1 argument, but given 0");
+
+ queueErrorTest("tan given 1 bad arg",
+ "(tan add1)",
+ "tan: expects a number as 1st argument, but given: #");
+
+ queueErrorTest("tan given too many args",
+ "(tan 1 1)",
+ "tan: expects 1 argument, but given 2: 1 1");
+ //next trig func
+
+ queueErrorTest("asin given no args",
+ "(asin)",
+ "asin: expects 1 argument, but given 0");
+
+ queueErrorTest("asin given 1 bad arg",
+ "(asin add1)",
+ "asin: expects a number as 1st argument, but given: #");
+
+ queueErrorTest("asin given too many args",
+ "(asin 1 1)",
+ "asin: expects 1 argument, but given 2: 1 1");
+ //next trig func
+
+ queueErrorTest("acos given no args",
+ "(acos)",
+ "acos: expects 1 argument, but given 0");
+
+ queueErrorTest("acos given 1 bad arg",
+ "(acos add1)",
+ "acos: expects a number as 1st argument, but given: #");
+
+ queueErrorTest("acos given too many args",
+ "(acos 1 1)",
+ "acos: expects 1 argument, but given 2: 1 1");
+ //next trig func
+
+ queueErrorTest("atan given no args",
+ "(atan)",
+ "atan: expects 1 argument, but given 0");
+
+ queueErrorTest("atan given 1 bad arg",
+ "(atan add1)",
+ "atan: expects a number as 1st argument, but given: #");
+
+ queueErrorTest("atan given too many args",
+ "(atan 1 1)",
+ "atan: expects 1 argument, but given 2: 1 1");
+ //next trig func
+
+
+ queueErrorTest("sinh given no args",
+ "(sinh)",
+ "sinh: expects 1 argument, but given 0");
+
+ queueErrorTest("sinh given 1 bad arg",
+ "(sinh add1)",
+ "sinh: expects a number as 1st argument, but given: #");
+
+ queueErrorTest("sinh given too many args",
+ "(sinh 1 1)",
+ "sinh: expects 1 argument, but given 2: 1 1");
+ //next trig func
+
+ queueErrorTest("cosh given no args",
+ "(cosh)",
+ "cosh: expects 1 argument, but given 0");
+
+ queueErrorTest("cosh given 1 bad arg",
+ "(cosh add1)",
+ "cosh: expects a number as 1st argument, but given: #");
+
+ queueErrorTest("cosh given too many args",
+ "(cosh 1 1)",
+ "cosh: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("sqr given no args",
+ "(sqr)",
+ "sqr: expects 1 argument, but given 0");
+
+ queueErrorTest("sqr given 1 bad arg",
+ "(sqr add1)",
+ "sqr: expects a number as 1st argument, but given: #");
+
+ queueErrorTest("sqr given too many args",
+ "(sqr 1 1)",
+ "sqr: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("sqrt given no args",
+ "(sqrt)",
+ "sqrt: expects 1 argument, but given 0");
+
+ queueErrorTest("sqrt given 1 bad arg",
+ "(sqrt add1)",
+ "sqrt: expects a number as 1st argument, but given: #");
+
+ queueErrorTest("sqrt given too many args",
+ "(sqrt 1 1)",
+ "sqrt: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("integer-sqrt given no args",
+ "(integer-sqrt)",
+ "integer-sqrt: expects 1 argument, but given 0");
+
+ queueErrorTest("integer-sqrt given 1 bad arg",
+ "(integer-sqrt add1)",
+ "integer-sqrt: expects an integer as 1st argument, but given: #");
+
+ queueErrorTest("integer-sqrt given too many args",
+ "(integer-sqrt 1 1)",
+ "integer-sqrt: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("make-rectangular given no args",
+ "(make-rectangular)",
+ "make-rectangular: expects 2 arguments, but given 0");
+
+ queueErrorTest("make-rectangular given bad first arg, good 2nd",
+ "(make-rectangular add1 1)",
+ "make-rectangular: expects a real as 1st argument, but given: #; other arguments were: 1");
+
+
+ queueErrorTest("make-rectangular given good first, bad second arg",
+ "(make-rectangular 1 add1)",
+ "make-rectangular: expects a real as 2nd argument, but given: #; other arguments were: 1");
+
+ queueErrorTest("make-rectangular given too many args",
+ "(make-rectangular 1 1 1 1 1)",
+ "make-rectangular: expects 2 arguments, but given 5: 1 1 1 1 1");
+
+ queueErrorTest("make-polar given no args",
+ "(make-polar)",
+ "make-polar: expects 2 arguments, but given 0");
+
+ queueErrorTest("make-polar given bad first arg, good 2nd",
+ "(make-polar add1 1)",
+ "make-polar: expects a real as 1st argument, but given: #; other arguments were: 1");
+
+
+ queueErrorTest("make-polar given good first, bad second arg",
+ "(make-polar 1 add1)",
+ "make-polar: expects a real as 2nd argument, but given: #; other arguments were: 1");
+
+ queueErrorTest("make-polar given too many args",
+ "(make-polar 1 1 1 1 1)",
+ "make-polar: expects 2 arguments, but given 5: 1 1 1 1 1");
+
+ queueErrorTest("real-part given no args",
+ "(real-part)",
+ "real-part: expects 1 argument, but given 0");
+
+ queueErrorTest("real-part given bad arg",
+ "(real-part add1)",
+ "real-part: expects a number as 1st argument, but given: #");
+
+ queueErrorTest("real-part given too many args",
+ "(real-part 1 1)",
+ "real-part: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("imag-part given no args",
+ "(imag-part)",
+ "imag-part: expects 1 argument, but given 0");
+
+ queueErrorTest("imag-part given bad arg",
+ "(imag-part add1)",
+ "imag-part: expects a number as 1st argument, but given: #");
+
+ queueErrorTest("imag-part given too many args",
+ "(imag-part 1 1)",
+ "imag-part: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("angle given no args",
+ "(angle)",
+ "angle: expects 1 argument, but given 0");
+
+ queueErrorTest("angle given bad arg",
+ "(angle add1)",
+ "angle: expects a number as 1st argument, but given: #");
+
+ queueErrorTest("angle given too many args",
+ "(angle 1 1)",
+ "angle: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("magnitude given no args",
+ "(magnitude)",
+ "magnitude: expects 1 argument, but given 0");
+
+ queueErrorTest("magnitude given bad arg",
+ "(magnitude add1)",
+ "magnitude: expects a number as 1st argument, but given: #");
+
+ queueErrorTest("magnitude given too many args",
+ "(magnitude 1 1)",
+ "magnitude: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("conjugate given no args",
+ "(conjugate)",
+ "conjugate: expects 1 argument, but given 0");
+
+ queueErrorTest("conjugate given bad arg",
+ "(conjugate add1)",
+ "conjugate: expects a number as 1st argument, but given: #");
+
+ queueErrorTest("conjugate given too many args",
+ "(conjugate 1 1)",
+ "conjugate: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("sgn given no args",
+ "(sgn)",
+ "sgn: expects 1 argument, but given 0");
+
+ queueErrorTest("sgn given bad arg",
+ "(sgn add1)",
+ "sgn: expects a real number as 1st argument, but given: #");
+
+ queueErrorTest("sgn given too many args",
+ "(sgn 1 1)",
+ "sgn: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("inexact->exact given no args",
+ "(inexact->exact)",
+ "inexact->exact: expects 1 argument, but given 0");
+
+ queueErrorTest("inexact->exact given bad arg",
+ "(inexact->exact add1)",
+ "inexact->exact: expects a number as 1st argument, but given: #");
+
+ queueErrorTest("inexact->exact given too many args",
+ "(inexact->exact 1 1)",
+ "inexact->exact: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("exact->inexact given no args",
+ "(exact->inexact)",
+ "exact->inexact: expects 1 argument, but given 0");
+
+ queueErrorTest("exact->inexact given bad arg",
+ "(exact->inexact add1)",
+ "exact->inexact: expects a number as 1st argument, but given: #");
+
+ queueErrorTest("exact->inexact given too many args",
+ "(exact->inexact 1 1)",
+ "exact->inexact: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("number->string given no args",
+ "(number->string)",
+ "number->string: expects 1 argument, but given 0");
+
+ queueErrorTest("number->string given bad arg",
+ "(number->string add1)",
+ "number->string: expects a number as 1st argument, but given: #");
+
+ queueErrorTest("number->string given too many args",
+ "(number->string 1 1)",
+ "number->string: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("string->number given no args",
+ "(string->number)",
+ "string->number: expects 1 argument, but given 0");
+
+ queueErrorTest("string->number given bad arg",
+ "(string->number add1)",
+ "string->number: expects a string as 1st argument, but given: #");
+
+ queueErrorTest("string->number given too many args",
+ "(string->number 1 1)",
+ "string->number: expects 1 argument, but given 2: 1 1");
+
+
+ queueErrorTest("xml->s-exp given no args",
+ "(xml->s-exp)",
+ "xml->s-exp: expects 1 argument, but given 0");
+
+ queueErrorTest("xml->s-exp given bad arg",
+ "(xml->s-exp add1)",
+ "xml->s-exp: expects a string as 1st argument, but given: #");
+
+ queueErrorTest("xml->s-exp given too many args",
+ "(xml->s-exp 1 1)",
+ "xml->s-exp: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("procedure? given no args",
+ "(procedure?)",
+ "procedure?: expects 1 argument, but given 0");
+
+ queueErrorTest("procedure? too many args",
+ "(procedure? 1 1)",
+ "procedure?: expects 1 argument, but given 2: 1 1");
+
+ //next predicate
+
+ queueErrorTest("pair? given no args",
+ "(pair?)",
+ "pair?: expects 1 argument, but given 0");
+
+ queueErrorTest("pair? too many args",
+ "(pair? 1 1)",
+ "pair?: expects 1 argument, but given 2: 1 1");
+
+ //next predicate
+
+ queueErrorTest("cons? given no args",
+ "(cons?)",
+ "cons?: expects 1 argument, but given 0");
+
+ queueErrorTest("cons? too many args",
+ "(cons? 1 1)",
+ "cons?: expects 1 argument, but given 2: 1 1");
+
+ //next predicate
+
+ queueErrorTest("empty? given no args",
+ "(empty?)",
+ "empty?: expects 1 argument, but given 0");
+
+ queueErrorTest("empty? too many args",
+ "(empty? 1 1)",
+ "empty?: expects 1 argument, but given 2: 1 1");
+
+ //next predicate
+ queueErrorTest("null? given no args",
+ "(null?)",
+ "null?: expects 1 argument, but given 0");
+
+ queueErrorTest("null? too many args",
+ "(null? 1 1)",
+ "null?: expects 1 argument, but given 2: 1 1");
+
+ //next predicate
+ queueErrorTest("undefined? given no args",
+ "(undefined?)",
+ "undefined?: expects 1 argument, but given 0");
+
+ queueErrorTest("undefined? too many args",
+ "(undefined? 1 1)",
+ "undefined?: expects 1 argument, but given 2: 1 1");
+
+ //next predicate
+ /*
+ queueErrorTest("void? given no args",
+ "(void?)",
+ "void?: expects 1 argument, but given 0");
+
+ queueErrorTest("void? too many args",
+ "(void? 1 1)",
+ "void?: expects 1 argument, but given 2: 1 1");
+ */
+ //next predicate
+ queueErrorTest("symbol? given no args",
+ "(symbol?)",
+ "symbol?: expects 1 argument, but given 0");
+
+ queueErrorTest("symbol? too many args",
+ "(symbol? 1 1)",
+ "symbol?: expects 1 argument, but given 2: 1 1");
+
+ //next predicate
+ queueErrorTest("string? given no args",
+ "(string?)",
+ "string?: expects 1 argument, but given 0");
+
+ queueErrorTest("string? too many args",
+ "(string? 1 1)",
+ "string?: expects 1 argument, but given 2: 1 1");
+
+ //next predicate
+ queueErrorTest("char? given no args",
+ "(char?)",
+ "char?: expects 1 argument, but given 0");
+
+ queueErrorTest("char? too many args",
+ "(char? 1 1)",
+ "char?: expects 1 argument, but given 2: 1 1");
+
+ //next predicate
+ queueErrorTest("boolean? given no args",
+ "(boolean?)",
+ "boolean?: expects 1 argument, but given 0");
+
+ queueErrorTest("boolean? too many args",
+ "(boolean? 1 1)",
+ "boolean?: expects 1 argument, but given 2: 1 1");
+
+ //next predicate
+ queueErrorTest("vector? given no args",
+ "(vector?)",
+ "vector?: expects 1 argument, but given 0");
+
+ queueErrorTest("vector? too many args",
+ "(vector? 1 1)",
+ "vector?: expects 1 argument, but given 2: 1 1");
+
+ //next predicate
+ queueErrorTest("struct? given no args",
+ "(struct?)",
+ "struct?: expects 1 argument, but given 0");
+
+ queueErrorTest("struct? too many args",
+ "(struct? 1 1)",
+ "struct?: expects 1 argument, but given 2: 1 1");
+
+ //next predicate
+ queueErrorTest("eof-object? given no args",
+ "(eof-object?)",
+ "eof-object?: expects 1 argument, but given 0");
+
+ queueErrorTest("eof-object? too many args",
+ "(eof-object? 1 1)",
+ "eof-object?: expects 1 argument, but given 2: 1 1");
+
+ //next predicate
+ queueErrorTest("posn? given no args",
+ "(posn?)",
+ "posn?: expects 1 argument, but given 0");
+
+ queueErrorTest("posn? too many args",
+ "(posn? 1 1)",
+ "posn?: expects 1 argument, but given 2: 1 1");
+ /*
+ //next predicate
+ queueErrorTest("bytes? given no args",
+ "(bytes?)",
+ "bytes?: expects 1 argument, but given 0");
+
+ queueErrorTest("bytes? too many args",
+ "(bytes? 1 1)",
+ "bytes?: expects 1 argument, but given 2: 1 1");
+
+ //next predicate
+ queueErrorTest("byte? given no args",
+ "(byte?)",
+ "byte?: expects 1 argument, but given 0");
+
+ queueErrorTest("byte? too many args",
+ "(byte? 1 1)",
+ "byte?: expects 1 argument, but given 2: 1 1");
+ */
+ //next predicate
+ queueErrorTest("number? given no args",
+ "(number?)",
+ "number?: expects 1 argument, but given 0");
+
+ queueErrorTest("number? too many args",
+ "(number? 1 1)",
+ "number?: expects 1 argument, but given 2: 1 1");
+
+ //next predicate
+ queueErrorTest("complex? given no args",
+ "(complex?)",
+ "complex?: expects 1 argument, but given 0");
+
+ queueErrorTest("complex? too many args",
+ "(complex? 1 1)",
+ "complex?: expects 1 argument, but given 2: 1 1");
+
+ //next predicate
+ queueErrorTest("real? given no args",
+ "(real?)",
+ "real?: expects 1 argument, but given 0");
+
+ queueErrorTest("rational? too many args",
+ "(rational? 1 1)",
+ "rational?: expects 1 argument, but given 2: 1 1");
+
+ //next predicate
+
+
+ queueErrorTest("integer? given no args",
+ "(integer?)",
+ "integer?: expects 1 argument, but given 0");
+
+
+ queueErrorTest("integer? too many args",
+ "(integer? 1 1)",
+ "integer?: expects 1 argument, but given 2: 1 1");
+
+
+ queueErrorTest("exact? given no args",
+ "(exact?)",
+ "exact?: expects 1 argument, but given 0");
+
+ queueErrorTest("exact? given a bad arg",
+ "(exact? add1)",
+ "exact?: expects a number as 1st argument, but given: #");
+
+ queueErrorTest("exact? given too many args",
+ "(exact? 1 1)",
+ "exact?: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("inexact? given no args",
+ "(inexact?)",
+ "inexact?: expects 1 argument, but given 0");
+
+ queueErrorTest("inexact? given a bad arg",
+ "(inexact? add1)",
+ "inexact?: expects a number as 1st argument, but given: #");
+
+ queueErrorTest("inexact? given too many args",
+ "(inexact? 1 1)",
+ "inexact?: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("odd? given no args",
+ "(odd?)",
+ "odd?: expects 1 argument, but given 0");
+
+ queueErrorTest("odd? given a bad arg",
+ "(odd? add1)",
+ "odd?: expects an integer as 1st argument, but given: #");
+
+ queueErrorTest("odd? given too many args",
+ "(odd? 1 1)",
+ "odd?: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("even? given no args",
+ "(even?)",
+ "even?: expects 1 argument, but given 0");
+
+ queueErrorTest("even? given a bad arg",
+ "(even? add1)",
+ "even?: expects an integer as 1st argument, but given: #");
+
+ queueErrorTest("even? given too many args",
+ "(even? 1 1)",
+ "even?: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("zero? given no args",
+ "(zero?)",
+ "zero?: expects 1 argument, but given 0");
+
+ queueErrorTest("zero? given a bad arg",
+ "(zero? add1)",
+ "zero?: expects a number as 1st argument, but given: #");
+
+ queueErrorTest("zero? given too many args",
+ "(zero? 1 1)",
+ "zero?: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("positive? given no args",
+ "(positive?)",
+ "positive?: expects 1 argument, but given 0");
+
+ queueErrorTest("positive? given a bad arg",
+ "(positive? add1)",
+ "positive?: expects a real as 1st argument, but given: #");
+
+ queueErrorTest("positive? given too many args",
+ "(positive? 1 1)",
+ "positive?: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("negative? given no args",
+ "(negative?)",
+ "negative?: expects 1 argument, but given 0");
+
+ queueErrorTest("negative? given a bad arg",
+ "(negative? add1)",
+ "negative?: expects a real as 1st argument, but given: #");
+
+ queueErrorTest("negative? given too many args",
+ "(negative? 1 1)",
+ "negative?: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("box? given no args",
+ "(box?)",
+ "box?: expects 1 argument, but given 0");
+
+ queueErrorTest("box? given too many args",
+ "(box? 2 2)",
+ "box?: expects 1 argument, but given 2: 2 2");
+
+ queueErrorTest("hash? given no args",
+ "(hash?)",
+ "hash?: expects 1 argument, but given 0");
+
+ queueErrorTest("hash? given too many args",
+ "(hash? 2 2)",
+ "hash?: expects 1 argument, but given 2: 2 2");
+
+ queueErrorTest("eq? given no args",
+ "(eq?)",
+ "eq?: expects 2 arguments, but given 0");
+
+ queueErrorTest("eq? given too many args",
+ "(eq? 2 2 2)",
+ "eq?: expects 2 arguments, but given 3: 2 2 2");
+
+ queueErrorTest("eq? given one arg",
+ "(eq? 1)",
+ "eq?: expects 2 arguments, but given 1: 1");
+
+ queueErrorTest("eqv? given no args",
+ "(eqv?)",
+ "eqv?: expects 2 arguments, but given 0");
+
+ queueErrorTest("eqv? given too many args",
+ "(eqv? 2 2 2)",
+ "eqv?: expects 2 arguments, but given 3: 2 2 2");
+
+ queueErrorTest("eqv? given one arg",
+ "(eqv? 1)",
+ "eqv?: expects 2 arguments, but given 1: 1");
+
+ queueErrorTest("equal? given no args",
+ "(equal?)",
+ "equal?: expects 2 arguments, but given 0");
+
+ queueErrorTest("equal? given too many args",
+ "(equal? 2 2 2)",
+ "equal?: expects 2 arguments, but given 3: 2 2 2");
+
+ queueErrorTest("equal? given one arg",
+ "(equal? 1)",
+ "equal?: expects 2 arguments, but given 1: 1");
+
+ queueErrorTest("equal~? given no args",
+ "(equal~?)",
+ "equal~?: expects 3 arguments, but given 0");
+
+ queueErrorTest("equal~? given too many args",
+ "(equal~? 1 1 1 1)",
+ "equal~?: expects 3 arguments, but given 4: 1 1 1 1");
+
+ queueErrorTest("equal~? given bad arg a for 3rd arg",
+ "(equal~? add1 sub1 add1)",
+ "equal~?: expects a non-negative number as 3rd argument, but given: #; other arguments were: # #");
+
+ queueErrorTest("false? given no args",
+ "(false?)",
+ "false?: expects 1 argument, but given 0");
+
+ queueErrorTest("false? given too many args",
+ "(false? 1 1)",
+ "false?: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("symbol=? given no args",
+ "(symbol=?)",
+ "symbol=?: expects 2 arguments, but given 0");
+
+ queueErrorTest("symbol=? given too many args",
+ "(symbol=? 1 1 1)",
+ "symbol=?: expects 2 arguments, but given 3: 1 1 1");
+
+ queueErrorTest("symbol=? given bad first arg",
+ "(symbol=? add1 sub1)",
+ "symbol=?: expects a symbol as 1st argument, but given: #; other arguments were: #");
+
+ queueErrorTest("symbol=? given bad 2nd arg",
+ "(symbol=? 'asdf sub1)",
+ "symbol=?: expects a symbol as 2nd argument, but given: #; other arguments were: asdf");
+
+ queueErrorTest("cons given no args",
+ "(cons)",
+ "cons: expects 2 arguments, but given 0");
+
+ queueErrorTest("cons given too many args",
+ "(cons 1 1 1)",
+ "cons: expects 2 arguments, but given 3: 1 1 1");
+
+ queueErrorTest("car given no args",
+ "(car)",
+ "car: expects 1 argument, but given 0");
+
+ queueErrorTest("car given bad arg",
+ "(car add1)",
+ "car: expects a pair as 1st argument, but given: #");
+
+ queueErrorTest("car given too many args",
+ "(car 1 1 1)",
+ "car: expects 1 argument, but given 3: 1 1 1");
+ //next list primitive
+
+ queueErrorTest("cdr given no args",
+ "(cdr)",
+ "cdr: expects 1 argument, but given 0");
+
+ queueErrorTest("cdr given bad arg",
+ "(cdr add1)",
+ "cdr: expects a pair as 1st argument, but given: #");
+
+ queueErrorTest("cdr given too many args",
+ "(cdr 1 1 1)",
+ "cdr: expects 1 argument, but given 3: 1 1 1");
+ //next list primitive
+
+ queueErrorTest("caar given no args",
+ "(caar)",
+ "caar: expects 1 argument, but given 0");
+
+ queueErrorTest("caar given bad arg",
+ "(caar add1)",
+ "caar: expects a caarable value as 1st argument, but given: #");
+
+ queueErrorTest("caar given too many args",
+ "(caar 1 1 1)",
+ "caar: expects 1 argument, but given 3: 1 1 1");
+ //next list primitive
+
+ queueErrorTest("cadr given no args",
+ "(cadr)",
+ "cadr: expects 1 argument, but given 0");
+
+ queueErrorTest("cadr given bad arg",
+ "(cadr add1)",
+ "cadr: expects a cadrable value as 1st argument, but given: #");
+
+ queueErrorTest("cadr given too many args",
+ "(cadr 1 1 1)",
+ "cadr: expects 1 argument, but given 3: 1 1 1");
+ //next list primitive
+
+ queueErrorTest("cdar given no args",
+ "(cdar)",
+ "cdar: expects 1 argument, but given 0");
+
+ queueErrorTest("cdar given bad arg",
+ "(cdar add1)",
+ "cdar: expects a cdarable value as 1st argument, but given: #");
+
+ queueErrorTest("cdar given too many args",
+ "(cdar 1 1 1)",
+ "cdar: expects 1 argument, but given 3: 1 1 1");
+ //next list primitive
+
+ queueErrorTest("cddr given no args",
+ "(cddr)",
+ "cddr: expects 1 argument, but given 0");
+
+ queueErrorTest("cddr given bad arg",
+ "(cddr add1)",
+ "cddr: expects a cddrable value as 1st argument, but given: #");
+
+ queueErrorTest("cddr given too many args",
+ "(cddr 1 1 1)",
+ "cddr: expects 1 argument, but given 3: 1 1 1");
+ //next list primitive
+
+ queueErrorTest("caaar given no args",
+ "(caaar)",
+ "caaar: expects 1 argument, but given 0");
+
+ queueErrorTest("caaar given bad arg",
+ "(caaar add1)",
+ "caaar: expects a caaarable value as 1st argument, but given: #");
+
+ queueErrorTest("caaar given too many args",
+ "(caaar 1 1 1)",
+ "caaar: expects 1 argument, but given 3: 1 1 1");
+ //next list primitive
+
+ queueErrorTest("caadr given no args",
+ "(caadr)",
+ "caadr: expects 1 argument, but given 0");
+
+ queueErrorTest("caadr given bad arg",
+ "(caadr add1)",
+ "caadr: expects a caadrable value as 1st argument, but given: #");
+
+ queueErrorTest("caadr given too many args",
+ "(caadr 1 1 1)",
+ "caadr: expects 1 argument, but given 3: 1 1 1");
+ //next list primitive
+
+ queueErrorTest("cadar given no args",
+ "(cadar)",
+ "cadar: expects 1 argument, but given 0");
+
+ queueErrorTest("cadar given bad arg",
+ "(cadar add1)",
+ "cadar: expects a cadarable value as 1st argument, but given: #");
+
+ queueErrorTest("cadar given too many args",
+ "(cadar 1 1 1)",
+ "cadar: expects 1 argument, but given 3: 1 1 1");
+ //next list primitive
+
+ queueErrorTest("cdaar given no args",
+ "(cdaar)",
+ "cdaar: expects 1 argument, but given 0");
+
+ queueErrorTest("cdaar given bad arg",
+ "(cdaar add1)",
+ "cdaar: expects a cdaarable value as 1st argument, but given: #");
+
+ queueErrorTest("cdaar given too many args",
+ "(cdaar 1 1 1)",
+ "cdaar: expects 1 argument, but given 3: 1 1 1");
+ //next list primitive
+
+ queueErrorTest("cdadr given no args",
+ "(cdadr)",
+ "cdadr: expects 1 argument, but given 0");
+
+ queueErrorTest("cdadr given bad arg",
+ "(cdadr add1)",
+ "cdadr: expects a cdadrable value as 1st argument, but given: #");
+
+ queueErrorTest("cdadr given too many args",
+ "(cdadr 1 1 1)",
+ "cdadr: expects 1 argument, but given 3: 1 1 1");
+ //next list primitive
+
+ queueErrorTest("cddar given no args",
+ "(cddar)",
+ "cddar: expects 1 argument, but given 0");
+
+ queueErrorTest("cddar given bad arg",
+ "(cddar add1)",
+ "cddar: expects a cddarable value as 1st argument, but given: #");
+
+ queueErrorTest("cddar given too many args",
+ "(cddar 1 1 1)",
+ "cddar: expects 1 argument, but given 3: 1 1 1");
+ //next list primitive
+
+ queueErrorTest("caddr given no args",
+ "(caddr)",
+ "caddr: expects 1 argument, but given 0");
+
+ queueErrorTest("caddr given bad arg",
+ "(caddr add1)",
+ "caddr: expects a caddrable value as 1st argument, but given: #");
+
+ queueErrorTest("caddr given too many args",
+ "(caddr 1 1 1)",
+ "caddr: expects 1 argument, but given 3: 1 1 1");
+ //next list primitive
+
+ queueErrorTest("cdddr given no args",
+ "(cdddr)",
+ "cdddr: expects 1 argument, but given 0");
+
+ queueErrorTest("cdddr given bad arg",
+ "(cdddr add1)",
+ "cdddr: expects a cdddrable value as 1st argument, but given: #");
+
+ queueErrorTest("cdddr given too many args",
+ "(cdddr 1 1 1)",
+ "cdddr: expects 1 argument, but given 3: 1 1 1");
+ //next list primitive
+
+ queueErrorTest("cadddr given no args",
+ "(cadddr)",
+ "cadddr: expects 1 argument, but given 0");
+
+ queueErrorTest("cadddr given bad arg",
+ "(cadddr add1)",
+ "cadddr: expects a cadddrable value as 1st argument, but given: #");
+
+ queueErrorTest("cadddr given too many args",
+ "(cadddr 1 1 1)",
+ "cadddr: expects 1 argument, but given 3: 1 1 1");
+ //next list primitive
+
+ queueErrorTest("rest given no args",
+ "(rest)",
+ "rest: expects 1 argument, but given 0");
+
+ queueErrorTest("rest given bad arg",
+ "(rest add1)",
+ "rest: expects a non-empty list as 1st argument, but given: #");
+
+ queueErrorTest("rest given too many args",
+ "(rest 1 1 1)",
+ "rest: expects 1 argument, but given 3: 1 1 1");
+ //next list primitive
+
+ queueErrorTest("first given no args",
+ "(first)",
+ "first: expects 1 argument, but given 0");
+
+ queueErrorTest("first given bad arg",
+ "(first add1)",
+ "first: expects a non-empty list as 1st argument, but given: #");
+
+ queueErrorTest("first given too many args",
+ "(first 1 1 1)",
+ "first: expects 1 argument, but given 3: 1 1 1");
+ //next list primitive
+
+ queueErrorTest("second given no args",
+ "(second)",
+ "second: expects 1 argument, but given 0");
+
+ queueErrorTest("second given bad arg",
+ "(second add1)",
+ "second: expects a list with 2 or more elements as 1st argument, but given: #");
+
+ queueErrorTest("second given too many args",
+ "(second 1 1 1)",
+ "second: expects 1 argument, but given 3: 1 1 1");
+
+ queueErrorTest("third given no args",
+ "(third)",
+ "third: expects 1 argument, but given 0");
+
+ queueErrorTest("third given bad arg",
+ "(third add1)",
+ "third: expects a list with 3 or more elements as 1st argument, but given: #");
+
+ queueErrorTest("third given too many args",
+ "(third 1 1 1)",
+ "third: expects 1 argument, but given 3: 1 1 1");
+
+ queueErrorTest("fourth given no args",
+ "(fourth)",
+ "fourth: expects 1 argument, but given 0");
+
+ queueErrorTest("fourth given bad arg",
+ "(fourth add1)",
+ "fourth: expects a list with 4 or more elements as 1st argument, but given: #");
+
+ queueErrorTest("fourth given too many args",
+ "(fourth 1 1 1)",
+ "fourth: expects 1 argument, but given 3: 1 1 1");
+
+ queueErrorTest("fifth given no args",
+ "(fifth)",
+ "fifth: expects 1 argument, but given 0");
+
+ queueErrorTest("fifth given bad arg",
+ "(fifth add1)",
+ "fifth: expects a list with 5 or more elements as 1st argument, but given: #");
+
+ queueErrorTest("fifth given too many args",
+ "(fifth 1 1 1)",
+ "fifth: expects 1 argument, but given 3: 1 1 1");
+
+ queueErrorTest("sixth given no args",
+ "(sixth)",
+ "sixth: expects 1 argument, but given 0");
+
+ queueErrorTest("sixth given bad arg",
+ "(sixth add1)",
+ "sixth: expects a list with 6 or more elements as 1st argument, but given: #");
+
+ queueErrorTest("sixth given too many args",
+ "(sixth 1 1 1)",
+ "sixth: expects 1 argument, but given 3: 1 1 1");
+
+ queueErrorTest("seventh given no args",
+ "(seventh)",
+ "seventh: expects 1 argument, but given 0");
+
+ queueErrorTest("seventh given bad arg",
+ "(seventh add1)",
+ "seventh: expects a list with 7 or more elements as 1st argument, but given: #");
+
+ queueErrorTest("seventh given too many args",
+ "(seventh 1 1 1)",
+ "seventh: expects 1 argument, but given 3: 1 1 1");
+
+ queueErrorTest("eighth given no args",
+ "(eighth)",
+ "eighth: expects 1 argument, but given 0");
+
+ queueErrorTest("eighth given bad arg",
+ "(eighth add1)",
+ "eighth: expects a list with 8 or more elements as 1st argument, but given: #");
+
+ queueErrorTest("eighth given too many args",
+ "(eighth 1 1 1)",
+ "eighth: expects 1 argument, but given 3: 1 1 1");
+
+ queueErrorTest("length given no args",
+ "(length)",
+ "length: expects 1 argument, but given 0");
+
+ queueErrorTest("length given a bad arg",
+ "(length add1)",
+ "length: expects a list as 1st argument, but given: #");
+
+ queueErrorTest("length given too many args",
+ "(length 1 1)",
+ "length: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("list? given no args",
+ "(list?)",
+ "list?: expects 1 argument, but given 0");
+
+ queueErrorTest("list? given too many args",
+ "(list? 1 1 1)",
+ "list?: expects 1 argument, but given 3: 1 1 1");
+
+ queueErrorTest("list* given no args",
+ "(list*)",
+ "list*: expects at least 1 argument, but given 0");
+
+ queueErrorTest("list* given too many args",
+ "(list* 1 1 1)",
+ "list*: expects a list as 3rd argument, but given: 1; other arguments were: 1 1");
+
+ queueErrorTest("list-ref given no args",
+ "(list-ref)",
+ "list-ref: expects 2 arguments, but given 0");
+
+ queueErrorTest("list-ref given too many args",
+ "(list-ref 1 1 1)",
+ "list-ref: expects 2 arguments, but given 3: 1 1 1");
+
+ queueErrorTest("list-ref given bad arg for first arg",
+ "(list-ref add1 1)",
+ "list-ref: expects a list as 1st argument, but given: #; other arguments were: 1");
+
+ queueErrorTest("list-ref given bad arg for second arg",
+ "(list-ref (list) add1)",
+ "list-ref: expects a non-negative exact integer as 2nd argument, but given: #; other arguments were: empty");
+
+ queueErrorTest("append given bad args",
+ "(append sub1 add1)",
+ "append: expects a list as 1st argument, but given: #; other arguments were: #")
+
+ queueErrorTest("reverse given no args",
+ "(reverse)",
+ "reverse: expects 1 argument, but given 0");
+
+ queueErrorTest("reverse given too many args",
+ "(reverse 1 1)",
+ "reverse: expects 1 argument, but given 2: 1 1");
+
+ queueErrorTest("reverse given bad arg",
+ "(reverse add1)",
+ "reverse: expects a list as 1st argument, but given: #");
+
+
+ queueErrorTest("underlay given no args",
+ "(underlay)",
+ "underlay: expects at least 2 arguments, but given 0");
+
+ queueErrorTest("underlay given bad first arg",
+ "(underlay 1 1 1)",
+ "underlay: expects an image as 1st argument, but given: 1; other arguments were: 1 1");
+
+ queueErrorTest("underlay given not enough args",
+ "(underlay 1)",
+ "underlay: expects at least 2 arguments, but given 1: 1");
+
+ queueErrorTest("underlay/xy given no args",
+ "(underlay/xy)",
+ "underlay/xy: expects 4 arguments, but given 0");
+
+ queueErrorTest("underlay/xy given bad first arg",
+ "(underlay/xy 1 1 1 1)",
+ "underlay/xy: expects an image as 1st argument, but given: 1; other arguments were: 1 1 1");
+
+ queueErrorTest("underlay/xy given too many args",
+ "(underlay/xy 1 1 1 1 1)",
+ "underlay/xy: expects 4 arguments, but given 5: 1 1 1 1 1");
+
+ queueErrorTest("underlay/align given no args",
+ "(underlay/align)",
+ "underlay/align: expects at least 4 arguments, but given 0");
+
+ queueErrorTest("underlay/align given bad first arg",
+ "(underlay/align 1 1 1 1 1)",
+ "underlay/align: expects a x-place as 1st argument, but given: 1; other arguments were: 1 1 1 1");
+
+ queueErrorTest("scale given no args",
+ "(scale)",
+ "scale: expects 2 arguments, but given 0");
+
+ queueErrorTest("scale given too many args",
+ "(scale 1 1 1)",
+ "scale: expects 2 arguments, but given 3: 1 1 1");
+
+ queueErrorTest("scale given bad second arg a",
+ "(scale 1 1)",
+ "scale: expects an image as 2nd argument, but given: 1; other arguments were: 1");
+
+
+ queueErrorTest("scale given bad first arg a",
+ "(scale add1 1)",
+ "scale: expects a finite real number as 1st argument, but given: #; other arguments were: 1");
+
+ queueErrorTest("scale/xy given no args",
+ "(scale/xy)",
+ "scale/xy: expects 3 arguments, but given 0");
+
+ queueErrorTest("scale/xy given bad 3rd arg a",
+ "(scale/xy 1 1 1)",
+ "scale/xy: expects an image as 3rd argument, but given: 1; other arguments were: 1 1");
+
+ queueErrorTest("scale/xy given too many args",
+ "(scale/xy 1 1 1 1)",
+ "scale/xy: expects 3 arguments, but given 4: 1 1 1 1");
+
+ queueErrorTest("andmap given no args",
+ "(andmap)",
+ "andmap: expects at least 2 arguments, but given 0");
+
+ queueErrorTest("andmap given bad first arg a",
+ "(andmap 1 1)",
+ "andmap: expects a function name as 1st argument, but given: 1; other arguments were: 1");
+
+ queueErrorTest("andmap given bad 2nd arg a",
+ "(andmap add1 sub1)",
+ "andmap: expects a list as 2nd argument, but given: #; other arguments were: #");
+
+ queueErrorTest("ormap given no args",
+ "(ormap)",
+ "ormap: expects at least 2 arguments, but given 0");
+
+ queueErrorTest("ormap given bad first arg a",
+ "(ormap 1 1)",
+ "ormap: expects a function name as 1st argument, but given: 1; other arguments were: 1");
+
+ queueErrorTest("ormap given bad 2nd arg a",
+ "(ormap add1 sub1)",
+ "ormap: expects a list as 2nd argument, but given: #; other arguments were: #");
+
+
+ queueErrorTest("memq given no args",
+ "(memq)",
+ "memq: expects 2 arguments, but given 0");
+
+ queueErrorTest("memq given too many args",
+ "(memq 1 1 1)",
+ "memq: expects 2 arguments, but given 3: 1 1 1");
+
+ queueErrorTest("memq given bad second arg a",
+ "(memq 1 1)",
+ "memq: expects a list as 2nd argument, but given: 1; other arguments were: 1");
+
+ queueErrorTest("memv given no args",
+ "(memv)",
+ "memv: expects 2 arguments, but given 0");
+
+ queueErrorTest("memv given too many args",
+ "(memv 1 1 1)",
+ "memv: expects 2 arguments, but given 3: 1 1 1");
+
+ queueErrorTest("memv given bad second arg a",
+ "(memv 1 1)",
+ "memv: expects a list as 2nd argument, but given: 1; other arguments were: 1");
+
+
+ queueErrorTest("member given no args",
+ "(member)",
+ "member: expects 2 arguments, but given 0");
+
+ queueErrorTest("member given too many args",
+ "(member 1 1 1)",
+ "member: expects 2 arguments, but given 3: 1 1 1");
+
+ queueErrorTest("member given bad second arg a",
+ "(member 1 1)",
+ "member: expects a list as 2nd argument, but given: 1; other arguments were: 1");
+
+
+ queueErrorTest("member? given no args",
+ "(member?)",
+ "member?: expects 2 arguments, but given 0");
+
+ queueErrorTest("member? given too many args",
+ "(member? 1 1 1)",
+ "member?: expects 2 arguments, but given 3: 1 1 1");
+
+ queueErrorTest("member? given bad second arg a",
+ "(member? 1 1)",
+ "member?: expects a list as 2nd argument, but given: 1; other arguments were: 1");
+
+
+ queueErrorTest("memf given no args",
+ "(memf)",
+ "memf: expects 2 arguments, but given 0");
+
+ queueErrorTest("memf given too many args",
+ "(memf 1 1 1)",
+ "memf: expects 2 arguments, but given 3: 1 1 1");
+
+ queueErrorTest("memf given bad first arg a",
+ "(memf 1 1)",
+ "memf: expects a function name as 1st argument, but given: 1; other arguments were: 1");
+
+
+ queueErrorTest("assq given no args",
+ "(assq)",
+ "assq: expects 2 arguments, but given 0");
+
+ queueErrorTest("assq given too many args",
+ "(assq 1 1 1)",
+ "assq: expects 2 arguments, but given 3: 1 1 1");
+
+ queueErrorTest("assq given bad second arg a",
+ "(assq 1 1)",
+ "assq: expects a list of pair as 2nd argument, but given: 1; other arguments were: 1");
+
+ queueErrorTest("assv given no args",
+ "(assv)",
+ "assv: expects 2 arguments, but given 0");
+
+ queueErrorTest("assv given too many args",
+ "(assv 1 1 1)",
+ "assv: expects 2 arguments, but given 3: 1 1 1");
+
+ queueErrorTest("assv given bad second arg a",
+ "(assv 1 1)",
+ "assv: expects a list of pair as 2nd argument, but given: 1; other arguments were: 1");
+
+
+ queueErrorTest("assoc given no args",
+ "(assoc)",
+ "assoc: expects 2 arguments, but given 0");
+
+ queueErrorTest("assoc given too many args",
+ "(assoc 1 1 1)",
+ "assoc: expects 2 arguments, but given 3: 1 1 1");
+
+ queueErrorTest("assoc given bad second arg a",
+ "(assoc 1 1)",
+ "assoc: expects a list of pair as 2nd argument, but given: 1; other arguments were: 1");
+
+ queueErrorTest("remove given no args",
+ "(remove)",
+ "remove: expects 2 arguments, but given 0");
+
+ queueErrorTest("remove given too many args",
+ "(remove 1 1 1)",
+ "remove: expects 2 arguments, but given 3: 1 1 1");
+
+ queueErrorTest("remove given bad second arg",
+ "(remove 1 1)",
+ "remove: expects a list as 2nd argument, but given: 1; other arguments were: 1");
+
+
+ queueErrorTest("test check-expect functions",
+ "(check-expect + -)",
+ 'check-expect cannot compare functions');
+
+ queueErrorTest("test check-expect arity",
+ "(check-expect 1 2 3)",
+ 'check-expect: expects 2 arguments, but given 3: 1 2 3');
+
+ queueErrorTest("test check-expect arity",
+ "(check-expect )",
+ 'check-expect: expects 2 arguments, but given 0');
+
+ queueErrorTest("test check-within nonneg real",
+ "(check-within 2 1 -3)",
+ 'check-within requires a non-negative real number for range, but given -3.');
+
+ queueErrorTest("test check-within functions",
+ "(check-within + - 2)",
+ 'check-within cannot compare functions');
+
+ queueErrorTest("test check-within arity",
+ "(check-within 3 3 3 3 3 3 3 3 3 3 3)",
+ 'check-within: expects 3 arguments, but given 11: 3 3 3 3 3 3 3 3 3 3 3');
+ /*
+ queueErrorTest("test print arity",
+ '(print "hello" "world")',
+ 'print: expects 1 argument, but given 2: "hello" "world"');
+ */
+ queueErrorTest("test write arity",
+ "(write 1 2 3 4 5)",
+ "write: expects 1 or 2 arguments, but given 5: 1 2 3 4 5");
+
+ queueErrorTest("test write arity",
+ "(write )",
+ "write: expects 1 or 2 arguments, but given 0");
+
+ queueErrorTest("test display arity",
+ "(display 1 2 3 4 5)",
+ "display: expects 1 or 2 arguments, but given 5: 1 2 3 4 5");
+
+ queueErrorTest("test display arity",
+ "(display )",
+ "display: expects 1 or 2 arguments, but given 0");
+
+ queueErrorTest("test for-each arity",
+ "(for-each )",
+ "for-each: expects at least 2 arguments, but given 0");
+
+ queueErrorTest("test for-each arity 2",
+ "(for-each 1 2 3 4 5)",
+ "for-each: expects a function name as 1st argument, but given: 1; other arguments were: 2 3 4 5");
+
+
+ queueErrorTest("test for-each a",
+ "(for-each 1 2)",
+ "for-each: expects a function name as 1st argument, but given: 1; other arguments were: 2");
+
+
+
+ //////////////////////////////////////////////////////////////////////
+
+
+ //map
+ queueErrorTest("test map with function that cannot be applied to elements in list",
+ "(map add1 (list \"hello\" \"world\"))",
+ 'add1: expects a number as 1st argument, but given: "hello"');
+ //filter
+ queueErrorTest("test filter without procedure as 1st argument",
+ "(filter 2 (list 2 3 4))",
+ 'filter: expects a function name (arity 1) as 1st argument, but given: 2; other arguments were: (list 2 3 4)');
+
+ //foldl
+ queueErrorTest("test foldl with arguments of wrong a",
+ "(foldl + \"1\" (list 2 3))",
+ '+: expects a number as 2nd argument, but given: "1"; other arguments were: 2');
+
+ queueErrorTest("test foldl with arguments of wrong a",
+ "(foldl 1 7 (list 2 3))",
+ 'foldl: expects a function name as 1st argument, but given: 1; other arguments were: 7 (list 2 3)');
+
+ //foldr
+ queueErrorTest("test foldr with arguments of wrong a",
+ "(foldr 1 2 (list 3))",
+ 'foldr: expects a function name as 1st argument, but given: 1; other arguments were: 2 (list 3)');
+
+ queueErrorTest("test foldr with arguments of wrong a",
+ "(foldr + \"hello\" (list 1 2 3))",
+ '+: expects a number as 2nd argument, but given: "hello"; other arguments were: 3');
+
+ //argmax
+ queueErrorTest("test argmax with empty list",
+ "(argmax 2 '())",
+ 'argmax: expects a function name as 1st argument, but given: 2; other arguments were: empty');
+
+ queueErrorTest("test argmax with first argument not a procedure",
+ "(argmax 2 (list 2))",
+ 'argmax: expects a function name as 1st argument, but given: 2; other arguments were: (list 2)');
+
+ queueErrorTest("test argmax with second argument not a list",
+ "(argmax car 2)",
+ 'argmax: expects a non-empty list as 2nd argument, but given: 2; other arguments were: #');
+
+ //argmin
+ queueErrorTest("test argmin with empty list",
+ "(argmin 2 '())",
+ 'argmin: expects a function name as 1st argument, but given: 2; other arguments were: empty');
+
+ queueErrorTest("test argmin with first argument not a procedure",
+ "(argmin 2 (list 2))",
+ 'argmin: expects a function name as 1st argument, but given: 2; other arguments were: (list 2)');
+
+ queueErrorTest("test argmin with second argument not a list",
+ "(argmin car 2)",
+ 'argmin: expects a non-empty list as 2nd argument, but given: 2; other arguments were: #');
+
+ //build-list
+ queueErrorTest("test build-list with first argument not a number",
+ "(build-list \"number\" add1)",
+ "build-list: expects a non-negative exact integer as 1st argument, but given: \"number\"; other arguments were: #");
+
+ queueErrorTest("test build-list with second argument not a proc",
+ "(build-list 2 6)",
+ 'build-list: expects a function name as 2nd argument, but given: 6; other arguments were: 2');
+
+ //make-hash
+
+ queueErrorTest("test make-hash with listof listof pairs not first argument",
+ "(make-hash 1)",
+ 'make-hash: expects a list of list of pairs as 1st argument, but given: 1');
+
+ queueErrorTest("test make-hash with 2 arguments instead of 0 or 1",
+ "(make-hash (list (list 1 \"hello\") (list 2 \"world\") (list 3 \"today\")) 2)",
+ 'make-hash: expects 0 or 1 arguments, but given 2: (list (list 1 "hello") (list 2 "world") (list 3 "today")) 2');
+
+
+ //hash-set!
+
+ queueErrorTest("test hash-set! with first argument not a hash",
+ "(hash-set! 5 2 \"bird\")",
+ 'hash-set!: expects a hash as 1st argument, but given: 5; other arguments were: 2 "bird"');
+
+ queueErrorTest("test hash-set! with wrong arity",
+ "(hash-set!)",
+ 'hash-set!: expects 3 arguments, but given 0');
+
+ //hash-ref
+ queueErrorTest("test hash-ref with wrong arity",
+ "(hash-ref \"thing\")",
+ 'hash-ref: expects 2 or 3 arguments, but given 1: thing');
+
+ queueErrorTest("test hash-ref with 1st argument not a hash",
+ "(hash-ref \"imma hash\" 2)",
+ 'hash-ref: expects a hash as 1st argument, but given: "imma hash"; other arguments were: 2');
+
+ //hash-remove!
+ queueErrorTest("test hash-remove! with wrong arity",
+ "(hash-remove!)",
+ 'hash-remove: expects 2 arguments, but given 0');
+
+ queueErrorTest("test hash-remove! with wrong 1st argument not hash",
+ "(hash-remove! 2 2)",
+ 'hash-remove!: expects a hash as 1st argument, but given: 2; other arguments were: 2');
+
+ //hash-map
+
+ queueErrorTest("test hash-map with wrong arity",
+ "(hash-map)",
+ 'hash-map: expects 2 arguments, but given 0');
+
+ queueErrorTest("test hash-map with wrong first argument not hash",
+ "(hash-map 2 cons)",
+ 'hash-map: expects a hash as 1st argument, but given: 2; other arguments were: #');
+
+ queueErrorTest("test hash-map with wrong 2nd argument not proc",
+ "(hash-map (make-hash (list (list 1 100) (list 2 200) (list 3 300))) 2)",
+ 'hash-map: expects a function name as 2nd argument, but given: 2; other arguments were: #hash((1 . (list 100)) (2 . (list 200)) (3 . (list 300)))');
+
+ //hash-for-each
+
+ queueErrorTest("test hash-for-each with wrong arity",
+ "(hash-for-each)",
+ 'hash-for-each: expects 2 arguments, but given 0');
+
+ queueErrorTest("test hash-for-each with wrong 1st argument not proc",
+ "(hash-for-each \"imma hash brown\" cons)",
+ 'hash-for-each: expects a hash as 1st argument, but given: "imma hash brown"; other arguments were: #');
+
+ queueErrorTest("test hash-for-each with wrong 2nd argument not proc",
+ "(hash-for-each (make-hash) \"add\")",
+ 'hash-for-each: expects a function name as 2nd argument, but given: "add"; other arguments were: #hash()');
+
+ //make-string
+
+ queueErrorTest("test make-string with wrong arity",
+ "(make-string)",
+ 'make-string: expects 2 arguments, but given 0');
+
+ queueErrorTest("test make-string with 1st argument not exact integer",
+ "(make-string 2.5 2)",
+ 'make-string: expects a non-negative exact integer as 1st argument, but given: 5/2; other arguments were: 2');
+
+ queueErrorTest("test make-string with 2nd argument not char",
+ "(make-string 3 2)",
+ 'make-string: expects a character as 2nd argument, but given: 2; other arguments were: 3');
+
+ //replicate
+
+ queueErrorTest("test replicate with wrong arity",
+ "(replicate)",
+ 'replicate: expects 2 arguments, but given 0');
+
+ queueErrorTest("test replicate with 1st argument not exact integer",
+ "(replicate 2.1 \"World\")",
+ 'replicate: expects a non-negative exact integer as 1st argument, but given: 21/10; other arguments were: "World"');
+
+ queueErrorTest("test replicate with 2nd argument not string",
+ "(replicate 2 1)",
+ 'replicate: expects a string as 2nd argument, but given: 1; other arguments were: 2');
+
+ //string
+
+ queueErrorTest("test string with 1st argument not char",
+ "(string 1)",
+ 'string: expects a character as 1st argument, but given: 1');
+
+ //string-length
+
+ queueErrorTest("test string-length with wrong arity",
+ "(string-length)",
+ 'string-length: expects 1 argument, but given 0');
+
+ queueErrorTest("test string-length with 1st argument not string",
+ "(string-length 2)",
+ 'string-length: expects a string as 1st argument, but given: 2');
+
+ //string-ref
+
+ queueErrorTest("test string-ref with wrong arity",
+ "(string-ref)",
+ 'string-ref: expects 2 arguments, but given 0');
+
+ queueErrorTest("test string-ref with 1st argument not string",
+ "(string-ref 2 2)",
+ 'string-ref: expects a string as 1st argument, but given: 2; other arguments were: 2');
+
+ queueErrorTest("test string-ref with 1st argument not string",
+ "(string-ref \"hello\" \"world\")",
+ 'string-ref: expects a non-negative exact integer as 2nd argument, but given: "world"; other arguments were: "hello"');
+
+ //out of bounds
+
+
+ //string=?
+
+ queueErrorTest("test string=? with 1st argument not string",
+ "(string=? 42 \"hello\")",
+ 'string=?: expects a string as 1st argument, but given: 42; other arguments were: "hello"');
+
+ queueErrorTest("test string=? with 2nd argument not string",
+ "(string=? \"thing\" 42)",
+ 'string=?: expects a string as 2nd argument, but given: 42; other arguments were: "thing"');
+
+ queueErrorTest("test string=? with wrong arity",
+ "(string=?)",
+ 'string=?: expects at least 2 arguments, but given 0');
+
+ //string-ci=?
+
+ queueErrorTest("test string-ci=? with wrong arity",
+ "(string-ci=?)",
+ 'string-ci=?: expects at least 2 arguments, but given 0');
+
+ queueErrorTest("test string-ci=? with 1st argument not string",
+ "(string-ci=? 4 \"thing\")",
+ 'string-ci=?: expects a string as 1st argument, but given: 4; other arguments were: "thing"');
+
+ queueErrorTest("test string-ci=? with 1st argument not string",
+ "(string-ci=? \"thing\" 2)",
+ 'string-ci=?: expects a string as 2nd argument, but given: 2; other arguments were: "thing"');
+
+ //string?
+
+ queueErrorTest("test string>? with wrong arity",
+ "(string>?)",
+ 'string>?: expects at least 2 arguments, but given 0');
+
+ queueErrorTest("test string>? with 1st argument not string",
+ "(string>? 3 \"thing\")",
+ 'string>?: expects a string as 1st argument, but given: 3; other arguments were: "thing"');
+
+ queueErrorTest("test string>? with 1st argument not string",
+ "(string>? \"thing\" 3)",
+ 'string>?: expects a string as 2nd argument, but given: 3; other arguments were: "thing"');
+
+
+ //string<=?
+
+ queueErrorTest("test string<=? with wrong arity",
+ "(string<=?)",
+ 'string<=?: expects at least 2 arguments, but given 0');
+
+ queueErrorTest("test string<=? with 1st argument not string",
+ "(string<=? 3 \"thing\")",
+ 'string<=?: expects a string as 1st argument, but given: 3; other arguments were: "thing"');
+
+ queueErrorTest("test string>? with 1st argument not string",
+ "(string>? \"thing\" 3)",
+ 'string>?: expects a string as 2nd argument, but given: 3; other arguments were: "thing"');
+
+ //string>=?
+
+ queueErrorTest("test string>=? with wrong arity",
+ "(string>=?)",
+ 'string>=?: expects at least 2 arguments, but given 0');
+
+ queueErrorTest("test string>=? with 1st argument not string",
+ "(string>=? 2 \"thing\")",
+ 'string>=?: expects a string as 1st argument, but given: 2; other arguments were: "thing"');
+
+ queueErrorTest("test string>=? with 1st argument not string",
+ "(string>=? \"thing\" 2)",
+ 'string>=?: expects a string as 2nd argument, but given: 2; other arguments were: "thing"');
+
+
+ //string-ci?
+
+ queueErrorTest("test string-ci>? with wrong arity",
+ "(string-ci>?)",
+ 'string-ci>?: expects at least 2 arguments, but given 0');
+
+ queueErrorTest("test string-ci>? with 1st argument not string",
+ "(string-ci>? 1 \"thing\")",
+ 'string-ci>?: expects a string as 1st argument, but given: 1; other arguments were: "thing"');
+
+ queueErrorTest("test string-ci>? with 1st argument not string",
+ "(string-ci>? \"thing\" 2)",
+ 'string-ci>?: expects a string as 2nd argument, but given: 2; other arguments were: "thing"');
+
+ //string-ci<=?
+
+ queueErrorTest("test string-ci<=? with wrong arity",
+ "(string-ci<=?)",
+ 'string-ci<=?: expects at least 2 arguments, but given 0');
+
+ queueErrorTest("test string-ci<=? with 1st argument not string",
+ "(string-ci<=? 1 \"thing\")",
+ 'string-ci<=?: expects a string as 1st argument, but given: 1; other arguments were: "thing"');
+
+ queueErrorTest("test string-ci<=? with 1st argument not string",
+ "(string-ci<=? \"thing\" 2)",
+ 'string-ci<=?: expects a string as 2nd argument, but given: 2; other arguments were: "thing"');
+
+ //string-ci>=?
+
+ queueErrorTest("test string-ci>=? with wrong arity",
+ "(string-ci>=?)",
+ 'string-ci>=?: expects at least 2 arguments, but given 0');
+
+ queueErrorTest("test string-ci>=? with 1st argument not string",
+ "(string-ci>=? 1 \"thing\")",
+ 'string-ci>=?: expects a string as 1st argument, but given: 1; other arguments were: "thing"');
+
+ queueErrorTest("test string-ci>=? with 1st argument not string",
+ "(string-ci>=? \"thing\" 2)",
+ 'string-ci>=?: expects a string as 2nd argument, but given: 2; other arguments were: "thing"');
+
+ //substring
+
+ queueErrorTest("test substring with wrong arity",
+ "(substring)",
+ 'substring: expects 2 or 3 arguments, but given 0');
+
+ queueErrorTest("test substring with 1st argument not string",
+ "(substring 1 1 2)",
+ 'substring: expects a string as 1st argument, but given: 1; other arguments were: 1 2');
+
+ queueErrorTest("test substring with 2nd argument not string",
+ "(substring \"hello\" \"world\" 2)",
+ 'substring: expects a non-negative exact integer as 2nd argument, but given: "world"; other arguments were: "hello" 2');
+
+ queueErrorTest("test substring with 3rd argument not string",
+ "(substring \"hello\" 2 \"world\")",
+ 'substring: expects a non-negative exact integer as 3rd argument, but given: "world"; other arguments were: "hello" 2');
+
+ queueErrorTest("test substring with index out of bounds",
+ "(substring \"thing\" 0 53)",
+ 'substring: ending index 53 out of range [0, 5] for string: "thing"');
+
+
+ //string-append
+
+ queueErrorTest("test string-append with first argument not a string",
+ "(string-append 1 \"2\")",
+ 'string-append: expects a string as 1st argument, but given: 1; other arguments were: "2"');
+
+ queueErrorTest("test string-append with an argument not a string",
+ "(string-append \"1\" \"2\" \"3\" \"4\" 5)",
+ 'string-append: expects a string as 5th argument, but given: 5; other arguments were: "1" "2" "3" "4"');
+
+ //string->list
+
+ queueErrorTest("test string->list with wrong arity",
+ "(string->list)",
+ 'string->list: expects 1 argument, but given 0');
+
+ queueErrorTest("test string->list with first argument not a string",
+ "(string->list 2)",
+ 'string->list: expects a string as 1st argument, but given: 2');
+
+ //list->string
+
+ queueErrorTest("test list->string with first argument not a string",
+ "(list->string)",
+ 'list->string: expects 1 argument, but given 0');
+
+ queueErrorTest("test list->string with first argument not list of char",
+ "(list->string (list 1 2 3))",
+ 'list->string: expects a list of character as 1st argument, but given: (list 1 2 3)');
+
+ //string-copy
+
+ queueErrorTest("test string-copy with wrong arity",
+ "(string-copy)",
+ 'string-copy: expects 1 argument, but given 0');
+
+ queueErrorTest("test string-copy with 1st argument not string",
+ "(string-copy 2)",
+ 'string-copy: expects a string as 1st argument, but given: 2');
+
+ //string->symbol
+
+ queueErrorTest("test string->symbol with wrong arity",
+ "(string->symbol)",
+ 'string->symbol: expects 1 argument, but given 0');
+
+ queueErrorTest("test string->symbol with 1st argument not string",
+ "(string->symbol 2)",
+ 'string->symbol: expects a string as 1st argument, but given: 2');
+
+ //symbol->string
+
+ queueErrorTest("test symbol->string with wrong arity",
+ "(symbol->string)",
+ 'symbol->string: expects 1 argument, but given 0');
+
+ queueErrorTest("test symbol->string with 1st argument not string",
+ "(symbol->string 2)",
+ 'symbol->string: expects a symbol as 1st argument, but given: 2');
+
+ //format
+
+ queueErrorTest("test format with wrong arity",
+ "(format)",
+ 'format: expects at least 1 argument, but given 0');
+
+ queueErrorTest("test format with 1st argument not string",
+ "(format 1)",
+ 'format: expects a string as 1st argument, but given: 1');
+
+ //printf
+
+ queueErrorTest("test bad inputs to big-bang",
+ "(big-bang 1 on-tick add1)",
+ "big-bang: expects a handler as 2nd argument, but given: #; other arguments were: 1 #");
+
+ queueErrorTest("too many arguments",
+ "(define (f x) (* x x)) (f 3 4)",
+ "f: expects 1 argument, but given 2: 3 4");
+
+ queueErrorTest("test printf with wrong arity",
+ "(printf)",
+ 'printf: expects at least 1 argument, but given 0');
+
+ queueErrorTest("test printf with 1st argument not string",
+ "(printf 1)",
+ 'printf: expects a string as 1st argument, but given: 1');
+
+ //string->int
+
+ queueErrorTest("test string->int with wrong arity",
+ "(string->int)",
+ 'string->int: expects 1 argument, but given 0');
+
+ queueErrorTest("test string->int with 1st argument not string",
+ "(string->int 1)",
+ 'string->int: expects a 1-letter string as 1st argument, but given: 1');
+
+ queueErrorTest("test string->int with 1st argument not 1-letter string",
+ "(string->int \"23\")",
+ 'string->int: expects a 1-letter string as 1st argument, but given: "23"');
+
+ //int->string
+
+ queueErrorTest("test int->string with wrong arity",
+ "(int->string)",
+ 'int->string: expects 1 argument, but given 0');
+
+ queueErrorTest("test int->string with 1st argument not exact integer",
+ "(int->string \"1\")",
+ 'int->string: expects an exact integer in [0,55295] or [57344,1114111] as 1st argument, but given: "1"');
+
+ //explode
+
+ queueErrorTest("explode with wrong arity",
+ "(explode)",
+ 'explode: expects 1 argument, but given 0');
+
+ queueErrorTest("test explode with 1st argument not string",
+ "(explode 123)",
+ 'explode: expects a string as 1st argument, but given: 123');
+
+ //implode
+
+ queueErrorTest("implode with wrong arity",
+ "(implode)",
+ 'implode: expects 1 argument, but given 0');
+
+ queueErrorTest("test implode with 1st argument not list of 1-letter strings",
+ "(implode \"h235s\")",
+ 'implode: expects a list of 1-letter strings as 1st argument, but given: "h235s"');
+
+ //string-alphabetic?
+
+ queueErrorTest("string-alphabetic? with wrong arity",
+ "(string-alphabetic?)",
+ 'string-alphabetic?: expects 1 argument, but given 0');
+
+ queueErrorTest("string-alphabetic? 1st argument not string",
+ "(string-alphabetic? 123)",
+ 'string-alphabetic?: expects a string as 1st argument, but given: 123');
+
+ //string-ith
+
+ queueErrorTest("string-ith with wrong arity",
+ "(string-ith)",
+ 'string-ith: expects 2 arguments, but given 0');
+
+ queueErrorTest("string-ith 1st argument not string",
+ "(string-ith 1 2)",
+ 'string-ith: expects a string as 1st argument, but given: 1; other arguments were: 2');
+
+ queueErrorTest("string-ith 2nd argument not exact integer",
+ "(string-ith \"hello\" 1.5)",
+ 'string-ith: expects an exact integer in [0, length of the given string minus 1 (4)] as 2nd argument, but given: 3/2; other arguments were: "hello"');
+
+ queueErrorTest("string-ith index out of bounds",
+ "(string-ith \"hello\" 5)",
+ 'string-ith: expects an exact integer in [0, length of the given string minus 1 (4)] as 2nd argument, but given: 5; other arguments were: "hello"');
+
+ //string-lower-case?
+
+ queueErrorTest("string-lower-case? with wrong arity",
+ "(string-lower-case?)",
+ 'string-lower-case?: expects 1 argument, but given 0');
+
+ queueErrorTest("string-lower-case? with 1st argument not string",
+ "(string-lower-case? 2)",
+ 'string-lower-case?: expects a string as 1st argument, but given: 2');
+
+ //string-numeric?
+
+ queueErrorTest("string-numeric? with wrong arity",
+ "(string-numeric?)",
+ 'string-numeric?: expects 1 argument, but given 0');
+
+ queueErrorTest("tring-numeric? with 1st argument not string",
+ "(string-numeric? 2)",
+ 'string-numeric?: expects a string as 1st argument, but given: 2');
+
+
+ //string-upper-case?
+
+ queueErrorTest("string-upper-case? with wrong arity",
+ "(string-upper-case?)",
+ 'string-upper-case?: expects 1 argument, but given 0');
+
+ queueErrorTest("string-upper-case? with 1st argument not string",
+ "(string-upper-case? 2)",
+ 'string-upper-case?: expects a string as 1st argument, but given: 2');
+ //string-whitespace?
+
+ queueErrorTest("string-whitespace? with wrong arity",
+ "(string-whitespace?)",
+ 'string-whitespace?: expects 1 argument, but given 0');
+
+ queueErrorTest("string-whitespace? with 1st argument not string",
+ "(string-whitespace? 2)",
+ 'string-whitespace?: expects a string as 1st argument, but given: 2');
+
+ //build-string
+
+ queueErrorTest("build-string with wrong arity",
+ "(build-string)",
+ 'build-string: expects 2 arguments, but given 0');
+
+ queueErrorTest("build-string? with 1st argument not non-negative exact integer",
+ "(build-string \"hello\" 2)",
+ 'build-string: expects a non-negative exact integer as 1st argument, but given: "hello"; other arguments were: 2');
+
+ queueErrorTest("build-string? with 2nd argument not a proc",
+ "(build-string 5 \"hello\")",
+ 'build-string: expects a function name as 2nd argument, but given: "hello"; other arguments were: 5');
+
+ //string->immutable-string DNE
+
+ //string-set! DNE
+
+ //string-fill! DNE
+
+ /*PRIMITIVES['make-bytes'] =
+
+ PRIMITIVES['bytes'] =
+
+ PRIMITIVES['bytes->immutable-bytes'] =
+
+ PRIMITIVES['bytes-length'] =
+
+ PRIMITIVES['bytes-ref'] =
+
+ PRIMITIVES['bytes-set!'] =
+
+ PRIMITIVES['subbytes'] =
+
+ PRIMITIVES['bytes-copy'] =
+
+ PRIMITIVES['bytes-fill!'] =
+
+ PRIMITIVES['bytes-append'] =
+
+ PRIMITIVES['bytes->list'] =
+
+ PRIMITIVES['list->bytes'] =
+
+ PRIMITIVES['bytes=?'] =
+
+ PRIMITIVES['bytes?'] = ALL DNE */
+
+ //PRIMITIVES['make-vector']
+
+ queueErrorTest("make-vector with wrong arity",
+ "(make-vector)",
+ 'make-vector: expects 2 arguments, but given 0');
+
+ queueErrorTest("make-vector with 1st argument not non-negative exact integer",
+ "(make-vector \"size\" 2)",
+ 'make-vector: expects a non-negative exact integer as 1st argument, but given: "size"; other arguments were: 2');
+
+ //PRIMITIVES['vector']
+
+ //PRIMITIVES['vector-length']
+
+ queueErrorTest("vector-length with wrong arity",
+ "(vector-length)",
+ 'vector-length: expects 1 argument, but given 0');
+
+ queueErrorTest("vector-length with 1st argument not vector",
+ "(vector-length 1)",
+ 'vector-length: expects a vector as 1st argument, but given: 1');
+
+ //PRIMITIVES['vector-ref']
+
+ queueErrorTest("vector-ref with wrong arity",
+ "(vector-ref)",
+ 'vector-ref: expects 2 arguments, but given 0');
+
+ queueErrorTest("vector-ref with 1st argument not vector",
+ "(vector-ref 1 2)",
+ 'vector-ref: expects a vector as 1st argument, but given: 1; other arguments were: 2');
+
+ queueErrorTest("vector-ref with 2nd argument not non-negative ",
+ "(vector-ref (make-vector 1) 2.2)",
+ 'make-vector: expects 2 arguments, but given 1: 1');
+
+ queueErrorTest("vector-ref with index out of bounds",
+ "(vector-ref (vector 1) 7)",
+ 'vector-ref: index 7 out of range [0, 0] for vector: #(1)');
+
+ //PRIMITIVES['vector-set!']
+
+ queueErrorTest("vector-set! with wrong arity",
+ "(vector-set! )",
+ 'vector-set!: expects 3 arguments, but given 0');
+
+ queueErrorTest("vector-length with 1st argument not vector",
+ "(vector-length 1)",
+ 'vector-length: expects a vector as 1st argument, but given: 1');
+
+
+ //PRIMITIVES['vector->list']
+
+ queueErrorTest("vector->list with wrong arity",
+ "(vector->list)",
+ 'vector->list: expects 1 argument, but given 0');
+
+ queueErrorTest("vector->list with 1st argument not vector",
+ "(vector->list 1)",
+ 'vector->list: expects a vector as 1st argument, but given: 1');
+
+ //PRIMITIVES['list->vector']
+
+ queueErrorTest("build-vector with wrong arity",
+ "(build-vector)",
+ 'build-vector: expects 2 arguments, but given 0');
+
+ queueErrorTest("list->vector with 1st argument not vector",
+ "(list->vector 1)",
+ 'list->vector: expects a list as 1st argument, but given: 1');
+
+ //PRIMITIVES['build-vector']
+
+ queueErrorTest("build-vector with wrong arity",
+ "(build-vector)",
+ 'build-vector: expects 2 arguments, but given 0');
+
+ queueErrorTest("build-vector with 1st argument not non-negative exact integer",
+ "(build-vector \"hello\" 2)",
+ 'build-vector: expects a non-negative exact integer as 1st argument, but given: "hello"; other arguments were: 2');
+
+ queueErrorTest("build-vector with 2nd argument not a proc",
+ "(build-vector \"hello\" 2)",
+ 'build-vector: expects a non-negative exact integer as 1st argument, but given: "hello"; other arguments were: 2');
+
+
+ //PRIMITIVES['char=?']
+
+ queueErrorTest("char=? with wrong arity",
+ "(char=?)",
+ 'char=?: expects at least 2 arguments, but given 0');
+
+ queueErrorTest("char=? with 1st argument not char",
+ '(char=? "hello")',
+ 'char=?: expects at least 2 arguments, but given 1: hello');
+
+ //PRIMITIVES['char; other arguments were: #\\a');
+
+ queueErrorTest("char; other arguments were: #\\a');
+
+ //PRIMITIVES['char>?']
+
+ queueErrorTest("char>? with wrong arity",
+ "(char>?)",
+ 'char>?: expects at least 2 arguments, but given 0');
+
+ queueErrorTest("char>? with 1st argument not char",
+ "(char>? add1 #\\a)",
+ 'char>?: expects a character as 1st argument, but given: #; other arguments were: #\\a');
+
+ queueErrorTest("char>? with 2nd argument not char",
+ "(char>? #\\a add1)",
+ 'char>?: expects a character as 2nd argument, but given: #; other arguments were: #\\a');
+
+ //PRIMITIVES['char<=?']
+
+ queueErrorTest("char<=? with wrong arity",
+ "(char<=?)",
+ 'char<=?: expects at least 2 arguments, but given 0');
+
+ queueErrorTest("char<=? with 1st argument not char",
+ "(char<=? add1 #\\a)",
+ 'char<=?: expects a character as 1st argument, but given: #; other arguments were: #\\a');
+
+ queueErrorTest("char<=? with 2nd argument not char",
+ "(char<=? #\\a add1)",
+ 'char<=?: expects a character as 2nd argument, but given: #; other arguments were: #\\a');
+
+ //PRIMITIVES['char>=?']
+
+ queueErrorTest("char>=? with wrong arity",
+ "(char>=?)",
+ 'char>=?: expects at least 2 arguments, but given 0');
+
+ queueErrorTest("char>=? with 1st argument not char",
+ "(char>=? add1 #\\a)",
+ 'char>=?: expects a character as 1st argument, but given: #; other arguments were: #\\a');
+
+ queueErrorTest("char>=? with 2nd argument not char",
+ "(char>=? #\\a add1)",
+ 'char>=?: expects a character as 2nd argument, but given: #; other arguments were: #\\a');
+
+
+ //PRIMITIVES['char-ci=?']
+
+ queueErrorTest("char-ci=? with wrong arity",
+ "(char-ci=?)",
+ 'char-ci=?: expects at least 2 arguments, but given 0');
+
+ queueErrorTest("char-ci=? with 1st argument not char",
+ "(char-ci=? add1 #\\a)",
+ 'char-ci=?: expects a character as 1st argument, but given: #; other arguments were: #\\a');
+
+ queueErrorTest("char-ci=? with 2nd argument not char",
+ "(char-ci=? #\\a add1)",
+ 'char-ci=?: expects a character as 2nd argument, but given: #; other arguments were: #\\a');
+
+
+ //PRIMITIVES['char-ci; other arguments were: #\\a');
+
+ queueErrorTest("char-ci; other arguments were: #\\a');
+
+ //PRIMITIVES['char-ci>?']
+
+ queueErrorTest("char-ci>? with wrong arity",
+ "(char-ci>?)",
+ 'char-ci>?: expects at least 2 arguments, but given 0');
+
+ queueErrorTest("char-ci>? with 1st argument not char",
+ "(char-ci>? add1 #\\a)",
+ 'char-ci>?: expects a character as 1st argument, but given: #; other arguments were: #\\a');
+
+ queueErrorTest("char-ci>? with 2nd argument not char",
+ "(char-ci>? #\\a add1)",
+ 'char-ci>?: expects a character as 2nd argument, but given: #; other arguments were: #\\a');
+
+ //PRIMITIVES['char-ci<=?']
+
+ queueErrorTest("char-ci<=? with wrong arity",
+ "(char-ci<=?)",
+ 'char-ci<=?: expects at least 2 arguments, but given 0');
+
+ queueErrorTest("char-ci<=? with 1st argument not char",
+ "(char-ci<=? add1 #\\a)",
+ 'char-ci<=?: expects a character as 1st argument, but given: #; other arguments were: #\\a');
+
+ queueErrorTest("char-ci<=? with 2nd argument not char",
+ "(char-ci<=? #\\a add1)",
+ 'char-ci<=?: expects a character as 2nd argument, but given: #; other arguments were: #\\a');
+
+ //PRIMITIVES['char-ci>=?']
+
+ queueErrorTest("char-ci>=? with wrong arity",
+ "(char-ci>=?)",
+ 'char-ci>=?: expects at least 2 arguments, but given 0');
+
+ queueErrorTest("char-ci>=? with 1st argument not char",
+ "(char-ci>=? add1 #\\a)",
+ 'char-ci>=?: expects a character as 1st argument, but given: #; other arguments were: #\\a');
+
+ queueErrorTest("char-ci>=? with 2nd argument not char",
+ "(char-ci>=? #\\a add1)",
+ 'char-ci>=?: expects a character as 2nd argument, but given: #; other arguments were: #\\a');
+
+ //PRIMITIVES['char-alphabetic?']
+
+ queueErrorTest("char-alphabetic? with wrong arity",
+ "(char-alphabetic?)",
+ 'char-alphabetic?: expects 1 argument, but given 0');
+
+ queueErrorTest("char-alphabetic? with 1st argument not char",
+ "(char-alphabetic? add1)",
+ 'char-alphabetic?: expects a character as 1st argument, but given: #');
+
+ //PRIMITIVES['char-numeric?']
+
+ queueErrorTest("char-numeric? with wrong arity",
+ "(char-numeric?)",
+ 'char-numeric?: expects 1 argument, but given 0');
+
+ queueErrorTest("char-numeric? with 1st argument not char",
+ "(char-numeric? add1)",
+ 'char-numeric?: expects a character as 1st argument, but given: #');
+
+ //PRIMITIVES['char-whitespace?']
+
+ queueErrorTest("char-whitespace? with wrong arity",
+ "(char-whitespace?)",
+ 'char-whitespace?: expects 1 argument, but given 0');
+
+ queueErrorTest("char-whitespace? with 1st argument not char",
+ "(char-whitespace? add1)",
+ 'char-whitespace?: expects a character as 1st argument, but given: #');
+
+ //PRIMITIVES['char-upper-case?']
+
+ queueErrorTest("char-upper-case? with wrong arity",
+ "(char-upper-case?)",
+ 'char-upper-case?: expects 1 argument, but given 0');
+
+ queueErrorTest("char-upper-case? with 1st argument not char",
+ "(char-upper-case? add1)",
+ 'char-upper-case?: expects a character as 1st argument, but given: #');
+
+ //PRIMITIVES['char-lower-case?']
+
+ queueErrorTest("char-lower-case? with wrong arity",
+ "(char-lower-case?)",
+ 'char-lower-case?: expects 1 argument, but given 0');
+
+ queueErrorTest("char-lower-case? with 1st argument not char",
+ "(char-lower-case? add1)",
+ 'char-lower-case?: expects a character as 1st argument, but given: #');
+
+ //PRIMITIVES['char->integer']
+
+ queueErrorTest("char->integer with wrong arity",
+ "(char->integer)",
+ 'char->integer: expects 1 argument, but given 0');
+
+ queueErrorTest("char->integer with 1st argument not char",
+ "(char->integer add1)",
+ 'char->integer: expects a character as 1st argument, but given: #');
+
+ //PRIMITIVES['integer->char']
+
+ queueErrorTest("integer->char with wrong arity",
+ "(integer->char)",
+ 'integer->char: expects 1 argument, but given 0');
+
+ queueErrorTest("integer->char with 1st argument not integer",
+ "(integer->char add1)",
+ 'integer->char: expects an exact integer in [0,#x10FFFF], not in [#xD800,#xDFFF] as 1st argument, but given: #');
+ //perhaps change the error message so hex does not show
+
+ //PRIMITIVES['char-upcase']
+
+ queueErrorTest("char-upcaser with wrong arity",
+ "(char-upcase)",
+ 'char-upcase: expects 1 argument, but given 0');
+
+ queueErrorTest("char-upcase with 1st argument not char",
+ "(char-upcase add1)",
+ 'char-upcase: expects a character as 1st argument, but given: #');
+
+ //PRIMITIVES['char-downcase']
+
+ queueErrorTest("char-downcase with wrong arity",
+ "(char-downcase)",
+ 'char-downcase: expects 1 argument, but given 0');
+
+ queueErrorTest("char-downcase with 1st argument not char",
+ "(char-downcase add1)",
+ 'char-downcase: expects a character as 1st argument, but given: #');
+
+ //PRIMITIVES['make-posn']
+
+ queueErrorTest("make-posn with wrong arity",
+ "(make-posn)",
+ 'make-posn: expects 2 arguments, but given 0');
+
+ //PRIMITIVES['posn-x']
+
+ queueErrorTest("posn-x with wrong arity",
+ "(posn-x)",
+ 'posn-x: expects 1 argument, but given 0');
+
+ queueErrorTest("posn-x with 1st argument not posn",
+ "(posn-x add1)",
+ 'posn-x: expects a posn as 1st argument, but given: #');
+
+ //PRIMITIVES['posn-y']
+
+ queueErrorTest("posn-y with wrong arity",
+ "(posn-y)",
+ 'posn-y: expects 1 argument, but given 0');
+
+ queueErrorTest("posn-y with 1st argument not posn",
+ "(posn-y add1)",
+ 'posn-y: expects a posn as 1st argument, but given: #');
+
+ //PRIMITIVES['key=?']
+
+ queueErrorTest("key=? with wrong arity",
+ "(key=?)",
+ 'key=?: expects 2 arguments, but given 0');
+
+ //PRIMITIVES['image?']
+
+ queueErrorTest("image? with wrong arity",
+ "(image?)",
+ 'image?: expects 1 argument, but given 0');
+
+ //PRIMITIVES['make-color']
+
+ queueErrorTest("make-color with wrong arity",
+ "(make-color)",
+ 'make-color: expects 3 or 4 arguments, but given 0');
+
+ queueErrorTest("make-color with 1st argument not a number between 0 and 255",
+ "(make-color 256 1 2 3)",
+ 'make-color: expects a number between 0 and 255 as 1st argument, but given: 256; other arguments were: 1 2 3');
+
+ queueErrorTest("make-color with 2nd argument not a number between 0 and 255",
+ "(make-color 255 256 2 3)",
+ 'make-color: expects a number between 0 and 255 as 2nd argument, but given: 256; other arguments were: 255 2 3');
+
+
+ queueErrorTest("make-color with 3rd argument not a number between 0 and 255",
+ "(make-color 255 255 256 3)",
+ 'make-color: expects a number between 0 and 255 as 3rd argument, but given: 256; other arguments were: 255 255 3');
+
+ queueErrorTest("make-color with 4th argument not a number between 0 and 255",
+ "(make-color 255 255 255 256)",
+ 'make-color: expects a number between 0 and 255 as 4th argument, but given: 256; other arguments were: 255 255 255');
+
+ //PRIMITIVES['color-red']
+
+ queueErrorTest("color-red with wrong arity",
+ "(color-red)",
+ 'color-red: expects 1 argument, but given 0');
+
+ queueErrorTest("color-red with 1st argument not color",
+ "(color-red add1)",
+ 'color-red: expects a color as 1st argument, but given: #');
+
+ //PRIMITIVES['color-green']
+
+ queueErrorTest("color-green with wrong arity",
+ "(color-green)",
+ 'color-green: expects 1 argument, but given 0');
+
+ queueErrorTest("color-green with 1st argument not color",
+ "(color-green add1)",
+ 'color-green: expects a color as 1st argument, but given: #');
+
+ //PRIMITIVES['color-blue']
+
+ queueErrorTest("color-blue with wrong arity",
+ "(color-blue)",
+ 'color-blue: expects 1 argument, but given 0');
+
+ queueErrorTest("color-blue with 1st argument not color",
+ "(color-blue add1)",
+ 'color-blue: expects a color as 1st argument, but given: #');
+
+ //PRIMITIVES['color-alpha']
+
+ queueErrorTest("color-alpha with wrong arity",
+ "(color-alpha)",
+ 'color-alpha: expects 1 argument, but given 0');
+
+ queueErrorTest("color-alpha with 1st argument not color",
+ "(color-alpha add1)",
+ 'color-alpha: expects a color as 1st argument, but given: #');
+
+
+ //PRIMITIVES['empty-scene']
+
+ queueErrorTest("empty-scene with wrong arity",
+ "(empty-scene)",
+ 'empty-scene: expects 2 arguments, but given 0');
+
+ queueErrorTest("empty-scene with 1st argument not non-negative number",
+ "(empty-scene add1 2)",
+ 'empty-scene: expects a non-negative number as 1st argument, but given: #; other arguments were: 2');
+
+ queueErrorTest("empty-scene with 2nd argument not non-negative number",
+ "(empty-scene 0 add1)",
+ 'empty-scene: expects a non-negative number as 2nd argument, but given: #; other arguments were: 0');
+
+ //PRIMITIVES['place-image']
+
+ queueErrorTest("empty-scene with wrong arity",
+ "(empty-scene)",
+ 'empty-scene: expects 2 arguments, but given 0');
+
+ queueErrorTest("empty-scene with 1st argument not non-negative number",
+ "(empty-scene add1 2)",
+ 'empty-scene: expects a non-negative number as 1st argument, but given: #; other arguments were: 2');
+
+ queueErrorTest("empty-scene with 2nd argument not non-negative number",
+ "(empty-scene 0 add1)",
+ 'empty-scene: expects a non-negative number as 2nd argument, but given: #; other arguments were: 0');
+
+ //PRIMITIVES['place-image/align']
+
+ queueErrorTest("place-image/align with wrong arity",
+ "(place-image/align)",
+ 'place-image/align: expects 6 arguments, but given 0');
+
+ queueErrorTest("place-image/align with 1st argument not image",
+ "(place-image/align add1 2 3 4 5 6)",
+ 'place-image/align: expects an image as 1st argument, but given: #; other arguments were: 2 3 4 5 6');
+
+ queueErrorTest("place-image/align with 2nd argument not real number",
+ "(place-image/align (circle 50 \"solid\" \"red\") \"hello\" 3 4 5 6)",
+ 'place-image/align: expects a real number as 2nd argument, but given: "hello"; other arguments were: 3 4 5 6');
+
+ queueErrorTest("place-image/align with 3rd argument not real number",
+ "(place-image/align (circle 50 \"solid\" \"red\") 2 \"hello\" 4 5 6)",
+ 'place-image/align: expects a real number as 3rd argument, but given: "hello"; other arguments were: 2 4 5 6');
+
+ queueErrorTest("place-image/align with 4th argument not x-place",
+ "(place-image/align (circle 50 \"solid\" \"red\") 2 3 (make-posn 2 3) 5 6)",
+ 'place-image/align: expects a x-place as 4th argument, but given: (posn 2 3); other arguments were: 2 3 5 6');
+
+ queueErrorTest("place-image/alignwith 5th argument not y-place",
+ "(place-image/align (circle 50 \"solid\" \"red\") 2 3 \"left\" 5 6)",
+ 'place-image/align: expects a y-place as 5th argument, but given: 5; other arguments were: 2 3 "left" 6');
+
+ queueErrorTest("place-image/align with 6th argument not image",
+ "(place-image/align (circle 50 \"solid\" \"red\") 2 3 \"left\" \"top\" add1)",
+ 'place-image/align: expects an image as 6th argument, but given: #; other arguments were: 2 3 "left" "top"');
+
+ //PRIMITIVES['scene+line']
+
+ queueErrorTest("scene+line with wrong arity",
+ "(scene+line)",
+ 'scene+line: expects 6 arguments, but given 0');
+
+ //PRIMITIVES['circle']
+
+ queueErrorTest("circle with wrong arity",
+ "(circle)",
+ 'circle: expects 3 arguments, but given 0');
+
+ queueErrorTest("circle with 1st argument not non-negative number",
+ "(circle \"foo\" 2 3)",
+ 'circle: expects a non-negative number as 1st argument, but given: "foo"; other arguments were: 2 3');
+
+ queueErrorTest("circle with 2nd argument not style",
+ "(circle 1 true 3)",
+ 'circle: expects a style ("solid" or "outline" or [0-255]) as 2nd argument, but given: true; other arguments were: 1 3');
+
+ queueErrorTest("circle with 3rd argument not colour",
+ "(circle 1 \"solid\" add1)",
+ 'circle: expects a color as 3rd argument, but given: #; other arguments were: 1 "solid"');
+
+ //PRIMITIVES['star']
+
+ queueErrorTest("star with wrong arity",
+ "(star)",
+ 'star: expects 5 or 3 arguments, but given 0');
+
+ queueErrorTest("star with 1st argument not non-negative number",
+ "(star \"hello\" 2 3)",
+ 'star: expects a non-negative number as 1st argument, but given: "hello"; other arguments were: 2 3');
+
+ queueErrorTest("star with 2nd argument not style",
+ "(star 1 \"moo\" 3)",
+ 'star: expects a style ("solid" or "outline" or [0-255]) as 2nd argument, but given: "moo"; other arguments were: 1 3');
+
+ queueErrorTest("star with 3rd argument not colour",
+ "(star 1 \"solid\" add1)",
+ 'star: expects a color as 3rd argument, but given: #; other arguments were: 1 "solid"');
+
+ //PRIMITIVES['radial-star']
+
+ queueErrorTest("radial-star with wrong arity",
+ "(radial-star)",
+ 'radial-star: expects 5 arguments, but given 0');
+
+ queueErrorTest("radial-star with 1st argument not positive integer greater than or equal to 2",
+ "(radial-star 1 2 3 4 5)",
+ 'radial-star: expects a positive integer greater than or equal to 2 as 1st argument, but given: 1; other arguments were: 2 3 4 5');
+
+ queueErrorTest("star with 2nd argument not positive number",
+ "(radial-star 5 \"foo\" 3 4 5)",
+ 'radial-star: expects a positive number as 2nd argument, but given: "foo"; other arguments were: 5 3 4 5');
+
+ queueErrorTest("star with 3rd argument not positive number",
+ "(radial-star 5 4 \"foo\" 4 5)",
+ 'radial-star: expects a positive number as 3rd argument, but given: "foo"; other arguments were: 5 4 4 5');
+
+ queueErrorTest("star with 4th argument not style",
+ "(radial-star 5 4 2 \"foo\" 5)",
+ 'radial-star: expects a style ("solid" or "outline" or [0-255]) as 4th argument, but given: "foo"; other arguments were: 5 4 2 5');
+
+ queueErrorTest("star with 5th argument not colour",
+ "(radial-star 5 4 2 \"solid\" \"foo\")",
+ 'radial-star: expects a color as 5th argument, but given: "foo"; other arguments were: 5 4 2 "solid"');
+
+ // PRIMITIVES['rectangle']
+
+ queueErrorTest("rectangle wrong arity",
+ "(rectangle)",
+ 'rectangle: expects 4 arguments, but given 0');
+
+ queueErrorTest("rectangle with 1st argument non-negative number",
+ "(rectangle \"foo\" 2 3 4)",
+ 'rectangle: expects a non-negative number as 1st argument, but given: "foo"; other arguments were: 2 3 4');
+
+ queueErrorTest("rectangle with 2nd argument not non-negative number",
+ "(rectangle 2 \"foo\" 3 4)",
+ 'rectangle: expects a non-negative number as 2nd argument, but given: "foo"; other arguments were: 2 3 4');
+
+ queueErrorTest("rectangle with 3rd argument not style",
+ "(rectangle 2 5 add1 4)",
+ 'rectangle: expects a style ("solid" or "outline" or [0-255]) as 3rd argument, but given: #; other arguments were: 2 5 4');
+
+ queueErrorTest("rectangle with 4th argument not colour",
+ "(rectangle 2 5 \"outline\" \"focus\")",
+ 'rectangle: expects a color as 4th argument, but given: "focus"; other arguments were: 2 5 "outline"');
+
+ // PRIMITIVES['regular-polygon']
+
+ queueErrorTest("regular-polygon wrong arity",
+ "(regular-polygon)",
+ 'regular-polygon: expects 4 arguments, but given 0');
+
+ queueErrorTest("rectangle with 1st argument not non-negative number",
+ "(regular-polygon \"foo\" 2 3 4)",
+ 'regular-polygon: expects a non-negative number as 1st argument, but given: "foo"; other arguments were: 2 3 4');
+
+ queueErrorTest("rectangle with 2nd argument not positive integer greater than or equal to 3",
+ "(regular-polygon 2 \"foo\" 3 4)",
+ 'regular-polygon: expects a positive integer greater than or equal to 3 as 2nd argument, but given: "foo"; other arguments were: 2 3 4');
+
+ queueErrorTest("regular-polygon with 3rd argument not style",
+ "(regular-polygon 2 5 add1 4)",
+ 'regular-polygon: expects a style ("solid" or "outline" or [0-255]) as 3rd argument, but given: #; other arguments were: 2 5 4');
+
+ queueErrorTest("regular-polygonwith 4th argument not colour",
+ "(regular-polygon 2 5 \"outline\" \"focus\")",
+ 'regular-polygon: expects a color as 4th argument, but given: "focus"; other arguments were: 2 5 "outline"');
+
+ // PRIMITIVES['star-polygon']
+
+ queueErrorTest("star-polygon wrong arity",
+ "(star-polygon)",
+ 'star-polygon: expects 5 arguments, but given 0');
+
+ queueErrorTest("star-polygon with 1st argument not non-negative number",
+ "(star-polygon \"foo\" 2 3 4 5)",
+ 'star-polygon: expects a non-negative number as 1st argument, but given: "foo"; other arguments were: 2 3 4 5');
+
+ queueErrorTest("star-polygon with 2nd argument not positive integer greater than or equal to 3",
+ "(star-polygon 2 \"foo\" 3 4 5)",
+ 'star-polygon: expects a positive integer greater than or equal to 3 as 2nd argument, but given: "foo"; other arguments were: 2 3 4 5');
+
+ queueErrorTest("star-polygon with 3rd argument not positive integer greater than or equal to 1",
+ "(star-polygon 2 5 add1 4 5)",
+ 'star-polygon: expects a positive integer greater than or equal to 1 as 3rd argument, but given: #; other arguments were: 2 5 4 5');
+
+ queueErrorTest("star-polygon with 4th argument not style",
+ "(star-polygon 2 5 5 add1 5)",
+ 'star-polygon: expects a style ("solid" or "outline" or [0-255]) as 4th argument, but given: #; other arguments were: 2 5 5 5');
+
+ queueErrorTest("star-polygon with 5th argument not colour",
+ "(star-polygon 2 5 5 \"outline\" \"focus\")",
+ 'star-polygon: expects a color as 5th argument, but given: "focus"; other arguments were: 2 5 5 "outline"');
+
+ // PRIMITIVES['rhombus']
+
+ queueErrorTest("rhombus wrong arity",
+ "(rhombus)",
+ 'rhombus: expects 4 arguments, but given 0');
+
+ queueErrorTest("rhombus with 1st argument non-negative number",
+ "(rhombus \"foo\" 2 3 4)",
+ 'rhombus: expects a non-negative number as 1st argument, but given: "foo"; other arguments were: 2 3 4');
+
+ queueErrorTest("star with 2nd argument not non-negative number",
+ "(rhombus 2 \"foo\" 3 4)",
+ 'rhombus: expects a non-negative number as 2nd argument, but given: "foo"; other arguments were: 2 3 4');
+
+ queueErrorTest("rhombus with 3rd argument not style",
+ "(rhombus 2 5 add1 4)",
+ 'rhombus: expects a style ("solid" or "outline" or [0-255]) as 3rd argument, but given: #; other arguments were: 2 5 4');
+
+ queueErrorTest("rhombus with 4th argument not colour",
+ "(rhombus 2 5 \"outline\" \"focus\")",
+ 'rhombus: expects a color as 4th argument, but given: "focus"; other arguments were: 2 5 "outline"');
+
+
+ // PRIMITIVES['square']
+
+ queueErrorTest("square wrong arity",
+ "(square)",
+ 'square: expects 3 arguments, but given 0');
+
+ queueErrorTest("square with 1st argument non-negative number",
+ "(square \"foo\" 3 4)",
+ 'square: expects a non-negative number as 1st argument, but given: "foo"; other arguments were: 3 4');
+
+ queueErrorTest("square with 2nd argument not style",
+ "(square 2 add1 4)",
+ 'square: expects a style ("solid" or "outline" or [0-255]) as 2nd argument, but given: #; other arguments were: 2 4');
+
+ queueErrorTest("square with 3rd argument not colour",
+ "(square 2 \"outline\" \"focus\")",
+ 'square: expects a color as 3rd argument, but given: "focus"; other arguments were: 2 "outline"');
+
+ // PRIMITIVES['triangle']
+
+ queueErrorTest("triangle wrong arity",
+ "(triangle)",
+ 'triangle: expects 3 arguments, but given 0');
+
+ queueErrorTest("triangle with 1st argument non-negative number",
+ "(triangle \"foo\" 3 4)",
+ 'triangle: expects a non-negative number as 1st argument, but given: "foo"; other arguments were: 3 4');
+
+ queueErrorTest("triangle with 2nd argument not style",
+ "(triangle 2 add1 4)",
+ 'triangle: expects a style ("solid" or "outline" or [0-255]) as 2nd argument, but given: #; other arguments were: 2 4');
+
+ queueErrorTest("triangle with 3rd argument not colour",
+ "(triangle 2 \"outline\" \"focus\")",
+ 'triangle: expects a color as 3rd argument, but given: "focus"; other arguments were: 2 "outline"');
+
+ // PRIMITIVES['right-triangle']
+
+ queueErrorTest("right-triangle wrong arity",
+ "(right-triangle)",
+ 'right-triangle: expects 4 arguments, but given 0');
+
+ queueErrorTest("right-triangle with 1st argument non-negative number",
+ "(right-triangle \"foo\" 3 4 3)",
+ 'right-triangle: expects a non-negative number as 1st argument, but given: "foo"; other arguments were: 3 4 3');
+
+ queueErrorTest("right-triangle with 2nd argument non-negative number",
+ "(right-triangle 5 \"foo\" 3 4)",
+ 'right-triangle: expects a non-negative number as 2nd argument, but given: "foo"; other arguments were: 5 3 4');
+
+ queueErrorTest("right-triangle with 3rd argument not style",
+ "(right-triangle 2 4 add1 4)",
+ 'right-triangle: expects a style ("solid" or "outline" or [0-255]) as 3rd argument, but given: #; other arguments were: 2 4 4');
+
+ queueErrorTest("right-triangle with 4th argument not colour",
+ "(right-triangle 5 2 \"outline\" \"focus\")",
+ 'right-triangle: expects a color as 4th argument, but given: "focus"; other arguments were: 5 2 "outline"');
+
+ // PRIMITIVES['isosceles-triangle']
+
+
+ queueErrorTest("isosceles-triangle wrong arity",
+ "(isosceles-triangle)",
+ 'isosceles-triangle: expects 4 arguments, but given 0');
+
+ queueErrorTest("isosceles-triangle with 1st argument not non-negative number",
+ "(isosceles-triangle \"foo\" 3 4 3)",
+ 'isosceles-triangle: expects a non-negative number as 1st argument, but given: "foo"; other arguments were: 3 4 3');
+
+ queueErrorTest("isosceles-triangle with 2nd argument not finite real number between 0 and 360",
+ "(isosceles-triangle 5 \"foo\" 3 4)",
+ 'isosceles-triangle: expects a finite real number between 0 and 360 as 2nd argument, but given: "foo"; other arguments were: 5 3 4');
+
+ queueErrorTest("isosceles-triangle with 3rd argument not style",
+ "(isosceles-triangle 2 4 add1 4)",
+ 'isosceles-triangle: expects a style ("solid" or "outline" or [0-255]) as 3rd argument, but given: #; other arguments were: 2 4 4');
+
+ queueErrorTest("isosceles-triangle with 4th argument not colour",
+ "(isosceles-triangle 5 2 \"outline\" \"focus\")",
+ 'isosceles-triangle: expects a color as 4th argument, but given: "focus"; other arguments were: 5 2 "outline"');
+
+ // PRIMITIVES['ellipse']
+
+ queueErrorTest("ellipse wrong arity",
+ "(ellipse)",
+ 'ellipse: expects 4 arguments, but given 0');
+
+ queueErrorTest("ellipse with 1st argument not non-negative number",
+ "(ellipse \"foo\" 3 4 3)",
+ 'ellipse: expects a non-negative number as 1st argument, but given: "foo"; other arguments were: 3 4 3');
+
+ queueErrorTest("ellipse with 2nd argument not non-negative number",
+ "(ellipse 5 \"foo\" 3 4)",
+ 'ellipse: expects a non-negative number as 2nd argument, but given: "foo"; other arguments were: 5 3 4');
+
+ queueErrorTest("ellipse with 3rd argument not string",
+ "(ellipse 2 4 add1 4)",
+ 'ellipse: expects a style ("solid" or "outline" or [0-255]) as 3rd argument, but given: #; other arguments were: 2 4 4');
+
+ queueErrorTest("ellipse with 4th argument not colour",
+ "(ellipse 5 2 \"outline\" \"focus\")",
+ 'ellipse: expects a color as 4th argument, but given: "focus"; other arguments were: 5 2 "outline"');
+
+ // PRIMITIVES['line']
+
+ queueErrorTest("line wrong arity",
+ "(line)",
+ 'line: expects 3 arguments, but given 0');
+
+ queueErrorTest("line 1st argument not finite real",
+ "(line \"foo\" 3 4)",
+ 'line: expects a finite real number as 1st argument, but given: "foo"; other arguments were: 3 4');
+
+ queueErrorTest("line with 2nd argument not finite real",
+ "(line 5 \"foo\" 3)",
+ 'line: expects a finite real number as 2nd argument, but given: "foo"; other arguments were: 5 3');
+
+ queueErrorTest("line with 3rd argument not colour",
+ "(line 2 4 add1)",
+ 'line: expects a color as 3rd argument, but given: #; other arguments were: 2 4');
+
+
+
+
+ queueErrorTest("Redefinition",
+ "(define x 3) (define x 4)",
+ "x: this name has a previous definition and cannot be re-defined");
+
+
+
+ queueErrorTest("define as a bare expression",
+ "define",
+ "define: expected an open parenthesis before define, but found none");
+
+ queueErrorTest("if as a bare expression, but found none",
+ "if",
+ "if: expected an open parenthesis before if, but found none");
+
+ queueErrorTest("cond as a bare expression",
+ "cond",
+ "cond: expected an open parenthesis before cond, but found none");
+
+ queueErrorTest("case as a bare expression",
+ "case",
+ "case: expected an open parenthesis before case, but found none");
+
+ queueErrorTest("let as a bare expression",
+ "let",
+ "let: expected an open parenthesis before let, but found none");
+
+ queueErrorTest("let* as a bare expression",
+ "let*",
+ "let*: expected an open parenthesis before let*, but found none");
+
+ queueErrorTest("letrec as a bare expression",
+ "letrec",
+ "letrec: expected an open parenthesis before letrec, but found none");
+
+ queueErrorTest("quasiquote as a bare expression",
+ "quasiquote",
+ "quasiquote: expected an open parenthesis before quasiquote, but found none");
+ queueErrorTest("unquote as a bare expression",
+ "unquote",
+ "unquote: expected an open parenthesis before unquote, but found none");
+
+ queueErrorTest("unquote-splicing as a bare expression",
+ "unquote-splicing",
+ "unquote-splicing: expected an open parenthesis before unquote-splicing, but found none");
+
+ // FIXME: more quasiquote/unquote/unquote-splicing tests needed.
+
+ queueErrorTest("local as a bare expression",
+ "local",
+ "local: expected an open parenthesis before local, but found none");
+
+ queueErrorTest("begin as a bare expression",
+ "begin",
+ "begin: expected an open parenthesis before begin, but found none");
+ queueErrorTest("and as a bare expression",
+ "and",
+ "and: expected an open parenthesis before and, but found none");
+ queueErrorTest("or as a bare expression",
+ "or",
+ "or: expected an open parenthesis before or, but found none");
+ queueErrorTest("when as a bare expression",
+ "when",
+ "when: expected an open parenthesis before when, but found none");
+
+ queueErrorTest("unless as a bare expression",
+ "unless",
+ "unless: expected an open parenthesis before unless, but found none");
+
+ queueErrorTest("lambda as a bare expression",
+ "lambda",
+ "lambda: expected an open parenthesis before lambda, but found none");
+
+ queueErrorTest("lambda as a bare expression",
+ "λ",
+ "λ: expected an open parenthesis before λ, but found none");
+
+ queueErrorTest("quote as a bare expression",
+ "quote",
+ "quote: expected an open parenthesis before quote, but found none");
+
+
+
+
+
+
+
+
+ queueErrorTest("define with no args",
+ "(define)",
+ "define: expected a variable, or a function name and its variables (in parentheses), after define, but nothing's there");
+
+ queueErrorTest("define variable not given enough args",
+ "(define a)",
+ "define: expected an expression after the variable a but nothing's there");
+
+ queueErrorTest("define function not given enough args",
+ "(define (f x))",
+ "define: expected an expression for the function body, but nothing's there");
+
+ queueErrorTest("define given undefined variable",
+ "(define x y)",
+ "y: this variable is not defined");
+
+ queueErrorTest("define given empty parenthesis",
+ "(define ())",
+ "define: expected a name for the function within the parentheses");
+
+ queueErrorTest("define given empty parenthesis",
+ "(define 29)",
+ "define: expected a variable but found something else");
+
+
+
+ queueErrorTest("define given too many args",
+ "(define (x) 3 4 5)",
+ "define: expected only one expression for the function body, but found 2 extra parts");
+
+ queueErrorTest("define given bad function name",
+ "(define (\"x\") 3)",
+ "define: expected a function name after the open parenthesis but found something else");
+
+ queueErrorTest("define given bad arg",
+ "(define (x y 7) 3)",
+ "define: expected a variable but found something else");
+
+ queueErrorTest("define variable given too many args",
+ "(define x 1 2 3 4 5)",
+ "define: expected only one expression after the variable x, but found 4 extra parts");
+
+ queueErrorTest("define-struct given no args",
+ "(define-struct)",
+ "define-struct: expected the structure name after define-struct, but nothing's there");
+
+ queueErrorTest("define-struct given not enough args",
+ "(define-struct test)",
+ "define-struct: expected at least one field name (in parentheses) after the structure name, but nothing's there");
+
+ queueErrorTest("define-struct given empty parenthesis",
+ "(define-struct ())",
+ "define-struct: expected the structure name after define-struct, but found something else");
+
+ queueErrorTest("define-struct given too many args",
+ "(define-struct test (p1 p2) 2 3 4 5 6)",
+ "define-struct: expected nothing after the field names, but found 5 extra parts");
+
+ queueErrorTest("define-struct given wrong kind of field",
+ "(define-struct test (4))",
+ "define-struct: expected a field name, but found something else");
+
+ queueErrorTest("define-struct given too many args",
+ "(define-struct test (p1 p2) 2)",
+ "define-struct: expected nothing after the field names, but found 1 extra part");
+
+ queueErrorTest("define-struct given bad structure name",
+ "(define-struct (name) (pr1 pr2))",
+ "define-struct: expected the structure name after define-struct, but found something else");
+
+ queueErrorTest("define-struct not given proper field name",
+ "(define-struct test this func)",
+ "define-struct: expected at least one field name (in parentheses) after the structure name, but found something else");
+
+ queueErrorTest("previous definition encountered",
+ "(define (fox a) 3) (define (fox b) 4)",
+ "fox: this name has a previous definition and cannot be re-defined");
+
+ queueErrorTest("previous struct definition encountered",
+ "(define-struct fox (a)) (define-struct fox (b))",
+ "fox: this name has a previous definition and cannot be re-defined");
+
+ queueErrorTest("dividing by zero",
+ "(/ 5 0)",
+ "/: cannot divide by zero");
+
+ queueErrorTest("dividing by zero",
+ "(/ 5 4 0)",
+ "/: cannot divide by zero");
+
+ queueErrorTest("dividing by zero",
+ "(/ 5 4 3 0)",
+ "/: cannot divide by zero");
+
+ queueErrorTest("dividing by zero",
+ "(/ 5 0 4 3)",
+ "/: cannot divide by zero");
+
+ queueErrorTest("dividing by zero",
+ "(/ 5 4 0 3)",
+ "/: cannot divide by zero");
+
+ queueErrorTest("defining a variable with the same variable",
+ "(define c c)",
+ "c: this variable is not defined");
+
+ queueErrorTest("define-values given bad first part",
+ "(define-values x (5 4))",
+ "define-values: expects a list of variables and a body, but found something else");
+
+ queueErrorTest("define-values given only one part",
+ "(define-values (5 4))",
+ "define-values: expects a list of variables and a body, but found only one part");
+
+ queueErrorTest("define-values given too many args",
+ "(define-values (x) (values 1) 1)",
+ "define-values: expects a list of variables and a body, but found an extra part");
+
+ queueErrorTest("lambda given no args",
+ "(lambda)",
+ "lambda: expected at least one variable (in parentheses) after lambda, but nothing's there");
+
+ queueErrorTest("lambda given extra arg no paren",
+ "(lambda 1)",
+ "lambda: expected at least one variable (in parentheses) after lambda, but found something else");
+
+ // Note: we do not currently allow vararity functions in this language, so even though
+ // this is ok in Scheme, it's not in WeScheme:
+ queueErrorTest("Disallow vararity lambdas",
+ "(lambda args args)",
+ "lambda: expected at least one variable (in parentheses) after lambda, but found something else");
+
+ queueErrorTest("lambda given 2 extra args no paren",
+ "(lambda 1 2)",
+ "lambda: expected at least one variable (in parentheses) after lambda, but found something else");
+
+ queueErrorTest("lambda given empty paren",
+ "(lambda ())",
+ "lambda: expected an expression for the function body, but nothing's there");
+
+ queueErrorTest("lambda given paren with bad arg type",
+ "(lambda (1))",
+ "lambda: expected a list of variables after lambda, but found something else");
+
+ queueErrorTest("lambda given variable, but no function body",
+ "(lambda (x))",
+ "lambda: expected an expression for the function body, but nothing's there");
+
+ queueErrorTest("lambda given two identical variables",
+ "(lambda (x x) 1)",
+ "lambda: found a variable that is already used here");
+
+ queueErrorTest("lambda given an extra part",
+ "(lambda (x y) (+ y x) 1)",
+ "lambda: expected only one expression for the function body, but found 1 extra part");
+
+ queueErrorTest("lambda given two extra part",
+ "(lambda (x y) (+ y x) 1 2)",
+ "lambda: expected only one expression for the function body, but found 2 extra parts");
+
+ queueErrorTest("lambda given multiple variables not in paren",
+ "(lambda x y (+ 2 y))",
+ "lambda: expected at least one variable (in parentheses) after lambda, but found something else");
+
+ queueErrorTest("lambda given lambda as variable, also no body for 2nd lambda",
+ "(lambda (x lambda) (lambda (u)))",
+ "lambda: this is a reserved keyword and cannot be used as a variable or function name");
+
+ queueErrorTest("let given nothing",
+ "(let)",
+ "let: expected at least one binding (in parentheses) after let, but nothing's there");
+
+ queueErrorTest("let given empty paren",
+ "(let ())",
+ "let: expected a single body, but found none");
+
+ queueErrorTest("let given bad form",
+ "(let x 6)",
+ "let: expected sequence of key value pairs, but given something else");
+
+ queueErrorTest("let given bad form",
+ "(let (x) 3)",
+ "let: expected a key/value pair, but given something else");
+
+ queueErrorTest("let given bad form",
+ "(let (x 2) 3)",
+ "let: expected a key/value pair, but given something else");
+
+ queueErrorTest("let given bad form",
+ "(let ((x 3) (x 6)) 5)",
+ "let: found a variable that is already used here");
+
+ queueErrorTest("let given bad form",
+ "(let ((x x)) x)",
+ "x: this variable is not defined");
+
+ queueErrorTest("let given bad form",
+ "(let ((x 3)))",
+ "let: expected a single body, but found none");
+
+ queueErrorTest("let given bad form",
+ "(let ((x 5) (1)) 6)",
+ "let: expected a key/value pair, but given something else");
+
+ queueErrorTest("let given bad form (too many values)",
+ "(let ((x 2 3)) 6)",
+ "let: expected a key/value pair, but given something else");
+
+ queueErrorTest("let given bad form",
+ "(let 5 6)",
+ "let: expected sequence of key value pairs, but given something else");
+
+ queueErrorTest("let given bad form",
+ "(let ((x 2)) ())",
+ "( ): expected a function, but nothing's there");
+
+ queueErrorTest("let given too many parts",
+ "(let () 4 4 5 5)",
+ "let: expected a single body, but found 3 extra parts");
+
+ queueErrorTest("local given too many parts",
+ "(local () 4 4 5 5)",
+ "local: expected a single body, but found 3 extra parts");
+
+ queueErrorTest("local given no args",
+ "(local)",
+ "local: expected at least one definition (in square brackets) after local, but nothing's there");
+
+ queueErrorTest("local given bad form",
+ "(local x 3)",
+ "local: expected a collection of definitions, but given something else");
+
+ queueErrorTest("local given bad form",
+ "(local (x))",
+ "local: expected a definition, but given something else");
+
+ queueErrorTest("local given bad form",
+ "(local (x) 7)",
+ "local: expected a definition, but given something else");
+
+ queueErrorTest("local given bad form",
+ "(local (x 1) 7)",
+ "local: expected a definition, but given something else");
+
+ queueErrorTest("local given bad form",
+ "(local ((x 6)))",
+ "local: expected a definition, but given something else");
+
+ queueErrorTest("local given bad form",
+ "(local ((x 6) (2)) 4)",
+ "local: expected a definition, but given something else");
+
+ queueErrorTest("local given bad form",
+ "(local 1 5)",
+ "local: expected a collection of definitions, but given something else");
+
+ queueErrorTest("local given bad form",
+ "(local ())",
+ "local: expected a single body, but found none");
+
+ queueErrorTest("local given bad form",
+ "(local ((x 1)) ())",
+ "local: expected a definition, but given something else");
+
+ queueErrorTest("lambda used as name",
+ "(define (f lambda) 2)",
+ "lambda: this is a reserved keyword and cannot be used as a variable or function name");
+
+ queueErrorTest("let used as name",
+ "(define (f let) 2)",
+ "let: this is a reserved keyword and cannot be used as a variable or function name");
+
+
+ queueErrorTest("cond used as name",
+ "(define (f cond) 2)",
+ "cond: this is a reserved keyword and cannot be used as a variable or function name");
+
+ queueErrorTest("else used as name",
+ "(define (f else) 2)",
+ "else: this is a reserved keyword and cannot be used as a variable or function name");
+
+ queueErrorTest("if used as name",
+ "(define (f if) 2)",
+ "if: this is a reserved keyword and cannot be used as a variable or function name");
+
+ queueErrorTest("define used as name",
+ "(define (f define) 2)",
+ "define: this is a reserved keyword and cannot be used as a variable or function name");
+
+ queueErrorTest("cond: empty case",
+ "(cond)",
+ "cond: expected at least one clause after cond, but nothing's there");
+
+ queueErrorTest("cond: non-clause",
+ "(cond 1)",
+ "cond: expected a clause with a question and an answer, but found something else");
+
+ queueErrorTest("cond: non-clause, with more pieces",
+ "(cond 1 2 3)",
+ "cond: expected a clause with a question and an answer, but found something else");
+
+ queueErrorTest("cond: clause with not enough pieces",
+ "(cond [])",
+ "cond: expected a clause with a question and an answer, but found an empty part");
+
+ queueErrorTest("cond: clause with not enough pieces",
+ "(cond [true])",
+ "cond: expected a clause with a question and an answer, but found a clause with only one part");
+
+ queueErrorTest("cond: clause with too many pieces",
+ "(cond [true false true])",
+ "cond: expected a clause with a question and an answer, but found a clause with 3 parts");
+
+
+ queueErrorTest("cond error properly uses the cond keyword",
+ "(cond (empty? 3) (add1 4))",
+ "cond: expected a boolean value, but found: #");
+
+ queueErrorTest("cond boolean test again",
+ "(cond (3 4))",
+ "cond: expected a boolean value, but found: 3")
+
+ queueErrorTest("cond error properly uses the cond keyword: make sure it checks inside too",
+ "(cond [(cond (number? 3) (add1 4)) 5])",
+ "cond: expected a boolean value, but found: #");
+
+ queueErrorTest("cond error properly uses the cond keyword: check multiple parts",
+ "(cond (empty? 3 'ok))",
+ "cond: expected a clause with a question and an answer, but found a clause with 3 parts");
+
+ queueErrorTest("cond fallthrough",
+ "(cond ((even? 43) 'huh?))",
+ "cond: all question results were false");
+
+
+ queueErrorTest("cond/and test",
+ "(cond [(and 3 4 5) 6] [else 7])",
+ "and: expected a boolean value, but found: 3");
+
+
+ queueErrorTest("cond/and/empty test",
+ "(cond [(and empty?) 3] [else 4])",
+ "and: expected at least 2 arguments, but given 1");
+
+
+ queueErrorTest("cond else clause must be last",
+ "(cond [else 'ok] [true 'huh?])",
+ "cond: found an else clause that isn't the last clause in its cond expression; there is another clause after it");
+
+ queueErrorTest("cond else clause must be last and unique.",
+ "(cond [else 'ok] [true 'huh?])",
+ "cond: found an else clause that isn't the last clause in its cond expression; there is another clause after it");
+
+ queueErrorTest("cond else clause must be last and unique, even if it shows up twice",
+ "(cond [else 'ok] [else 'huh?])",
+ "cond: found an else clause that isn't the last clause in its cond expression; there is another clause after it");
+
+ queueErrorTest("cond else clause must be last and unique; make sure the test isn't fragile",
+ "(cond [else 'ok] 42 [else 'huh?])",
+ "cond: expected a clause with a question and an answer, but found something else");
+
+ queueErrorTest("else is a keyword only usable in context",
+ "else",
+ "else: not allowed here, because this is not a question in a clause");
+
+ queueErrorTest("else is a keyword only usable in context",
+ "(else)",
+ "else: not allowed here, because this is not a question in a clause");
+
+ queueErrorTest("double definitions",
+ "(define-struct x (y)) (define x-y 43)",
+ "x-y: this name has a previous definition and cannot be re-defined");
+
+ queueErrorTest("define-values too few",
+ "(define-values (x y z) (values 1))",
+ "define-values: expected 3 values, but only received one: 1");
+
+ queueErrorTest("define-values too few",
+ "(define-values (x y z) (values 1 2 3 4))",
+ "define-values: expected 3 values, but received 4");
+
+
+ // FIXME: define-values looks wrong. Here's what the code does:
+ queueErrorTest("define-values too many parts",
+ "(define-values (x) a b c)",
+ "define-values: expects a list of variables and a body, but found a part");
+
+ queueErrorTest("define-values too many parts",
+ "(define-values (x) (a) b c)",
+ "define-values: expected 1 part, but found 1 part");
+
+ queueErrorTest('define one extra part',
+ '(define (f x) 1 2)',
+ 'define: expected only one expression for the function body, but found 1 extra part');
+
+ queueErrorTest('define duplicate identifier',
+ '(define (f x x) x)',
+ 'define: found a variable that is already used here');
+
+
+
+ var initTests = function(afterInit) {
+ var afterReplSetup = function(theRepl) {
+ repl = theRepl;
+ afterInit(runTests);
+ };
+
+ $("#failure-index").css("display", "none");
+ $("#is-running").text("Running...");
+ plt.runtime.makeRepl({ write: function(dom) { outputSpan.append(dom); } },
+ afterReplSetup);
+ };
+
+
+ if (typeof window.plt === 'undefined') { window.plt = {}; }
+ window.plt.tests = {};
+ window.plt.tests.initTests = initTests;
+ window.plt.tests.resetTests = function() {
+ $("#failure-index").clear();
+ failureCount = 0;
+ $("#failure-index").css("display", "none");
+
+ };
+ window.plt.tests.getTestsRunCount = function() { return testsRunCount; };
+ window.plt.tests.getFailureCount = function() { return failureCount; };
+
+
+})
+
diff --git a/whalesong/repl-prototype/htdocs/tests.html b/whalesong/repl-prototype/htdocs/tests.html
index 182d8cf..26f7456 100644
--- a/whalesong/repl-prototype/htdocs/tests.html
+++ b/whalesong/repl-prototype/htdocs/tests.html
@@ -5,6 +5,7 @@
+
@@ -15,6 +16,7 @@
Failures:
+
diff --git a/whalesong/repl-prototype/htdocs/tests.js b/whalesong/repl-prototype/htdocs/tests.js
index f22b51e..a7f2fae 100644
--- a/whalesong/repl-prototype/htdocs/tests.js
+++ b/whalesong/repl-prototype/htdocs/tests.js
@@ -1,4263 +1,10 @@
jQuery(document).ready(function() {
"use strict";
-
- var repl; // Will be initialized at the bottom
- // of this file.
- var outputSpan = $("");
-
- var testsRunCount = 0;
- var failureCount = 0;
-
- var noteRedFailure = function(e) {
- failureCount++;
- $("#failure-index").css("display", "inline");
- $("#failure-index").append($("").attr("href", "#fail" + failureCount)
- .text("" + failureCount)).append(' ');
- var failMsgText = " FAIL" + ((e.message || e || '') ?
- ": " + (e.message || e || '') : "");
- $(document.body).append($("").text(failMsgText)
- .css("color", "red")
- .css("white-space", "pre")
- .append($("").attr("name", "fail" + failureCount)));
- $(document.body).css("background-color", "#eeaaaa");
- };
-
-
- var runTests = function(after) {
- runAsyncTests(0, after);
- };
-
- var asyncTests = [];
- var queueAsyncTest = function(name, f) {
- asyncTests.push({name: name, f: f});
- };
-
- var runAsyncTests = function(i, k) {
- if (i < asyncTests.length) {
- runAsyncTest(asyncTests[i].name,
- asyncTests[i].f,
- function() {
- setTimeout(function() {
- runAsyncTests(i+1, k);
- }, 10);
- });
- } else {
- k();
- }
- };
-
- var runAsyncTest = function(name, f, k) {
- $(document.body).append("running " + name + "... ");
- var success = function() {
- $(document.body).append(" ok").append($("
"));
- testsRunCount++;
- k();
- };
- var fail = function(e) {
- noteRedFailure(e);
- testsRunCount++;
- $(document.body).append($("
"));
- // $(document.body).append(e + '');
- //$(document.body).append($("
"));
- k();
- };
- try {
- f(success, fail);
- } catch(e) {
- fail(e);
- }
- };
-
-
- var queueTest = function(name, code, expectedText) {
- queueAsyncTest(name, function(success, fail) {
- var checkOutput = function(err) {
- var observedText = outputSpan.text().replace(/\n$/, "");
- if (observedText === expectedText) {
- success();
- } else {
- fail("not the same: " + observedText +
- ", " +
- expectedText);
- }
- };
- // Reinitialize outputSpan.
- outputSpan = jQuery("");
- repl.reset(function() {
- repl.compileAndExecuteProgram(name, code, checkOutput,
- checkOutput);
- });
- });
- };
-
- var queueErrorTest = function(name, code, expectedErrorText) {
- queueAsyncTest(name, function(success, fail) {
- var checkOutput = function(err) {
- var errText = ((err && err.message) || err) + '';
- if (errText === expectedErrorText) {
- success();
- } else {
- fail("not the same: " + errText +
- ", " + expectedErrorText);
- }
- };
- repl.reset(function() {
- repl.compileAndExecuteProgram(name, code, checkOutput, checkOutput);
- });
- });
- };
-
-
-
- //////////////////////////////////////////////////////////////////////
-
-
- queueTest("local",
- "(local [(define x 42)] x)",
- "42");
- queueTest("local",
- "(local [(define x 42) (define y 3)] (+ x y))",
- "45");
- queueTest("local",
- "(local [] 1)",
- "1");
-
- queueTest("test simple function application program",
- "(define (double x) (+ x x)) (double 25)",
- "50");
-
- queueTest("test simple function application program 2",
- "(define (double x) (+ x x)) (double (double 25))",
- "100");
-
- queueTest("simple structures 1",
- "(define-struct foo (x y)) (foo-x (make-foo 3 4))",
- "3");
-
- queueTest("simple structures 2",
- "(define-struct foo (x y)) (foo-y (make-foo 3 4))",
- "4");
-
- queueTest("simple structures predicate 1",
- "(define-struct foo (x y)) (foo? (make-foo 3 4))",
- "true");
-
- queueTest("simple structures predicate 2",
- "(define-struct foo (x y)) (foo? 'foo)",
- "false");
-
- queueTest("division",
- "(/ 18 2)",
- "9");
-
-
- queueTest("symbol string",
- "(symbol->string 'hello)",
- "\"hello\"");
-
- queueTest("string->symbol",
- "(string->symbol \"hello\")",
- "'hello");
-
- // queueTest("formatting lists",
- // "(format \"~a\" '(1 2))",
- // "\"(list 1 2)\"");
-
-
- queueTest("symbols that should not leak js implementation",
- "'constructor",
- "'constructor");
-
- queueTest("symbols that should not leak js implementation 2",
- "'hasOwnProperty",
- "'hasOwnProperty");
-
- queueTest("symbols that should not leak js implementation 3",
- "'__proto__",
- "'__proto__");
-
-
- queueTest("simple set!",
- "(define x 42) (set! x 16) x",
- "16")
-
-
- queueErrorTest("test mis-application 1",
- "(define (double x) (+ x x)) (double double)",
- "+: expects a number as 1st argument, but given: #; other arguments were: #");
-
- queueErrorTest("test mis-application 2",
- "(define (double x) (+ x x)) (double double 25)",
- "double: expects 1 argument, but given 2: # 25");
-
- queueErrorTest("test a error in map",
- '(map add1 (list "1"))',
- 'add1: expects a number as 1st argument, but given: "1"');
-
-
- queueErrorTest("test non-boolean in if test position",
- "(if 3 'four 'five)",
- 'if: expected a boolean value, but found: 3');
-
- queueErrorTest("test if not enough args",
- "(if)",
- "if: expected a test, a consequence, and an alternative, but all three were not found");
-
- queueErrorTest("test if not enough args",
- "(if true)",
- "if: expected a test, a consequence, and an alternative, but all three were not found");
-
- queueErrorTest("test if not enough args",
- "(if true false)",
- "if: expected a test, a consequence, and an alternative, but all three were not found");
-
- queueErrorTest("test if too many args",
- "(if true false true false)",
- "if: expected only a test, a consequence, and an alternative, but found more than three of these");
-
-
- queueErrorTest("test non-boolean in 'or'",
- "(or 42 4)",
- 'or: expected a boolean value, but found: 42');
-
- queueErrorTest("test non-boolean in 'or', second position",
- "(or #f 4)",
- 'or: expected a boolean value, but found: 4');
-
- queueErrorTest("test and empty",
- "(and)",
- "and: expected at least 2 arguments, but given 0");
-
- queueErrorTest("test and empty",
- "(and 1)",
- "and: expected at least 2 arguments, but given 1");
-
- queueErrorTest("test and empty",
- "(and 'foo)",
- "and: expected at least 2 arguments, but given 1");
-
- queueErrorTest("test or empty",
- "(or)",
- "or: expected at least 2 arguments, but given 0");
-
- queueErrorTest("test or only one arg",
- "(or 1)",
- "or: expected at least 2 arguments, but given 1");
-
- queueErrorTest("test and empty",
- "(or 'noo)",
- "or: expected at least 2 arguments, but given 1");
-
- queueErrorTest("test non-boolean in 'and'",
- "(and 'blah 4)",
- "and: expected a boolean value, but found: blah");
-
- queueErrorTest("test non-boolean in 'and', second position",
- "(and #t 'not-bool)",
- "and: expected a boolean value, but found: not-bool");
-
- queueErrorTest("beside given 1 arg",
- "(beside 5)",
- "beside: expects at least 2 arguments, but given 1: 5");
-
- queueErrorTest("beside given 3 non-image args",
- "(beside 2 3 3)",
- "beside: expects an image as 1st argument, but given: 2; other arguments were: 3 3");
-
- queueErrorTest("beside given bad args, correct number",
- "(beside 1 1)",
- "beside: expects an image as 1st argument, but given: 1; other arguments were: 1");
-
- queueErrorTest("beside given 0 args",
- "(beside)",
- "beside: expects at least 2 arguments, but given 0");
-
- queueErrorTest("beside/align give too few args",
- "(beside/align 3 3)",
- "beside/align: expects at least 3 arguments, but given 2: 3 3");
- queueErrorTest("beside/align given bad args",
- "(beside/align 3 3 3 3 3 3)",
- "beside/align: expects a y-place as 1st argument, but given: 3; other arguments were: 3 3 3 3 3");
-
- queueErrorTest("beside/align given bad args, correct number",
- "(beside/align 1 1 1)",
- "beside/align: expects a y-place as 1st argument, but given: 1; other arguments were: 1 1");
-
- queueErrorTest("above given 0 args",
- "(above)",
- "above: expects at least 2 arguments, but given 0");
-
- queueErrorTest("above given bad args",
- "(above 2 1 1)",
- "above: expects an image as 1st argument, but given: 2; other arguments were: 1 1");
-
- queueErrorTest("above given bad args, correct number",
- "(above 1 1)",
- "above: expects an image as 1st argument, but given: 1; other arguments were: 1");
-
- queueErrorTest("above/align given no args",
- "(above/align)",
- "above/align: expects at least 3 arguments, but given 0");
-
- queueErrorTest("above/align given bad args, correct number",
- "(above/align 1 1 1)",
- "above/align: expects a x-place as 1st argument, but given: 1; other arguments were: 1 1");
-
- queueErrorTest("above/align given too many args, all bad",
- "(above/align 1 1 1 1 1)",
- "above/align: expects a x-place as 1st argument, but given: 1; other arguments were: 1 1 1 1");
-
- queueErrorTest("rotate given no args",
- "(rotate)",
- "rotate: expects 2 arguments, but given 0");
-
- queueErrorTest("rotate given correct number of bad args",
- "(rotate 1 1)",
- "rotate: expects an image as 2nd argument, but given: 1; other arguments were: 1");
-
- queueErrorTest("rotate given too many args",
- "(rotate 1 1 1 1 1 1)",
- "rotate: expects 2 arguments, but given 6: 1 1 1 1 1 1");
-
- queueErrorTest("crop given no args",
- "(crop)",
- "crop: expects 5 arguments, but given 0");
-
- queueErrorTest("crop given correct # args, but bad args",
- "(crop 1 1 1 1 1)",
- "crop: expects an image as 5th argument, but given: 1; other arguments were: 1 1 1 1");
-
- queueErrorTest("frame given no args",
- "(frame)",
- "frame: expects 1 argument, but given 0");
-
- queueErrorTest("frame given correct number args, but bad args",
- "(frame 1)",
- "frame: expects an image as 1st argument, but given: 1");
-
- queueErrorTest("frame given too many args",
- "(frame 1 1)",
- "frame: expects 1 argument, but given 2: 1 1");
-
- queueErrorTest("flip-vertical given no args",
- "(flip-vertical)",
- "flip-vertical: expects 1 argument, but given 0");
-
- queueErrorTest("flip-vertical given correct amount of args, but bad args",
- "(flip-vertical 1)",
- "flip-vertical: expects an image as 1st argument, but given: 1");
-
- queueErrorTest("flip-vertical given too many args",
- "(flip-vertical 1 1)",
- "flip-vertical: expects 1 argument, but given 2: 1 1");
-
- queueErrorTest("flip-horizontal given no args",
- "(flip-horizontal)",
- "flip-horizontal: expects 1 argument, but given 0");
-
- queueErrorTest("flip-horizontal given correct amount of args, but bad args",
- "(flip-horizontal 1)",
- "flip-horizontal: expects an image as 1st argument, but given: 1");
-
- queueErrorTest("flip-horizontal given too many args",
- "(flip-horizontal 1 1)",
- "flip-horizontal: expects 1 argument, but given 2: 1 1");
-
- queueErrorTest("text given no args",
- "(text)",
- "text: expects 3 arguments, but given 0");
-
- queueErrorTest("text given correct # args, but bad args",
- "(text 1 1 1)",
- "text: expects a string as 1st argument, but given: 1; other arguments were: 1 1");
-
- queueErrorTest("text given too many args",
- "(text 1 1 1 1)",
- "text: expects 3 arguments, but given 4: 1 1 1 1");
-
- queueErrorTest("text/font given bad number of args",
- "(text/font 1)",
- "text/font: expects 8 arguments, but given 1: 1");
-
- queueErrorTest("text/font given bad but correct amount of args",
- "(text/font 1 1 1 1 1 1 1 1)",
- "text/font: expects a string as 1st argument, but given: 1; other arguments were: 1 1 1 1 1 1 1");
-
- queueErrorTest("bitmap/url given bad amount of args",
- "(bitmap/url)",
- "image-url: expects 1 argument, but given 0");
-
- queueErrorTest("bitmap/url given correct amount of args, but bad as",
- "(bitmap/url 1)",
- "image-url: expects a string as 1st argument, but given: 1");
-
- queueErrorTest("video-url given bad amount of args",
- "(video-url)",
- "video-url: expects 1 argument, but given 0");
-
- queueErrorTest("video-url given correct arg amount, but bad as",
- "(video-url 1)",
- "video-url: expects a string as 1st argument, but given: 1");
-
- queueErrorTest("image-width given no args",
- "(image-width)",
- "image-width: expects 1 argument, but given 0");
-
- queueErrorTest("image-width given correct arg amount, but bad as",
- "(image-width 1)",
- "image-width: expects an image as 1st argument, but given: 1");
-
- queueErrorTest("image-height given no args",
- "(image-height)",
- "image-height: expects 1 argument, but given 0");
-
- queueErrorTest("image-height given correct arg amount, but bad as",
- "(image-height 1)",
- "image-height: expects an image as 1st argument, but given: 1");
-
- queueErrorTest("image-baseline given no args",
- "(image-baseline)",
- "image-baseline: expects 1 argument, but given 0");
-
- queueErrorTest("image-baseline given correct arg amount, but bad as",
- "(image-baseline 1)",
- "image-baseline: expects an image as 1st argument, but given: 1");
-
- queueErrorTest("color-list->image bad arg amount",
- "(color-list->image)",
- "color-list->image: expects 5 arguments, but given 0");
-
- queueErrorTest("color-list->bitmap bad arg a",
- "(color-list->bitmap 1 1 1 1 1)",
- "color-list->bitmap: expects 3 arguments, but given 5: 1 1 1 1 1");
-
- queueErrorTest("color-list->bitmap bad arg amount",
- "(color-list->bitmap)",
- "color-list->bitmap: expects 3 arguments, but given 0");
-
- queueErrorTest("color-list->image bad arg a",
- "(color-list->image 1 1 1 1 1)",
- "color-list->image: expects a list of image as 1st argument, but given: 1");
-
- queueErrorTest("mode? no args",
- "(mode?)",
- "mode?: expects 1 argument, but given 0");
-
- queueErrorTest("mode? too many args",
- "(mode? 1 1)",
- "mode?: expects 1 argument, but given 2: 1 1");
-
- queueErrorTest("image-color? no args",
- "(image-color?)",
- "image-color?: expects 1 argument, but given 0");
-
- queueErrorTest("image-color? too many args",
- "(image-color? 1 1)",
- "image-color?: expects 1 argument, but given 2: 1 1");
-
- queueErrorTest("name->color no args",
- "(name->color)",
- "name->color: expects 1 argument, but given 0");
-
- queueErrorTest("name->color too many args",
- "(name->color 1 1)",
- "name->color: expects 1 argument, but given 2: 1 1");
-
- queueErrorTest("x-place? no args",
- "(x-place?)",
- "x-place?: expects 1 argument, but given 0");
-
- queueErrorTest("x-place? too many args",
- "(x-place? 1 1)",
- "x-place?: expects 1 argument, but given 2: 1 1");
-
- queueErrorTest("y-place? no args",
- "(y-place?)",
- "y-place?: expects 1 argument, but given 0");
-
- queueErrorTest("y-place? too many args",
- "(y-place? 1 1)",
- "y-place?: expects 1 argument, but given 2: 1 1");
-
- queueErrorTest("angle? no args",
- "(angle?)",
- "angle?: expects 1 argument, but given 0");
-
- queueErrorTest("angle? too many args",
- "(angle? 1 1)",
- "angle?: expects 1 argument, but given 2: 1 1");
-
- queueErrorTest("side-count? no args",
- "(side-count?)",
- "side-count?: expects 1 argument, but given 0");
-
- queueErrorTest("side-count? too many args",
- "(side-count? 1 1)",
- "side-count?: expects 1 argument, but given 2: 1 1");
-
- queueErrorTest("step-count? no args",
- "(step-count?)",
- "step-count?: expects 1 argument, but given 0");
-
- queueErrorTest("step-count? too many args",
- "(step-count? 1 1)",
- "step-count?: expects 1 argument, but given 2: 1 1");
-
- queueErrorTest("on-tick bad args amount",
- "(on-tick)",
- "on-tick: expects 1 or 2 arguments, but given 0");
-
- queueErrorTest("on-tick 1 arg",
- "(on-tick 1)",
- "on-tick: expects a function name as 1st argument, but given: 1");
-
- queueErrorTest("on-tick 2 args",
- "(on-tick 1 2)",
- "on-tick: expects a function name as 1st argument, but given: 1; other arguments were: 2");
-
-
- queueErrorTest("on-tap bad arg amount",
- "(on-tap)",
- "on-tap: expects 1 argument, but given 0");
-
- queueErrorTest("on-tap bad arg a",
- "(on-tap 1)",
- "on-tap: expects a function name as 1st argument, but given: 1");
-
- queueErrorTest("on-tilt bad arg amount",
- "(on-tilt)",
- "on-tilt: expects 1 argument, but given 0");
-
- queueErrorTest("on-tilt bad arg a",
- "(on-tilt 1)",
- "on-tilt: expects a function name as 1st argument, but given: 1");
-
- queueErrorTest("on-key bad arg amount",
- "(on-key)",
- "on-key: expects 1 argument, but given 0");
-
- queueErrorTest("on-key bad arg a",
- "(on-key 1)",
- "on-key: expects a function name as 1st argument, but given: 1");
-
-
- queueErrorTest("stop-when bad arg amount",
- "(stop-when)",
- "stop-when: expects 1 argument, but given 0");
-
- queueErrorTest("stop-when bad arg a",
- "(stop-when 1)",
- "stop-when: expects a function name as 1st argument, but given: 1");
- /*
- queueErrorTest("stop-when! bad arg amount",
- "(stop-when!)",
- "stop-when!: expects 2 arguments, but given 0");
-
- queueErrorTest("stop-when! bad arg a",
- "(stop-when! 1 1)",
- "stop-when!: expects a function name as 1st argument, but given: 1; other arguments were: 1");
- */
- queueErrorTest("on-redraw bad arg amount",
- "(on-redraw)",
- "on-redraw: expects 1 argument, but given 0");
-
- queueErrorTest("on-redraw bad arg a",
- "(on-redraw 1)",
- "on-redraw: expects a function name as 1st argument, but given: 1");
-
-
-
- queueErrorTest("on-draw bad arg amount",
- "(on-draw)",
- "on-draw: expects 1 or 2 arguments, but given 0");
-
- queueErrorTest("on-draw bad arg a",
- "(on-draw 1)",
- "on-draw: expects a function name as 1st argument, but given: 1");
-
- queueErrorTest("on-draw bad arg as",
- "(on-draw 1 2)",
- "on-draw: expects a function name as 1st argument, but given: 1; other arguments were: 2");
-
- queueErrorTest("initial-effect bad arg amount (no args)",
- "(initial-effect)",
- "initial-effect: expects 1 argument, but given 0");
-
- queueErrorTest("initial-effect too many args",
- "(initial-effect 1 2)",
- "initial-effect: expects 1 argument, but given 2: 1 2");
-
- queueErrorTest("big-bang given no arguments",
- "(big-bang)",
- "big-bang: expects at least 1 argument, but given 0");
-
- queueErrorTest("big-bang given wrong type of arg as 2nd arg",
- "(big-bang 1 1)",
- "big-bang: expects a handler as 2nd argument, but given: 1; other arguments were: 1");
-
- queueErrorTest("make-struct-type wrong number of args",
- "(make-struct-type)",
- "make-struct-type: expects 4 or 5 or 6 or 7 or 8 or 9 or 10 arguments, but given 0");
-
- queueErrorTest("make-struct-type give wrong arg type",
- "(make-struct-type 1 1 1 1)",
- "make-struct-type: expects a symbol as 1st argument, but given: 1; other arguments were: 1 1 1");
-
- queueErrorTest("make-struct-field-accessor wrong number of args",
- "(make-struct-field-accessor)",
- "make-struct-field-accessor: expects 2 or 3 arguments, but given 0");
-
- queueErrorTest("make-struct-field-accessor given wrong arg type",
- "(make-struct-field-accessor 1 1 1)",
- "make-struct-field-accessor: expects an accessor procedure that requires a field index as 1st argument, but given: 1; other arguments were: 1 1");
-
- queueErrorTest("make-struct-field-accessor given 2 wrong args",
- "(make-struct-field-accessor 1 1)",
- "make-struct-field-accessor: expects an accessor procedure that requires a field index as 1st argument, but given: 1; other arguments were: 1");
-
- queueErrorTest("make-struct-field-mutator given 2 args, bad a",
- "(make-struct-field-mutator 1 1)",
- "make-struct-field-mutator: expects a mutator procedure that requires a field index as 1st argument, but given: 1; other arguments were: 1");
-
- queueErrorTest("make-struct-field-mutator given no args",
- "(make-struct-field-mutator)",
- "make-struct-field-mutator: expects 2 or 3 arguments, but given 0");
-
- queueErrorTest("make-struct-field-mutator given 3 args, bad a",
- "(make-struct-field-mutator 1 1 1)",
- "make-struct-field-mutator: expects a mutator procedure that requires a field index as 1st argument, but given: 1; other arguments were: 1 1");
-
- queueErrorTest("procedure-arity given no args",
- "(procedure-arity)",
- "procedure-arity: expects 1 argument, but given 0");
-
- queueErrorTest("procedure-arity given bad arg a",
- "(procedure-arity 1)",
- "procedure-arity: expects a function name as 1st argument, but given: 1");
-
- queueErrorTest("procedure-arity given way too many args",
- "(procedure-arity 1 1 1 1 1 1 1 1 1 1)",
- "procedure-arity: expects 1 argument, but given 10: 1 1 1 1 1 1 1 1 1 1");
-
- queueErrorTest("apply given no args",
- "(apply)",
- "apply: expects at least 2 arguments, but given 0");
-
- queueErrorTest("apply given bad arg as",
- "(apply 1 1)",
- "apply: expects a function name as 1st argument, but given: 1; other arguments were: 1");
-
- queueErrorTest("apply given bad arg a for second arg",
- "(apply add1 1)",
- "apply: expects a list as 2nd argument, but given: 1; other arguments were: #");
-
- queueErrorTest("compose given bad arg a",
- "(compose 1)",
- "compose: expects a function name as 1st argument, but given: 1");
-
- queueErrorTest("compose given bad 2nd arg a",
- "(compose add1 1)",
- "compose: expects a function name as 2nd argument, but given: 1; other arguments were: #");
-
- queueErrorTest("current-inexact-milliseconds given too many args",
- "(current-inexact-milliseconds 1)",
- "current-inexact-milliseconds: expects 0 arguments, but given 1: 1");
-
- queueErrorTest("current-seconds given too many args",
- "(current-seconds 1)",
- "current-seconds: expects 0 arguments, but given 1: 1");
-
- queueErrorTest("not given no args",
- "(not)",
- "not: expects 1 argument, but given 0");
-
- queueErrorTest("not given too many args",
- "(not 1 1)",
- "not: expects 1 argument, but given 2: 1 1");
-
- queueErrorTest("random given too many args",
- "(random 1 1)",
- "random: expects 0 or 1 arguments, but given 2: 1 1");
-
- queueErrorTest("random given bad arg a",
- "(random add1)",
- "random: expects a non-negative exact integer as 1st argument, but given: #");
-
- queueErrorTest("sleep given bad arg a",
- "(sleep add1)",
- "sleep: expects a non-negative real number as 1st argument, but given: #");
-
- queueErrorTest("sleep given too many args",
- "(sleep 1 2)",
- "sleep: expects 0 or 1 arguments, but given 2: 1 2");
-
- queueErrorTest("identity given no args",
- "(identity)",
- "identity: expects 1 argument, but given 0");
-
- queueErrorTest("identity given too many args",
- "(identity 2 2)",
- "identity: expects 1 argument, but given 2: 2 2");
-
- queueErrorTest("raise given no args",
- "(raise)",
- "raise: expects 1 argument, but given 0");
-
- queueErrorTest("raise given too many args",
- "(raise 1 1)",
- "raise: expects 1 argument, but given 2: 1 1");
-
- queueErrorTest("error given no args",
- "(error)",
- "error: expects at least 1 argument, but given 0");
-
- queueErrorTest("error given bad a",
- "(error 1)",
- "error: expects a symbol or string as 1st argument, but given: 1");
-
- queueErrorTest("make-exn given no args",
- "(make-exn)",
- "make-exn: expects 2 arguments, but given 0");
-
- queueErrorTest("make-exn given bad arg as",
- "(make-exn 1 1)",
- "exn: expects argument of type continuation mark set, but given: 1");
-
- queueErrorTest("* given bad arg",
- "(* add1)",
- "*: expects a number as 1st argument, but given: #");
-
- queueErrorTest("/ given insufficient number of arguments",
- "(/ 1)",
- "/: expects at least 2 arguments, but given 1: 1");
-
- queueErrorTest("/ given bad arg 1st position",
- "(/ add1 1)",
- "/: expects a number as 1st argument, but given: #; other arguments were: 1");
-
- queueErrorTest("/ given bad arg 2nd position",
- "(/ 1 add1)",
- "/: expects a number as 2nd argument, but given: #; other arguments were: 1");
-
- queueErrorTest("/ given bad arg 3rd position",
- "(/ 1 2 add1)",
- "/: expects a number as 3rd argument, but given: #; other arguments were: 1 2");
-
- queueErrorTest("- given bad arg",
- "(- add1)",
- "-: expects a number as 1st argument, but given: #");
-
- queueErrorTest("+ given bad arg",
- "(+ add1)",
- "+: expects a number as 1st argument, but given: #");
-
- queueErrorTest("/ given no arguments",
- "(/)",
- "/: expects at least 2 arguments, but given 0");
-
- queueErrorTest("/ given only one argument",
- "(/ 5)",
- "/: expects at least 2 arguments, but given 1: 5");
-
- queueErrorTest("- given no args",
- "(-)",
- "-: expects at least 1 argument, but given 0");
-
- queueErrorTest("= given no args",
- "(=)",
- "=: expects at least 2 arguments, but given 0");
-
- queueErrorTest("= given bad 2nd arg",
- "(= 1 sub1)",
- "=: expects a number as 2nd argument, but given: #; other arguments were: 1");
-
- queueErrorTest("= given bad first arg",
- "(= sub1 1)",
- "=: expects a number as 1st argument, but given: #; other arguments were: 1");
-
- queueErrorTest("=~ given no args",
- "(=~)",
- "=~: expects 3 arguments, but given 0");
-
- queueErrorTest("=~ given bad as",
- "(=~ add1 sub1 add1)",
- "=~: expects a real as 1st argument, but given: #; other arguments were: # #");
-
- queueErrorTest("sub1 given no args",
- "(sub1)",
- "sub1: expects 1 argument, but given 0");
-
- queueErrorTest("sub1 given a bad arg",
- "(sub1 add1)",
- "sub1: expects a number as 1st argument, but given: #");
-
- queueErrorTest("sub1 given too many args",
- "(sub1 1 1 1)",
- "sub1: expects 1 argument, but given 3: 1 1 1");
-
- queueErrorTest("add1 given too many args",
- "(add1 1 1 1)",
- "add1: expects 1 argument, but given 3: 1 1 1");
-
- queueErrorTest("add1 given no args",
- "(add1)",
- "add1: expects 1 argument, but given 0");
-
- queueErrorTest("add1 given a bad arg",
- "(add1 add1)",
- "add1: expects a number as 1st argument, but given: #");
-
-
- queueErrorTest("< given no args",
- "(<)",
- "<: expects at least 2 arguments, but given 0");
-
- queueErrorTest("< given 1 bad arg",
- "(< add1 1)",
- "<: expects a number as 1st argument, but given: #; other arguments were: 1");
-
- queueErrorTest("< given 1 bad arg (2nd arg)",
- "(< 1 add1)",
- "<: expects a number as 2nd argument, but given: #; other arguments were: 1");
-
- queueErrorTest("< given too few args",
- "(< 1)",
- "<: expects at least 2 arguments, but given 1: 1");
-
- queueErrorTest("> given no args",
- "(>)",
- ">: expects at least 2 arguments, but given 0");
-
- queueErrorTest("> given 1 bad arg",
- "(> add1 1)",
- ">: expects a number as 1st argument, but given: #; other arguments were: 1");
-
- queueErrorTest("> given 1 bad arg (2nd arg)",
- "(> 1 add1)",
- ">: expects a number as 2nd argument, but given: #; other arguments were: 1");
-
- queueErrorTest("> given too few args",
- "(> 1)",
- ">: expects at least 2 arguments, but given 1: 1");
-
-
- queueErrorTest("<= given no args",
- "(<=)",
- "<=: expects at least 2 arguments, but given 0");
-
- queueErrorTest("<= given bad arg (first arg))",
- "(<= add1 1)",
- "<=: expects a number as 1st argument, but given: #; other arguments were: 1");
-
- queueErrorTest("<= given 1 bad arg (2nd arg)",
- "(<= 1 add1)",
- "<=: expects a number as 2nd argument, but given: #; other arguments were: 1");
-
- queueErrorTest("<= given too few args",
- "(<= 1)",
- "<=: expects at least 2 arguments, but given 1: 1");
-
- queueErrorTest(">= given no args",
- "(>=)",
- ">=: expects at least 2 arguments, but given 0");
-
- queueErrorTest(">= given bad arg (first arg))",
- "(>= add1 1)",
- ">=: expects a number as 1st argument, but given: #; other arguments were: 1");
-
- queueErrorTest(">= given 1 bad arg (2nd arg)",
- "(>= 1 add1)",
- ">=: expects a number as 2nd argument, but given: #; other arguments were: 1");
-
- queueErrorTest(">= given too few args",
- "(>= 1)",
- ">=: expects at least 2 arguments, but given 1: 1");
-
- queueErrorTest("abs given no args",
- "(abs)",
- "abs: expects 1 argument, but given 0");
-
- queueErrorTest("abs given 1 bad arg",
- "(abs add1)",
- "abs: expects a real as 1st argument, but given: #");
-
- queueErrorTest("abs given too many args",
- "(abs 1 1)",
- "abs: expects 1 argument, but given 2: 1 1");
-
- queueErrorTest("quotient given no args",
- "(quotient)",
- "quotient: expects 2 arguments, but given 0");
-
- queueErrorTest("quotient given 1 bad arg (first arg))",
- "(quotient add1 1)",
- "quotient: expects an integer as 1st argument, but given: #; other arguments were: 1");
-
- queueErrorTest("quotient given 1 bad arg (2nd arg)",
- "(quotient 1 add1)",
- "quotient: expects an integer as 2nd argument, but given: #; other arguments were: 1");
-
- queueErrorTest("quotient given too many args",
- "(quotient 1 1 1)",
- "quotient: expects 2 arguments, but given 3: 1 1 1");
-
- queueErrorTest("remainder given no args",
- "(remainder)",
- "remainder: expects 2 arguments, but given 0");
-
- queueErrorTest("remainder given 1 bad arg (first arg))",
- "(remainder add1 1)",
- "remainder: expects an integer as 1st argument, but given: #; other arguments were: 1");
-
- queueErrorTest("remainder given 1 bad arg (2nd arg)",
- "(remainder 1 add1)",
- "remainder: expects an integer as 2nd argument, but given: #; other arguments were: 1");
-
- queueErrorTest("remainder given too many args",
- "(remainder 1 1 1)",
- "remainder: expects 2 arguments, but given 3: 1 1 1");
-
- queueErrorTest("modulo given no args",
- "(modulo)",
- "modulo: expects 2 arguments, but given 0");
-
- queueErrorTest("modulo given 1 bad arg (first arg))",
- "(modulo add1 1)",
- "modulo: expects an integer as 1st argument, but given: #; other arguments were: 1");
-
- queueErrorTest("modulo given 1 bad arg (2nd arg)",
- "(modulo 1 add1)",
- "modulo: expects an integer as 2nd argument, but given: #; other arguments were: 1");
-
- queueErrorTest("modulo given too many args",
- "(modulo 1 1 1)",
- "modulo: expects 2 arguments, but given 3: 1 1 1");
-
- queueErrorTest("max given no args",
- "(max)",
- "max: expects at least 1 argument, but given 0");
-
- queueErrorTest("max given 1 bad arg",
- "(max add1)",
- "max: expects a real as 1st argument, but given: #");
-
- queueErrorTest("max given 1 good 1 bad arg",
- "(max 1 add1)",
- "max: expects a real as 2nd argument, but given: #; other arguments were: 1");
-
- queueErrorTest("min given no args",
- "(min)",
- "min: expects at least 1 argument, but given 0");
-
- queueErrorTest("min given 1 bad arg",
- "(min add1)",
- "min: expects a real as 1st argument, but given: #");
-
- queueErrorTest("min given 1 good 1 bad arg",
- "(min 1 add1)",
- "min: expects a real as 2nd argument, but given: #; other arguments were: 1");
-
- queueErrorTest("gcd given no args",
- "(gcd)",
- "gcd: expects at least 1 argument, but given 0");
-
- queueErrorTest("gcd given 1 bad arg",
- "(gcd add1)",
- "gcd: expects an integer as 1st argument, but given: #");
-
- queueErrorTest("gcd given 1 good 1 bad arg",
- "(gcd 1 add1)",
- "gcd: expects an integer as 2nd argument, but given: #; other arguments were: 1");
-
- queueErrorTest("lcm given no args",
- "(lcm)",
- "lcm: expects at least 1 argument, but given 0");
-
- queueErrorTest("lcm given 1 bad arg",
- "(lcm add1)",
- "lcm: expects an integer as 1st argument, but given: #");
-
- queueErrorTest("lcm given 1 good 1 bad arg",
- "(lcm 1 add1)",
- "lcm: expects an integer as 2nd argument, but given: #; other arguments were: 1");
-
- queueErrorTest("floor given no args",
- "(floor)",
- "floor: expects 1 argument, but given 0");
-
- queueErrorTest("floor given 1 bad arg",
- "(floor add1)",
- "floor: expects a real as 1st argument, but given: #");
-
- queueErrorTest("floor given too many args",
- "(floor 1 1 1)",
- "floor: expects 1 argument, but given 3: 1 1 1");
-
- queueErrorTest("ceiling given no args",
- "(ceiling)",
- "ceiling: expects 1 argument, but given 0");
-
- queueErrorTest("ceiling given 1 bad arg",
- "(ceiling add1)",
- "ceiling: expects a real as 1st argument, but given: #");
-
- queueErrorTest("ceiling given too many args",
- "(ceiling 1 1 1)",
- "ceiling: expects 1 argument, but given 3: 1 1 1");
-
- queueErrorTest("round given no args",
- "(round)",
- "round: expects 1 argument, but given 0");
-
- queueErrorTest("round given 1 bad arg",
- "(round add1)",
- "round: expects a real as 1st argument, but given: #");
-
- queueErrorTest("round given too many args",
- "(round 1 1 1)",
- "round: expects 1 argument, but given 3: 1 1 1");
-
- queueErrorTest("numerator given no args",
- "(numerator)",
- "numerator: expects 1 argument, but given 0");
-
- queueErrorTest("numerator given 1 bad arg",
- "(numerator add1)",
- "numerator: expects a rational number as 1st argument, but given: #");
-
- queueErrorTest("numerator given too many args",
- "(numerator 1 1 1)",
- "numerator: expects 1 argument, but given 3: 1 1 1");
-
- queueErrorTest("denominator given no args",
- "(denominator)",
- "denominator: expects 1 argument, but given 0");
-
- queueErrorTest("denominator given 1 bad arg",
- "(denominator add1)",
- "denominator: expects a rational number as 1st argument, but given: #");
-
- queueErrorTest("denominator given too many args",
- "(denominator 1 1 1)",
- "denominator: expects 1 argument, but given 3: 1 1 1");
-
- queueErrorTest("expt given no args",
- "(expt)",
- "expt: expects 2 arguments, but given 0");
-
- queueErrorTest("expt given bad first arg, valid 2nd arg",
- "(expt add1 1)",
- "expt: expects a number as 1st argument, but given: #; other arguments were: 1");
-
- queueErrorTest("expt given valid 1st arg, bad 2nd arg",
- "(expt 1 add1)",
- "expt: expects a number as 2nd argument, but given: #; other arguments were: 1");
-
- queueErrorTest("expt given too many args",
- "(expt 1 1 1)",
- "expt: expects 2 arguments, but given 3: 1 1 1");
-
- queueErrorTest("exp given no args",
- "(exp)",
- "exp: expects 1 argument, but given 0");
-
- queueErrorTest("exp given 1 bad arg",
- "(exp add1)",
- "exp: expects a number as 1st argument, but given: #");
-
- queueErrorTest("exp given too many bad args",
- "(exp 1 1)",
- "exp: expects 1 argument, but given 2: 1 1");
-
- queueErrorTest("log given no args",
- "(log)",
- "log: expects 1 argument, but given 0");
-
- queueErrorTest("log given 1 bad arg",
- "(log add1)",
- "log: expects a number as 1st argument, but given: #");
-
- queueErrorTest("log given too many args",
- "(log 1 1)",
- "log: expects 1 argument, but given 2: 1 1");
-
- queueErrorTest("sin given no args",
- "(sin)",
- "sin: expects 1 argument, but given 0");
-
- queueErrorTest("sin given 1 bad arg",
- "(sin add1)",
- "sin: expects a number as 1st argument, but given: #");
-
- queueErrorTest("sin given too many args",
- "(sin 1 1)",
- "sin: expects 1 argument, but given 2: 1 1");
- //next trig func
-
- queueErrorTest("cos given no args",
- "(cos)",
- "cos: expects 1 argument, but given 0");
-
- queueErrorTest("cos given 1 bad arg",
- "(cos add1)",
- "cos: expects a number as 1st argument, but given: #");
-
- queueErrorTest("cos given too many args",
- "(cos 1 1)",
- "cos: expects 1 argument, but given 2: 1 1");
- //next trig func
-
- queueErrorTest("tan given no args",
- "(tan)",
- "tan: expects 1 argument, but given 0");
-
- queueErrorTest("tan given 1 bad arg",
- "(tan add1)",
- "tan: expects a number as 1st argument, but given: #");
-
- queueErrorTest("tan given too many args",
- "(tan 1 1)",
- "tan: expects 1 argument, but given 2: 1 1");
- //next trig func
-
- queueErrorTest("asin given no args",
- "(asin)",
- "asin: expects 1 argument, but given 0");
-
- queueErrorTest("asin given 1 bad arg",
- "(asin add1)",
- "asin: expects a number as 1st argument, but given: #");
-
- queueErrorTest("asin given too many args",
- "(asin 1 1)",
- "asin: expects 1 argument, but given 2: 1 1");
- //next trig func
-
- queueErrorTest("acos given no args",
- "(acos)",
- "acos: expects 1 argument, but given 0");
-
- queueErrorTest("acos given 1 bad arg",
- "(acos add1)",
- "acos: expects a number as 1st argument, but given: #");
-
- queueErrorTest("acos given too many args",
- "(acos 1 1)",
- "acos: expects 1 argument, but given 2: 1 1");
- //next trig func
-
- queueErrorTest("atan given no args",
- "(atan)",
- "atan: expects 1 argument, but given 0");
-
- queueErrorTest("atan given 1 bad arg",
- "(atan add1)",
- "atan: expects a number as 1st argument, but given: #");
-
- queueErrorTest("atan given too many args",
- "(atan 1 1)",
- "atan: expects 1 argument, but given 2: 1 1");
- //next trig func
-
-
- queueErrorTest("sinh given no args",
- "(sinh)",
- "sinh: expects 1 argument, but given 0");
-
- queueErrorTest("sinh given 1 bad arg",
- "(sinh add1)",
- "sinh: expects a number as 1st argument, but given: #");
-
- queueErrorTest("sinh given too many args",
- "(sinh 1 1)",
- "sinh: expects 1 argument, but given 2: 1 1");
- //next trig func
-
- queueErrorTest("cosh given no args",
- "(cosh)",
- "cosh: expects 1 argument, but given 0");
-
- queueErrorTest("cosh given 1 bad arg",
- "(cosh add1)",
- "cosh: expects a number as 1st argument, but given: #");
-
- queueErrorTest("cosh given too many args",
- "(cosh 1 1)",
- "cosh: expects 1 argument, but given 2: 1 1");
-
- queueErrorTest("sqr given no args",
- "(sqr)",
- "sqr: expects 1 argument, but given 0");
-
- queueErrorTest("sqr given 1 bad arg",
- "(sqr add1)",
- "sqr: expects a number as 1st argument, but given: #");
-
- queueErrorTest("sqr given too many args",
- "(sqr 1 1)",
- "sqr: expects 1 argument, but given 2: 1 1");
-
- queueErrorTest("sqrt given no args",
- "(sqrt)",
- "sqrt: expects 1 argument, but given 0");
-
- queueErrorTest("sqrt given 1 bad arg",
- "(sqrt add1)",
- "sqrt: expects a number as 1st argument, but given: #");
-
- queueErrorTest("sqrt given too many args",
- "(sqrt 1 1)",
- "sqrt: expects 1 argument, but given 2: 1 1");
-
- queueErrorTest("integer-sqrt given no args",
- "(integer-sqrt)",
- "integer-sqrt: expects 1 argument, but given 0");
-
- queueErrorTest("integer-sqrt given 1 bad arg",
- "(integer-sqrt add1)",
- "integer-sqrt: expects an integer as 1st argument, but given: #");
-
- queueErrorTest("integer-sqrt given too many args",
- "(integer-sqrt 1 1)",
- "integer-sqrt: expects 1 argument, but given 2: 1 1");
-
- queueErrorTest("make-rectangular given no args",
- "(make-rectangular)",
- "make-rectangular: expects 2 arguments, but given 0");
-
- queueErrorTest("make-rectangular given bad first arg, good 2nd",
- "(make-rectangular add1 1)",
- "make-rectangular: expects a real as 1st argument, but given: #; other arguments were: 1");
-
-
- queueErrorTest("make-rectangular given good first, bad second arg",
- "(make-rectangular 1 add1)",
- "make-rectangular: expects a real as 2nd argument, but given: #; other arguments were: 1");
-
- queueErrorTest("make-rectangular given too many args",
- "(make-rectangular 1 1 1 1 1)",
- "make-rectangular: expects 2 arguments, but given 5: 1 1 1 1 1");
-
- queueErrorTest("make-polar given no args",
- "(make-polar)",
- "make-polar: expects 2 arguments, but given 0");
-
- queueErrorTest("make-polar given bad first arg, good 2nd",
- "(make-polar add1 1)",
- "make-polar: expects a real as 1st argument, but given: #