/**
 * Dump some data to the console in JSON
 *
 * @param{Array.<any>} xs - objects to be dumped
 * @returns{void}         - all xs would have been dumped to console.
 */
function dump(...xs) { ... }

/**
 * Deep comparison.
 *
 * NOTE: Exhaustive enough for our purposes.
 *
 * @param{any}       a - first  object to compare.
 * @param{any}       b - second object to compare.
 * @returns{boolean}   - true if a and b are equals, false otherwise.
 */
function dcmp(a, b) {
	...
}

/**
 * Run a single test.
 *
 * NOTE: we're a bit lazy when comparing to error. Perhaps
 * we could add an additional entry for that instead of using
 * expected. This is of little practical importance for now.
 *
 * @this{any}                        -
 * @param{function}         f        - function to test
 * @param{Array.<any>}      args     - array of arguments for f
 * @param{any}              expected - expected value for f(args)
 * @param{string}           descr    - test description
 * @param{string|undefined} error    - expected error (exception)
 * @returns{boolean}                 - true if test executed successfully
 *
 * In case of failure, got/expected are dumped as JSON on the console.
 */
function run1(f, args, expected, descr, error) {
	var got;

	try {
		got      = f.apply(this, args);
	} catch(e) {
		console.log(e);
		got      = e.toString();
		expected = error || "<!no error were expected!>";
	}

	var ok  = dcmp(got, expected);

	console.log("["+(ok ? "OK" : "KO")+"] "+f.name+": "+descr);
	if (!ok) {
		console.log("Got:", );
		dump(got);
		console.log("Expected: ");
		dump(expected);
	}
	return ok;
}

/**
 * Run multiple tests, stopping on failure.
 *
 * @param{Array.<Test>} tests - tests to run
 * @returns{boolean}          - true iff all tests were run successfully
 */
function run(tests) {
	return tests.reduce(
		/** @type{(ok : boolean, t : Test) => boolean} */
		function(ok, t) {
			return ok && run1(t.f, t.args, t.expected, t.descr, t.error);
		},
		true
	);
}

package FTests;

use strict;
use warnings;

# Test::Deep::cmp_deeply() would be slightly better
# than Test::More::is_deeply(), but Test::More comes
# with a default perl(1) installation.
use Test::More;

use B;

# Retrieve a name for a coderef.
#
# See https://stackoverflow.com/a/7419346
#
# Input:
#	$_[0] : coderef
# Output:
#	string, generally module::fn
sub getsubname {
	...
}

# A test is encoded as a hashref containing:
#
# {
#	"f"        => \&function_pointer,
#	"fn"       => $optional_function_name,
#	"args"     => $arrayref_holding_input_arguments,
#	"expected" => $expected_output_values
#	"descr"    => "Test description, string",
# }

# Run a single test.
#
# Input:
#	$_[0] : hashref describing the test (see above)
# Output:
#	Boolean: 1 if the test was successfully executed,
#	0 otherwise.
#
#	May die().
sub run1 {
	my ($test) = @_;

	my (
		$f,
		$fn,
		$args,
		$expected,
		$descr,
	) = @{$test}{qw(f fn args expected descr)};

	my $n = $fn || FTests::getsubname($f);

	# NOTE: We could manage exceptions
	return Test::More::is_deeply(
		$f->(@$args),
		$expected,
		sprintf("% -35s: %s", $n, $descr),
	);
}

# Run a list of tests in order, stopping in case of
# failure.
#
# Input:
#	$_[0] : arrayref of tests
# Output:
#	Boolean: 1 if all tests were successfully executed,
#	0 otherwise.
#
#	May die().
sub run {
	my ($tests) = @_;

	foreach my $test (@$tests) {
		return 0 unless(FTests::run1($test));
	}

	return 1;
}

import * as FTests from '../modules/ftests.js'

FTests.run([
	/*
	 * dcmp()
	 */
	{
		f        : Ftests.dcmp,
		args     : [1, 1],
		expected : true,
		descr    : "Integers, equals",
	},
	{
		f        : Ftests.dcmp,
		args     : [1, 2],
		expected : false,
		descr    : "Integers, not equals",
	},
	...
	{
		f        : Ftests.dcmp,
		args     : [{}, []],
		expected : false,
		descr    : "Empty hash is not an array",
	},
	{
		f        : Ftests.dcmp,
		args     : [{}, {}],
		expected : true,
		descr    : "Hashes, empty, equals",
	},
	...
	{
		f        : Ftests.dcmp,
		args     : [{foo : [1, 2, [3, 1]]}, {foo : [1, 2, [3, 1]]}],
		expected : true,
		descr    : "Deep object, equals",
	},
	{
		f        : Ftests.dcmp,
		args     : [{foo : [1, 2, [3, 1]]}, {foo : [1, 2, [3, 1, {}]]}],
		expected : false,
		descr    : "Deep object, not equals",
	},
]);

#!/usr/bin/perl

use strict;
use warnings;

use File::Basename;
use lib File::Basename::dirname (__FILE__);

use Test::More;
use FTests;

sub id { return $_[0]; }

FTests::run([
	{
		"f"        => sub { return $_[0]; },
		"fn"       => '(\\x = x)',
		"args"     => [1],
		"expected" => 1,
		"descr"    => "(\\x = x) 1",
	},
	{
		"f"        => \&id,
		"args"     => [{foo=>"bar"}],
		"expected" => {foo=>"bar"},
		"descr"    => "id({foo=>'bar'}) = {foo=>'bar'}",
	},
	{
		"f"        => \&FTests::run,
		"args"     => [[{
			"f"        => \&id,
			"fn"       => "FTests::run([id])",
			"args"     => [{foo=>"baz"}],
			"expected" => {foo=>"baz"},
			"descr"    => "id({foo=>'baz'}) = {foo=>'baz'}",
		}]],
		"expected" => 1,
		"descr"    => "going meta",
	},
]);

Test::More::done_testing();