/*
 * Copyright (c) 2008-2010 Stefan Krah. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */


#include "mpdecimal.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <ctype.h>
#include <errno.h>
#include <limits.h>
#include <locale.h>
#include <time.h>
#include "io.h"
#include "memory.h"
#include "mptest.h"
#include "mptypes.h"
#include "malloc_fail.h"


#define MAXLINE 400000
#define MAXTOKEN 32


#ifndef _MSC_VER
  #include <inttypes.h>
  #define ASSERT(p) if (!(p)) {abort();}
#else
  #define ASSERT(p) if (!(p)) {mpd_err_fatal("assertion failed");}
#endif


int have_fail = 0;
int have_printed = 0;


static void
mpd_init_rand(mpd_t *x)
{
	long r = random() % 100;
	uint8_t sign = random()%2;

	if (r >= 80) {
		mpd_minalloc(x);
	}
	else if (r >= 60) {
		mpd_minalloc(x);
		mpd_set_flags(x, sign);
	}
	else if (r >= 40) {
		mpd_setspecial(x, sign, MPD_NAN);
	}
	else if (r >= 20) {
		mpd_setspecial(x, sign, MPD_SNAN);
	}
	else {
		mpd_setspecial(x, sign, MPD_INF);
	}
}

static void
mpd_readcontext(mpd_context_t *ctx)
{
#if defined(CONFIG_64)
	ctx->prec=1070000000000000000;
	ctx->emax=1070000000000000000;
	ctx->emin=-1070000000000000000;
#elif defined(CONFIG_32)
	/* These ranges are needed for the official testsuite
	 * and are generally not problematic at all. */
	ctx->prec=1070000000;
	ctx->emax=1070000000;
	ctx->emin=-1070000000;
#else
  #error "config not defined"
#endif
	ctx->round=MPD_ROUND_HALF_UP;
	ctx->traps=MPD_Traps;
	ctx->status=0;
	ctx->newtrap=0;
	ctx->clamp=0;
	ctx->allcr=0;
}

static void
mpd_testcontext(mpd_context_t *ctx)
{
#if defined(CONFIG_64)
	ctx->prec=999999999;
	ctx->emax=MPD_MAX_EMAX;
	ctx->emin=MPD_MIN_EMIN;
#elif defined(CONFIG_32)
	/* These ranges are needed for the official testsuite
	 * and are generally not problematic at all. */
	ctx->prec=999999999;
	ctx->emax=999999999;
	ctx->emin=-999999999;
#else
  #error "config not defined"
#endif
	ctx->round=MPD_ROUND_HALF_UP;
	ctx->traps=MPD_Traps;
	ctx->status=0;
	ctx->newtrap=0;
	ctx->clamp=0;
	ctx->allcr=0;
}

/* Known differences that are within the spec */
struct result_diff {
	const char *id;
	const char *calc;
	const char *expected;
};

struct status_diff {
	const char *id;
	uint32_t calc;
	uint32_t expected;
};

struct result_diff ulp_cases[] = {
	/* Cases where the result is allowed to differ by less than one ULP.
	 * Only needed if ctx->allcr is 0. */
	{ "expx013", "1.001000", "1.001001" },
	{ "expx020", "1.000000", "1.000001" },
	{ "expx109", "0.999999910000004049999878", "0.999999910000004049999879" },
	{ "expx1036", "1.005088", "1.005087" },
	{ "expx350", "1.0000000", "1.0000001" },
	{ "expx351", "1.0000000", "1.0000001" },
	{ "expx352", "1.0000000", "1.0000001" },
	{NULL, NULL, NULL}
};

struct status_diff status_cases[] = {
	/* With a reduced working precision in mpd_qpow() the status matches. */
	{ "pwsx803", MPD_Inexact|MPD_Rounded|MPD_Subnormal|MPD_Underflow, MPD_Inexact|MPD_Rounded },
	{NULL, 0, 0}
};

char *skipit[] = {
	/* NULL reference, decimal16, decimal32, or decimal128 */
	"absx900",
	"addx9990",
	"addx9991",
	"clam090",
	"clam091",
	"clam092",
	"clam093",
	"clam094",
	"clam095",
	"clam096",
	"clam097",
	"clam098",
	"clam099",
	"clam189",
	"clam190",
	"clam191",
	"clam192",
	"clam193",
	"clam194",
	"clam195",
	"clam196",
	"clam197",
	"clam198",
	"clam199",
	"comx990",
	"comx991",
	"cotx9990",
	"cotx9991",
	"ctmx9990",
	"ctmx9991",
	"ddabs900",
	"ddadd9990",
	"ddadd9991",
	"ddcom9990",
	"ddcom9991",
	"ddcot9990",
	"ddcot9991",
	"ddctm9990",
	"ddctm9991",
	"dddiv9998",
	"dddiv9999",
	"dddvi900",
	"dddvi901",
	"ddfma2990",
	"ddfma2991",
	"ddfma39990",
	"ddfma39991",
	"ddlogb900",
	"ddmax900",
	"ddmax901",
	"ddmxg900",
	"ddmxg901",
	"ddmin900",
	"ddmin901",
	"ddmng900",
	"ddmng901",
	"ddmul9990",
	"ddmul9991",
	"ddnextm900",
	"ddnextm900",
	"ddnextp900",
	"ddnextp900",
	"ddnextt900",
	"ddnextt901",
	"ddqua998",
	"ddqua999",
	"ddred900",
	"ddrem1000",
	"ddrem1001",
	"ddrmn1000",
	"ddrmn1001",
	"ddsub9990",
	"ddsub9991",
	"ddintx074",
	"ddintx094",
	"divx9998",
	"divx9999",
	"dvix900",
	"dvix901",
	"dqabs900",
	"dqadd9990",
	"dqadd9991",
	"dqcom990",
	"dqcom991",
	"dqcot9990",
	"dqcot9991",
	"dqctm9990",
	"dqctm9991",
	"dqdiv9998",
	"dqdiv9999",
	"dqdvi900",
	"dqdvi901",
	"dqfma2990",
	"dqfma2991",
	"dqadd39990",
	"dqadd39991",
	"dqlogb900",
	"dqmax900",
	"dqmax901",
	"dqmxg900",
	"dqmxg901",
	"dqmin900",
	"dqmin901",
	"dqmng900",
	"dqmng901",
	"dqmul9990",
	"dqmul9991",
	"dqnextm900",
	"dqnextp900",
	"dqnextt900",
	"dqnextt901",
	"dqqua998",
	"dqqua999",
	"dqred900",
	"dqrem1000",
	"dqrem1001",
	"dqrmn1000",
	"dqrmn1001",
	"dqsub9990",
	"dqsub9991",
	"dqintx074",
	"dqintx094",
	"expx900",
	"fmax2990",
	"fmax2991",
	"fmax39990",
	"fmax39991",
	"lnx900",
	"logx900",
	"logbx900",
	"maxx900",
	"maxx901",
	"mxgx900",
	"mxgx901",
	"mnm900",
	"mnm901",
	"mng900",
	"mng901",
	"minx900",
	"mulx990",
	"mulx991",
	"nextm900",
	"nextp900",
	"nextt900",
	"nextt901",
	"plu900",
	"powx900",
	"powx901",
	"pwsx900",
	"quax1022",
	"quax1023",
	"quax1024",
	"quax1025",
	"quax1026",
	"quax1027",
	"quax1028",
	"quax1029",
	"quax0a2",
	"quax0a3",
	"quax998",
	"quax999",
	"redx900",
	"remx1000",
	"remx1001",
	"rmnx900",
	"rmnx901",
	"sqtx9900",
	"subx9990",
	"subx9991",
	/* operand range violations, invalid context */
	"expx901",
	"expx902",
	"expx903",
	"expx905",
	"lnx901",
	"lnx902",
	"lnx903",
	"lnx905",
	"logx901",
	"logx902",
	"logx903",
	"logx905",
	"powx1183",
	"powx1184",
	"powx4001",
	"powx4002",
	"powx4003",
	"powx4005",
	"powx4008",
	"powx4010",
	"powx4012",
	"powx4014",
	"scbx164",
	"scbx165",
	"scbx166",
	/* skipped for decNumber, too */
	"powx4302",
	"powx4303",
	"powx4303",
	"powx4342",
	"powx4343",
	"pwsx805",
	/* disagreement for three arg power */
	"pwmx325",
	"pwmx326",
	NULL
};

static inline int
startswith(const char *token, const char *s)
{
	return strncasecmp(token, s, strlen(s)) == 0;
}

static inline int
eqtoken(const char *token, const char *s)
{
	return strcasecmp(token, s) == 0;
}

static int
check_skip(char *id)
{
	int i;

	for (i = 0; skipit[i] != NULL; i++) {
		if (eqtoken(id, skipit[i])) {
#if RT_VERBOSITY == 2
			if (!have_printed) {
				fputs("\n\n", stderr);
				have_printed = 1;
			}
			fprintf(stderr, "SKIP: %s\n", id);
#endif
			return 1;
		}
	}

	return 0;
}

static char *
nexttoken(char *cp)
{
	static char *start;
	static char *end;

	if (cp == NULL)
		cp = end;

	for (; *cp != '\0'; cp++) {
		if (isspace((unsigned char)*cp)) {
			;
		}
		else if (*cp == '"') {
			start = end = cp+1;
			for (; *end != '\0'; end++) {
				if (*end == '"' && *(end+1) == '"')
					end += 1;
				else if (*end == '"')
					break;
			}
			if (*end == '\0')
				return NULL;
			*end++ = '\0';
			return start;
		}
		else if (*cp == '\'') {
			start = end = cp+1;
			for (; *end != '\0'; end++) {
				if (*end == '\'' && *(end+1) == '\'')
					end += 1;
				else if (*end == '\'')
					break;
			}
			if (*end == '\0')
				return NULL;
			*end++ = '\0';
			return start;
		}
		else {
			start = end = cp;
			for (; *end != '\0'; end++)
				if (isspace((unsigned char)*end))
					break;
			if (*end == '\0')
				return NULL;
			*end++ = '\0';
			return start;
		}
	}

	return NULL;
}

/* split a line into tokens */
static int
split(char *token[], char line[])
{
	char *cp;
	size_t len;
	int n = 0;

	cp = nexttoken(line);
	while (n < MAXTOKEN && cp != NULL) {
		len = strlen(cp);
		if ((token[n] = malloc(len+1)) == NULL) {
			mpd_err_fatal("out of memory");
		}
		strcpy(token[n], cp);
		cp = nexttoken(NULL);
		n++;
	}
	token[n] = NULL;

	return n;
}

static void
freetoken(char **token)
{
	while (*token != NULL) {
		free(*token++);
	}
}

/* returns all expected conditions in a status flag */
static uint32_t
scan_conditions(char **token)
{
	char *condition = *token;
	uint32_t status = 0;

	while (condition != NULL) {

		if (startswith(condition, "--"))
			break;
		else if (eqtoken(condition, "Clamped"))
			status |= MPD_Clamped;
		else if (eqtoken(condition, "Conversion_syntax"))
			status |= MPD_Conversion_syntax;
		else if (eqtoken(condition, "Division_by_zero"))
			status |= MPD_Division_by_zero;
		else if (eqtoken(condition, "Division_impossible"))
			status |= MPD_Division_impossible;
		else if (eqtoken(condition, "Division_undefined"))
			status |= MPD_Division_undefined;
		else if (eqtoken(condition, "Fpu_error"))
			status |= MPD_Fpu_error;
		else if (eqtoken(condition, "Inexact"))
			status |= MPD_Inexact;
		else if (eqtoken(condition, "Invalid_context"))
			status |= MPD_Invalid_context;
		else if (eqtoken(condition, "Invalid_operation"))
			status |= MPD_Invalid_operation;
		else if (eqtoken(condition, "Malloc_error"))
			status |= MPD_Malloc_error;
		else if (eqtoken(condition, "Not_implemented"))
			status |= MPD_Not_implemented;
		else if (eqtoken(condition, "Overflow"))
			status |= MPD_Overflow;
		else if (eqtoken(condition, "Rounded"))
			status |= MPD_Rounded;
		else if (eqtoken(condition, "Subnormal"))
			status |= MPD_Subnormal;
		else if (eqtoken(condition, "Underflow"))
			status |= MPD_Underflow;
		else
			mpd_err_fatal("unknown status: %s", condition);

		condition = *(++token);
	}

	return status;
}

static void
compare_expected(const char *calc, const char *expected, uint32_t expected_status,
                 char *id, mpd_context_t *ctx)
{
	char ctxstatus[MPD_MAX_FLAG_STRING];
	char expstatus[MPD_MAX_FLAG_STRING];


#ifndef RT_VERBOSITY
	/* Do not print known pseudo-failures. */
	int i;

	/* known ULP diffs */
	if (ctx->allcr == 0) {
		for (i = 0; ulp_cases[i].id != NULL; i++) {
			if (eqtoken(id, ulp_cases[i].id) &&
			    strcmp(expected, ulp_cases[i].expected) == 0 &&
			    strcmp(calc, ulp_cases[i].calc) == 0) {
				return;
			}
		}
	}

	/* known status diffs */
	for (i = 0; status_cases[i].id != NULL; i++) {
		if (eqtoken(id, status_cases[i].id) &&
		    expected_status == status_cases[i].expected &&
		    ctx->status == status_cases[i].calc) {
			return;
		}
	}
#endif

	if (strcmp(calc, expected) != 0) {
		if (!have_printed) {
			fputs("\n\n", stderr);
			have_printed = 1;
		}
		fprintf(stderr, "FAIL: %s  calc: %s  expected: %s\n",
		                id, calc, expected);
		have_fail = 1;
	}
	if (ctx->status != expected_status) {
		if (!have_printed) {
			fputs("\n\n", stderr);
			have_printed = 1;
		}
		mpd_snprint_flags(ctxstatus, MPD_MAX_FLAG_STRING, ctx->status),
		mpd_snprint_flags(expstatus, MPD_MAX_FLAG_STRING, expected_status);
		fprintf(stderr, "FAIL: %s: status:  calc: %s  expected: %s\n",
		        id, ctxstatus, expstatus);
		have_fail = 1;
	}
}

static int
equalmem(const mpd_t *a, const mpd_t *b)
{
	mpd_ssize_t i;

	if (a->flags != b->flags) return 0;
	if (a->exp != b->exp) return 0;
	if (a->len != b->len) return 0;
	if (a->digits != b->digits) return 0;
	for (i = 0; i < a->len; i++)
		if (a->data[i] != b->data[i])
			return 0;
	return 1;
}

static void
check_equalmem(const mpd_t *a, const mpd_t *b, char *id)
{
	if (!equalmem(a, b)) {
		fprintf(stderr, "FAIL: const arg changed: %s\n", id);
	}
}

static unsigned long
get_testno(char *token)
{
	char *number;

	number = strpbrk(token, "0123456789");
	return strtoul(number, NULL, 10);
}

/* scan a single operand and the expected result */
static int
scan_1op_result(mpd_t *op1, char **result, char *token[], mpd_context_t *ctx)
{
	/* operand 1 */
	if (token[2] == NULL) {
		mpd_err_fatal("parse error at id %s", token[0]);
	}
	mpd_set_string(op1, token[2], ctx);

	/* discard "->" */
	if (token[3] == NULL) {
		mpd_err_fatal("parse error at id %s", token[0]);
	}

	/* expected result */
	if (token[4] == NULL) {
		mpd_err_fatal("parse error at id %s", token[0]);
	}
	*result = token[4];

	return 5;
}

/* scan a single operand and two results */
static int
scan_1op_2results(mpd_t *op1, char **result1, char **result2, char *token[], mpd_context_t *ctx)
{
	/* operand 1 */
	if (token[2] == NULL) {
		mpd_err_fatal("parse error at id %s", token[0]);
	}
	mpd_set_string(op1, token[2], ctx);

	/* discard "->" */
	if (token[3] == NULL) {
		mpd_err_fatal("parse error at id %s", token[0]);
	}

	/* expected result1 */
	if (token[4] == NULL) {
		mpd_err_fatal("parse error at id %s", token[0]);
	}
	*result1 = token[4];

	/* expected result2 */
	if (token[5] == NULL) {
		mpd_err_fatal("parse error at id %s", token[0]);
	}
	*result2 = token[5];

	return 6;
}

/* scan decimal operand, string operand and the expected result */
static int
scan_1op_str_result(mpd_t *op1, char **op2, char **result, char *token[], mpd_context_t *ctx)
{
	/* operand 1 */
	if (token[2] == NULL) {
		mpd_err_fatal("%s", token[0]);
	}
	mpd_set_string(op1, token[2], ctx);

	/* operand 2 */
	if (token[3] == NULL) {
		mpd_err_fatal("%s", token[0]);
	}
	*op2 = token[3];

	/* discard "->" */
	if (token[4] == NULL) {
		mpd_err_fatal("%s", token[0]);
	}

	/* expected result */
	if (token[5] == NULL) {
		mpd_err_fatal("%s", token[0]);
	}
	*result = token[5];

	return 6;
}

/* scan two operands and the expected result */
static int
scan_2ops_result(mpd_t *op1, mpd_t *op2, char **result, char *token[], mpd_context_t *ctx)
{
	/* operand 1 */
	if (token[2] == NULL) {
		mpd_err_fatal("%s", token[0]);
	}
	mpd_set_string(op1, token[2], ctx);

	/* operand 2 */
	if (token[3] == NULL) {
		mpd_err_fatal("%s", token[0]);
	}
	mpd_set_string(op2, token[3], ctx);

	/* discard "->" */
	if (token[4] == NULL) {
		mpd_err_fatal("%s", token[0]);
	}

	/* expected result */
	if (token[5] == NULL) {
		mpd_err_fatal("%s", token[0]);
	}
	*result = token[5];

	return 6;
}

/* scan two operands and two results */
static int
scan_2ops_2results(mpd_t *op1, mpd_t *op2, char **result1, char **result2, char *token[], mpd_context_t *ctx)
{
	/* operand 1 */
	if (token[2] == NULL) {
		mpd_err_fatal("%s", token[0]);
	}
	mpd_set_string(op1, token[2], ctx);

	/* operand 2 */
	if (token[3] == NULL) {
		mpd_err_fatal("%s", token[0]);
	}
	mpd_set_string(op2, token[3], ctx);

	/* discard "->" */
	if (token[4] == NULL) {
		mpd_err_fatal("%s", token[0]);
	}

	/* expected result1 */
	if (token[5] == NULL) {
		mpd_err_fatal("%s", token[0]);
	}
	*result1 = token[5];

	/* expected result2 */
	if (token[6] == NULL) {
		mpd_err_fatal("%s", token[0]);
	}
	*result2 = token[6];

	return 7;
}

/* scan three operands and the expected result */
static int
scan_3ops_result(mpd_t *op1, mpd_t *op2, mpd_t *op3, char **result, char *token[], mpd_context_t *ctx)
{
	/* operand 1 */
	if (token[2] == NULL) {
		mpd_err_fatal("%s", token[0]);
	}
	mpd_set_string(op1, token[2], ctx);

	/* operand 2 */
	if (token[3] == NULL) {
		mpd_err_fatal("%s", token[0]);
	}
	mpd_set_string(op2, token[3], ctx);

	/* operand 2 */
	if (token[4] == NULL) {
		mpd_err_fatal("%s", token[0]);
	}
	mpd_set_string(op3, token[4], ctx);

	/* discard "->" */
	if (token[5] == NULL) {
		mpd_err_fatal("%s", token[0]);
	}

	/* expected result */
	if (token[6] == NULL) {
		mpd_err_fatal("%s", token[0]);
	}
	*result = token[6];

	return 7;
}

mpd_t *op, *op1, *op2, *op3;
mpd_t *tmp, *tmp1, *tmp2, *tmp3;
mpd_t *result, *result1, *result2;


/*
 * Test a function returning pointer to char, accepting:
 *     op1, context
 *
 * This function is used for "toSci", "toEng" and "apply"
 * and does not use a maxctx for the conversion of the operand.
 */
static void
_cp_MpdCtx(char **token, char *(*func)(const mpd_t *, int), mpd_context_t *ctx)
{
	char *calc;
	char *expected, *expected_fail;
	uint32_t expstatus;
	int n;

	ctx->status = 0;
	/* status should be set in conversion */
	n = scan_1op_result(op, &expected, token, ctx);

	/* scan expected conditions */
	expstatus = scan_conditions(token+n);

	/* Allocation failures for mpd_set_string */
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		mpd_init_rand(tmp);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		(void)scan_1op_result(tmp, &expected_fail, token, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(tmp))
	}
	ASSERT(strcmp(expected, expected_fail) == 0)
	ASSERT(mpd_cmp_total(tmp, op) == 0)


	/* make a copy of the operand */
	mpd_init_rand(tmp);
	mpd_copy(tmp, op, ctx);

	calc = func(tmp, 1);

	/* compare the calculated result to the expected result */
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp, op, token[0]);

	/* Allocation failures */
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		mpd_init_rand(tmp);
		mpd_copy(tmp, op, ctx);

		mpd_set_alloc_fail(ctx);
		calc = func(tmp, 1);
		mpd_set_alloc(ctx);

		if (calc != NULL) {
			break;
		}
	}
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp, op, token[0]);
}

/* Quick and dirty: parse hex escape sequences as printed in bytestring
 * output of Python3x. */
static char *
parse_escapes(const char *s)
{
	char hex[5];
	char *result, *cp;
	unsigned int u;
	int n;

	cp = result = malloc(strlen(s)+1);
	if (result == NULL) {
		return NULL;
	}

	hex[0] = '0';
	hex[1] = '\0';
	while (*s) {
		if (*s == '\\' && *(s+1) == 'x') {
			for (n = 1; n < 4; n++) {
				if (!s[n]) {
					free(result);
					return NULL;
				}
				hex[n] = s[n];
			}
			hex[n] = '\0';
			sscanf(hex, "%x%n", &u, &n);
			*cp++ = u;
			s += n;
		}
		else {
			*cp++ = *s++;
		}
	}

	*cp = '\0';
	return result;
}

/*
 * Test a function returning pointer to char, accepting:
 *     op1, fmt, context
 *
 * This function is used for "mpd_format".
 */
static void
_cp_MpdFmtCtx(char **token, char *(*func)(const mpd_t *, const char *, mpd_context_t *), mpd_context_t *ctx)
{
	mpd_context_t maxctx;
	char *fmt;
	char *calc;
	char *expected;
	uint32_t expstatus;
	int n;

	mpd_readcontext(&maxctx);
	maxctx.traps = MPD_Malloc_error;

	/* conversion should be done as if there were no limits */
	n = scan_1op_str_result(op1, &fmt, &expected, token, &maxctx);

	fmt = parse_escapes(fmt);
	expected = parse_escapes(expected);

	expstatus = scan_conditions(token+n);

	mpd_init_rand(tmp);
	mpd_copy(tmp, op1, ctx);
	ctx->status = 0;

	calc = func(tmp, fmt, ctx);

	if (calc == NULL) {
		calc = __mingw_dfp_get_globals()->mpd_callocfunc(1,5);
		memcpy(calc,"NULL",4);
	}
	/* compare the calculated result to the expected result */
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp, op1, token[0]);

	/* Allocation failures */
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		mpd_init_rand(tmp);
		mpd_copy(tmp, op1, ctx);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		calc = func(tmp, fmt, ctx);
		mpd_set_alloc(ctx);
		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(calc == NULL)
	}
	if (calc == NULL) {
		calc = __mingw_dfp_get_globals()->mpd_callocfunc(1,5);
		memcpy(calc,"NULL",4);
	}
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp, op1, token[0]);

	free(fmt);
	free(expected);
}

/*
 * Test a function returning pointer to const char, accepting:
 *     op1, context
 */
static void
_ccp_MpdCtx(char **token, const char *(*func)(const mpd_t *, const mpd_context_t *), mpd_context_t *ctx)
{
	mpd_context_t maxctx;
	const char *calc;
	char *expected;
	uint32_t expstatus;
	int n;

	mpd_readcontext(&maxctx);
	maxctx.traps = MPD_Malloc_error;

	/* conversion should be done as if there were no limits */
	n = scan_1op_result(op, &expected, token, &maxctx);

	/* scan expected conditions */
	expstatus = scan_conditions(token+n);


	mpd_init_rand(tmp);
	mpd_copy(tmp, op, ctx);
	ctx->status = 0;

	calc = func(tmp, ctx);

	compare_expected(calc, expected, expstatus, token[0], ctx);
	check_equalmem(tmp, op, token[0]);

	/* Allocation failures */
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		mpd_init_rand(tmp);
		mpd_copy(tmp, op, ctx);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		calc = func(tmp, ctx);
		mpd_set_alloc(ctx);
		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(calc == NULL)
	}
	compare_expected(calc, expected, expstatus, token[0], ctx);
	check_equalmem(tmp, op, token[0]);
}

/* Test a unary function */
static void
_Res_Op_Ctx(char *token[], void (*func)(mpd_t *, const mpd_t *, mpd_context_t *), mpd_context_t *ctx)
{
	mpd_context_t maxctx;
	char *calc;
	char *expected;
	uint32_t expstatus;
	int n, incr;

	mpd_readcontext(&maxctx);
	maxctx.traps = MPD_Malloc_error;

	n = scan_1op_result(op, &expected, token, &maxctx);

	/* scan expected conditions */
	expstatus = scan_conditions(token+n);


	/* result and tmp are distinct decimals */
	mpd_init_rand(tmp);
	mpd_copy(tmp, op, ctx);
	mpd_init_rand(result);
	ctx->status = 0;

	mpd_set_alloc_count(ctx);
	func(result, tmp, ctx);
	mpd_set_alloc(ctx);

	calc = mpd_to_sci(result, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp, op, token[0]);

	/* Allocation failures */
	incr = 1;
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail += incr) {
		mpd_init_rand(tmp);
		mpd_copy(tmp, op, ctx);
		mpd_minalloc(result);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		func(result, tmp, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(result))

		if (alloc_fail > 50) {
			incr = (int)(alloc_count*0.02) + 1;
		}
	}
	calc = mpd_to_sci(result, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp, op, token[0]);


	/* result equals operand */
	mpd_init_rand(tmp);
	mpd_copy(tmp, op, ctx);
	ctx->status = 0;

	mpd_set_alloc_count(ctx);
	func(tmp, tmp, ctx);
	mpd_set_alloc(ctx);

	calc = mpd_to_sci(tmp, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	/* Allocation failures */
	incr = 1;
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail += incr) {
		mpd_init_rand(tmp);
		mpd_copy(tmp, op, ctx);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		func(tmp, tmp, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(tmp))

		if (alloc_fail > 50) {
			incr = (int)(alloc_count*0.02) + 1;
		}
	}
	calc = mpd_to_sci(tmp, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
}

/* Test a binary function */
static void
_Res_Binop_Ctx(char *token[], void (*func)(mpd_t *, const mpd_t *, const mpd_t *, mpd_context_t *), mpd_context_t *ctx)
{
	mpd_context_t maxctx;
	char *calc;
	char *expected;
	uint32_t expstatus;
	int n, incr;

	mpd_readcontext(&maxctx);
	maxctx.traps = MPD_Malloc_error;

	n = scan_2ops_result(op1, op2, &expected, token, &maxctx);

	/* scan expected conditions */
	expstatus = scan_conditions(token+n);


	/* three distinct decimals */
	mpd_init_rand(tmp1);
	mpd_init_rand(tmp2);
	mpd_copy(tmp1, op1, ctx);
	mpd_copy(tmp2, op2, ctx);
	mpd_init_rand(result);
	ctx->status = 0;

	mpd_set_alloc_count(ctx);
	func(result, tmp1, tmp2, ctx);
	mpd_set_alloc(ctx);

	calc = mpd_to_sci(result, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp1, op1, token[0]);
	check_equalmem(tmp2, op2, token[0]);

	/* Allocation failures */
	incr = 1;
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail += incr) {
		mpd_init_rand(tmp1);
		mpd_init_rand(tmp2);
		mpd_copy(tmp1, op1, ctx);
		mpd_copy(tmp2, op2, ctx);
		mpd_minalloc(result);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		func(result, tmp1, tmp2, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(result))

		if (alloc_fail > 50) {
			incr = (int)(alloc_count*0.02) + 1;
		}
	}
	calc = mpd_to_sci(result, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp1, op1, token[0]);
	check_equalmem(tmp2, op2, token[0]);


	/* result == tmp1 */
	mpd_init_rand(tmp1);
	mpd_init_rand(tmp2);
	mpd_copy(tmp1, op1, ctx);
	mpd_copy(tmp2, op2, ctx);
	ctx->status = 0;

	mpd_set_alloc_count(ctx);
	func(tmp1, tmp1, tmp2, ctx);
	mpd_set_alloc(ctx);

	calc = mpd_to_sci(tmp1, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp2, op2, token[0]);

	/* Allocation failures */
	incr = 1;
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail += incr) {
		mpd_init_rand(tmp1);
		mpd_init_rand(tmp2);
		mpd_copy(tmp1, op1, ctx);
		mpd_copy(tmp2, op2, ctx);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		func(tmp1, tmp1, tmp2, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(tmp1))

		if (alloc_fail > 50) {
			incr = (int)(alloc_count*0.02) + 1;
		}
	}
	calc = mpd_to_sci(tmp1, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp2, op2, token[0]);


	/* result == tmp2 */
	mpd_init_rand(tmp1);
	mpd_init_rand(tmp2);
	mpd_copy(tmp1, op1, ctx);
	mpd_copy(tmp2, op2, ctx);
	ctx->status = 0;

	mpd_set_alloc_count(ctx);
	func(tmp2, tmp1, tmp2, ctx);
	mpd_set_alloc(ctx);

	calc = mpd_to_sci(tmp2, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp1, op1, token[0]);

	/* Allocation failures */
	incr = 1;
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail += incr) {
		mpd_init_rand(tmp1);
		mpd_init_rand(tmp2);
		mpd_copy(tmp1, op1, ctx);
		mpd_copy(tmp2, op2, ctx);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		func(tmp2, tmp1, tmp2, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(tmp2))

		if (alloc_fail > 50) {
			incr = (int)(alloc_count*0.02) + 1;
		}
	}
	calc = mpd_to_sci(tmp2, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp1, op1, token[0]);
}

/* Test a binary function where op1 == op2. */
static void
_Res_EqualBinop_Ctx(char *token[], void (*func)(mpd_t *, const mpd_t *, const mpd_t *, mpd_context_t *), mpd_context_t *ctx)
{
	mpd_context_t maxctx;
	char *calc;
	char *expected;
	uint32_t expstatus;
	int n;

	mpd_readcontext(&maxctx);
	maxctx.traps = MPD_Malloc_error;

	n = scan_1op_result(op, &expected, token, &maxctx);

	/* scan expected conditions */
	expstatus = scan_conditions(token+n);


	/* equal operands, distinct result */
	mpd_init_rand(tmp);
	mpd_copy(tmp, op, ctx);
	mpd_init_rand(result);
	ctx->status = 0;

	func(result, tmp, tmp, ctx);

	/* hack #1 to resolve disagreement with results generated by decimal.py */
	if (expstatus&MPD_Invalid_operation && ctx->status&MPD_Division_impossible) {
		expstatus = MPD_Division_impossible;
	}
	/* hack #2 to resolve disagreement with results generated by decimal.py */
	if (expstatus&MPD_Invalid_operation && ctx->status&MPD_Division_undefined) {
		expstatus = MPD_Division_undefined;
	}
	/* hack #3 to resolve disagreement with results generated by decimal.py (power) */
	if ((startswith(expected, "-0E") || startswith(expected, "0E")) && mpd_isnan(result)) {
		expected = "NaN";
		expstatus = MPD_Invalid_operation;
	}

	calc = mpd_to_sci(result, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp, op, token[0]);

	/* Allocation failures */
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		mpd_init_rand(tmp);
		mpd_copy(tmp, op, ctx);
		mpd_minalloc(result);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		func(result, tmp, tmp, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(result))
	}
	calc = mpd_to_sci(result, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp, op, token[0]);


	/* all parameters equal */
	mpd_init_rand(tmp);
	mpd_copy(tmp, op, ctx);
	ctx->status = 0;

	func(tmp, tmp, tmp, ctx);

	calc = mpd_to_sci(tmp, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	/* Allocation failures */
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		mpd_init_rand(tmp);
		mpd_copy(tmp, op, ctx);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		func(tmp, tmp, tmp, ctx);
		mpd_set_alloc(ctx);
		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(tmp))
	}
	calc = mpd_to_sci(tmp, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
}

/* Test a binary function with a binary result */
static void
_Binres_Binop_Ctx(char *token[], void (*func)(mpd_t *, mpd_t*, const mpd_t *, const mpd_t *, mpd_context_t *), mpd_context_t *ctx)
{
	mpd_context_t maxctx;
	char *calc;
	char *expected1, *expected2;
	uint32_t expstatus;
	int n, incr;

	mpd_readcontext(&maxctx);
	maxctx.traps = MPD_Malloc_error;

	n = scan_2ops_2results(op1, op2, &expected1, &expected2, token, &maxctx);

	/* scan expected conditions */
	expstatus = scan_conditions(token+n);


	/* four distinct decimals */
	mpd_init_rand(tmp1);
	mpd_init_rand(tmp2);
	mpd_copy(tmp1, op1, ctx);
	mpd_copy(tmp2, op2, ctx);
	mpd_init_rand(result1);
	mpd_init_rand(result2);
	ctx->status = 0;

	mpd_set_alloc_count(ctx);
	func(result1, result2, tmp1, tmp2, ctx);
	mpd_set_alloc(ctx);

	/* hack #1 to resolve disagreement with results generated by decimal.py */
	if (expstatus&MPD_Invalid_operation && ctx->status&MPD_Division_impossible) {
		expstatus = MPD_Division_impossible;
	}
	/* hack #2 to resolve disagreement with results generated by decimal.py */
	if (expstatus&MPD_Invalid_operation && ctx->status&MPD_Division_undefined) {
		expstatus = MPD_Division_undefined;
	}
	/* hack #3 to resolve disagreement with results generated by decimal.py */
	if ((startswith(expected1, "-Inf") || startswith(expected1, "Inf")) && mpd_isnan(result1)) {
		expected1 = "NaN";
	}

	calc = mpd_to_sci(result1, 1);
	compare_expected(calc, expected1, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	calc = mpd_to_sci(result2, 1);
	compare_expected(calc, expected2, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	check_equalmem(tmp1, op1, token[0]);
	check_equalmem(tmp2, op2, token[0]);

	/* Allocation failures */
	incr = 1;
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail += incr) {
		mpd_init_rand(tmp1);
		mpd_init_rand(tmp2);
		mpd_copy(tmp1, op1, ctx);
		mpd_copy(tmp2, op2, ctx);
		mpd_minalloc(result1);
		mpd_minalloc(result2);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		func(result1, result2, tmp1, tmp2, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(result1))
		ASSERT(mpd_isnan(result2))

		if (alloc_fail > 50) {
			incr = (int)(alloc_count*0.02) + 1;
		}
	}
	calc = mpd_to_sci(result1, 1);
	compare_expected(calc, expected1, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	calc = mpd_to_sci(result2, 1);
	compare_expected(calc, expected2, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	check_equalmem(tmp1, op1, token[0]);
	check_equalmem(tmp2, op2, token[0]);


	/* result1 == tmp1 */
	mpd_init_rand(tmp1);
	mpd_init_rand(tmp2);
	mpd_copy(tmp1, op1, ctx);
	mpd_copy(tmp2, op2, ctx);
	mpd_init_rand(result2);
	ctx->status = 0;

	mpd_set_alloc_count(ctx);
	func(tmp1, result2, tmp1, tmp2, ctx);
	mpd_set_alloc(ctx);

	calc = mpd_to_sci(tmp1, 1);
	compare_expected(calc, expected1, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	calc = mpd_to_sci(result2, 1);
	compare_expected(calc, expected2, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	check_equalmem(tmp2, op2, token[0]);

	/* Allocation failures */
	incr = 1;
	for (alloc_fail = 1; alloc_fail <= INT_MAX; alloc_fail += incr) {
		mpd_init_rand(tmp1);
		mpd_init_rand(tmp2);
		mpd_copy(tmp1, op1, ctx);
		mpd_copy(tmp2, op2, ctx);
		mpd_minalloc(result2);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		func(tmp1, result2, tmp1, tmp2, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(tmp1))
		ASSERT(mpd_isnan(result2))

		if (alloc_fail > 50) {
			incr = (int)(alloc_count*0.02) + 1;
		}
	}
	calc = mpd_to_sci(tmp1, 1);
	compare_expected(calc, expected1, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	calc = mpd_to_sci(result2, 1);
	compare_expected(calc, expected2, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	check_equalmem(tmp2, op2, token[0]);


	/* result2 == tmp1 */
	mpd_init_rand(tmp1);
	mpd_init_rand(tmp2);
	mpd_copy(tmp1, op1, ctx);
	mpd_copy(tmp2, op2, ctx);
	mpd_init_rand(result1);
	ctx->status = 0;

	mpd_set_alloc_count(ctx);
	func(result1, tmp1, tmp1, tmp2, ctx);
	mpd_set_alloc(ctx);

	calc = mpd_to_sci(result1, 1);
	compare_expected(calc, expected1, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	calc = mpd_to_sci(tmp1, 1);
	compare_expected(calc, expected2, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	check_equalmem(tmp2, op2, token[0]);

	/* Allocation failures */
	incr = 1;
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail += incr) {
		mpd_init_rand(tmp1);
		mpd_init_rand(tmp2);
		mpd_copy(tmp1, op1, ctx);
		mpd_copy(tmp2, op2, ctx);
		mpd_minalloc(result1);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		func(result1, tmp1, tmp1, tmp2, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(result1))
		ASSERT(mpd_isnan(tmp1))

		if (alloc_fail > 50) {
			incr = (int)(alloc_count*0.02) + 1;
		}
	}
	calc = mpd_to_sci(result1, 1);
	compare_expected(calc, expected1, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	calc = mpd_to_sci(tmp1, 1);
	compare_expected(calc, expected2, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	check_equalmem(tmp2, op2, token[0]);


	/* result1 == tmp2 */
	mpd_init_rand(tmp1);
	mpd_init_rand(tmp2);
	mpd_copy(tmp1, op1, ctx);
	mpd_copy(tmp2, op2, ctx);
	mpd_init_rand(result2);
	ctx->status = 0;

	mpd_set_alloc_count(ctx);
	func(tmp2, result2, tmp1, tmp2, ctx);
	mpd_set_alloc(ctx);

	calc = mpd_to_sci(tmp2, 1);
	compare_expected(calc, expected1, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	calc = mpd_to_sci(result2, 1);
	compare_expected(calc, expected2, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	check_equalmem(tmp1, op1, token[0]);

	/* Allocation failures */
	incr = 1;
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail += incr) {
		mpd_init_rand(tmp1);
		mpd_init_rand(tmp2);
		mpd_copy(tmp1, op1, ctx);
		mpd_copy(tmp2, op2, ctx);
		mpd_minalloc(result2);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		func(tmp2, result2, tmp1, tmp2, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(tmp2))
		ASSERT(mpd_isnan(result2))

		if (alloc_fail > 50) {
			incr = (int)(alloc_count*0.02) + 1;
		}
	}
	calc = mpd_to_sci(tmp2, 1);
	compare_expected(calc, expected1, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	calc = mpd_to_sci(result2, 1);
	compare_expected(calc, expected2, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	check_equalmem(tmp1, op1, token[0]);


	/* result2 == tmp2 */
	mpd_init_rand(tmp1);
	mpd_init_rand(tmp2);
	mpd_copy(tmp1, op1, ctx);
	mpd_copy(tmp2, op2, ctx);
	mpd_init_rand(result1);
	ctx->status = 0;

	mpd_set_alloc_count(ctx);
	func(result1, tmp2, tmp1, tmp2, ctx);
	mpd_set_alloc(ctx);

	calc = mpd_to_sci(result1, 1);
	compare_expected(calc, expected1, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	calc = mpd_to_sci(tmp2, 1);
	compare_expected(calc, expected2, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	check_equalmem(tmp1, op1, token[0]);

	/* Allocation failures */
	incr = 1;
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail += incr) {
		mpd_init_rand(tmp1);
		mpd_init_rand(tmp2);
		mpd_copy(tmp1, op1, ctx);
		mpd_copy(tmp2, op2, ctx);
		mpd_minalloc(result1);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		func(result1, tmp2, tmp1, tmp2, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(result1))
		ASSERT(mpd_isnan(tmp2))

		if (alloc_fail > 50) {
			incr = (int)(alloc_count*0.02) + 1;
		}
	}
	calc = mpd_to_sci(result1, 1);
	compare_expected(calc, expected1, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	calc = mpd_to_sci(tmp2, 1);
	compare_expected(calc, expected2, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	check_equalmem(tmp1, op1, token[0]);


	/* result1 == tmp1, result2 == tmp2 */
	mpd_init_rand(tmp1);
	mpd_init_rand(tmp2);
	mpd_copy(tmp1, op1, ctx);
	mpd_copy(tmp2, op2, ctx);
	ctx->status = 0;

	mpd_set_alloc_count(ctx);
	func(tmp1, tmp2, tmp1, tmp2, ctx);
	mpd_set_alloc(ctx);

	calc = mpd_to_sci(tmp1, 1);
	compare_expected(calc, expected1, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	calc = mpd_to_sci(tmp2, 1);
	compare_expected(calc, expected2, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	/* Allocation failures */
	incr = 1;
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail += incr) {
		mpd_init_rand(tmp1);
		mpd_init_rand(tmp2);
		mpd_copy(tmp1, op1, ctx);
		mpd_copy(tmp2, op2, ctx);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		func(tmp1, tmp2, tmp1, tmp2, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(tmp1))
		ASSERT(mpd_isnan(tmp2))

		if (alloc_fail > 50) {
			incr = (int)(alloc_count*0.02) + 1;
		}
	}
	calc = mpd_to_sci(tmp1, 1);
	compare_expected(calc, expected1, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	calc = mpd_to_sci(tmp2, 1);
	compare_expected(calc, expected2, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);


	/* result1 == tmp2, result2 == tmp1 */
	mpd_init_rand(tmp1);
	mpd_init_rand(tmp2);
	mpd_copy(tmp1, op1, ctx);
	mpd_copy(tmp2, op2, ctx);
	ctx->status = 0;

	mpd_set_alloc_count(ctx);
	func(tmp2, tmp1, tmp1, tmp2, ctx);
	mpd_set_alloc(ctx);

	calc = mpd_to_sci(tmp2, 1);
	compare_expected(calc, expected1, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	calc = mpd_to_sci(tmp1, 1);
	compare_expected(calc, expected2, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	/* Allocation failures */
	incr = 1;
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail += incr) {
		mpd_init_rand(tmp1);
		mpd_init_rand(tmp2);
		mpd_copy(tmp1, op1, ctx);
		mpd_copy(tmp2, op2, ctx);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		func(tmp2, tmp1, tmp1, tmp2, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(tmp2))
		ASSERT(mpd_isnan(tmp1))

		if (alloc_fail > 50) {
			incr = (int)(alloc_count*0.02) + 1;
		}
	}
	calc = mpd_to_sci(tmp2, 1);
	compare_expected(calc, expected1, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	calc = mpd_to_sci(tmp1, 1);
	compare_expected(calc, expected2, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
}

/* Test a binary function with a binary result; equal operands */
static void
_Binres_EqualBinop_Ctx(char *token[], void (*func)(mpd_t *, mpd_t*, const mpd_t *, const mpd_t *, mpd_context_t *), mpd_context_t *ctx)
{
	mpd_context_t maxctx;
	char *calc;
	char *expected1, *expected2;
	uint32_t expstatus;
	int n;

	mpd_readcontext(&maxctx);
	maxctx.traps = MPD_Malloc_error;

	n = scan_1op_2results(op, &expected1, &expected2, token, &maxctx);

	/* scan expected conditions */
	expstatus = scan_conditions(token+n);


	/* distinct results */
	mpd_init_rand(tmp);
	mpd_copy(tmp, op, ctx);
	mpd_init_rand(result1);
	mpd_init_rand(result2);
	ctx->status = 0;

	func(result1, result2, tmp, tmp, ctx);

	/* hack #1 to resolve disagreement with results generated by decimal.py */
	if (expstatus&MPD_Invalid_operation && ctx->status&MPD_Division_impossible) {
		expstatus = MPD_Division_impossible;
	}
	/* hack #2 to resolve disagreement with results generated by decimal.py */
	if (expstatus&MPD_Invalid_operation && ctx->status&MPD_Division_undefined) {
		expstatus = MPD_Division_undefined;
	}
	/* hack #3 to resolve disagreement with results generated by decimal.py */
	if ((startswith(expected1, "-Inf") || startswith(expected1, "Inf")) && mpd_isnan(result1)) {
		expected1 = "NaN";
	}

	calc = mpd_to_sci(result1, 1);
	compare_expected(calc, expected1, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	calc = mpd_to_sci(result2, 1);
	compare_expected(calc, expected2, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	check_equalmem(tmp, op, token[0]);

	/* Allocation failures */
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		mpd_init_rand(tmp);
		mpd_copy(tmp, op, ctx);
		mpd_minalloc(result1);
		mpd_minalloc(result2);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		func(result1, result2, tmp, tmp, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(result1))
		ASSERT(mpd_isnan(result2))
	}
	calc = mpd_to_sci(result1, 1);
	compare_expected(calc, expected1, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	calc = mpd_to_sci(result2, 1);
	compare_expected(calc, expected2, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	check_equalmem(tmp, op, token[0]);


	/* result1 == tmp */
	mpd_init_rand(tmp);
	mpd_copy(tmp, op, ctx);
	mpd_init_rand(result2);
	ctx->status = 0;

	func(tmp, result2, tmp, tmp, ctx);

	calc = mpd_to_sci(tmp, 1);
	compare_expected(calc, expected1, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	calc = mpd_to_sci(result2, 1);
	compare_expected(calc, expected2, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	/* Allocation failures */
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		mpd_init_rand(tmp);
		mpd_copy(tmp, op, ctx);
		mpd_minalloc(result2);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		func(tmp, result2, tmp, tmp, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(tmp))
		ASSERT(mpd_isnan(result2))
	}
	calc = mpd_to_sci(tmp, 1);
	compare_expected(calc, expected1, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	calc = mpd_to_sci(result2, 1);
	compare_expected(calc, expected2, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);


	/* result2 == tmp */
	mpd_init_rand(tmp);
	mpd_copy(tmp, op, ctx);
	mpd_init_rand(result1);
	ctx->status = 0;

	func(result1, tmp, tmp, tmp, ctx);

	calc = mpd_to_sci(result1, 1);
	compare_expected(calc, expected1, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	calc = mpd_to_sci(tmp, 1);
	compare_expected(calc, expected2, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	/* Allocation failures */
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		mpd_init_rand(tmp);
		mpd_copy(tmp, op, ctx);
		mpd_minalloc(result1);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		func(result1, tmp, tmp, tmp, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(result1))
		ASSERT(mpd_isnan(tmp))
	}
	calc = mpd_to_sci(result1, 1);
	compare_expected(calc, expected1, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	calc = mpd_to_sci(tmp, 1);
	compare_expected(calc, expected2, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
}

/* Test a ternary function */
static void
_Res_Ternop_Ctx(char *token[], void (*func)(mpd_t *, const mpd_t *, const mpd_t *, const mpd_t *, mpd_context_t *), mpd_context_t *ctx)
{
	mpd_context_t maxctx;
	char *calc;
	char *expected;
	uint32_t expstatus;
	int n, incr;

	mpd_readcontext(&maxctx);
	maxctx.traps = MPD_Malloc_error;

	n = scan_3ops_result(op1, op2, op3, &expected, token, &maxctx);

	/* scan expected conditions */
	expstatus = scan_conditions(token+n);


	/* four distinct decimals */
	mpd_init_rand(tmp1);
	mpd_init_rand(tmp2);
	mpd_init_rand(tmp3);
	mpd_copy(tmp1, op1, ctx);
	mpd_copy(tmp2, op2, ctx);
	mpd_copy(tmp3, op3, ctx);
	mpd_init_rand(result);
	ctx->status = 0;

	mpd_set_alloc_count(ctx);
	func(result, tmp1, tmp2, tmp3, ctx);
	mpd_set_alloc(ctx);

	calc = mpd_to_sci(result, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp1, op1, token[0]);
	check_equalmem(tmp2, op2, token[0]);
	check_equalmem(tmp3, op3, token[0]);

	/* Allocation failures */
	incr = 1;
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail += incr) {
		mpd_init_rand(tmp1);
		mpd_init_rand(tmp2);
		mpd_init_rand(tmp3);
		mpd_copy(tmp1, op1, ctx);
		mpd_copy(tmp2, op2, ctx);
		mpd_copy(tmp3, op3, ctx);
		mpd_minalloc(result);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		func(result, tmp1, tmp2, tmp3, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(result))

		if (alloc_fail > 100) {
			incr = (int)(alloc_count*0.02) + 1;
		}
	}
	calc = mpd_to_sci(result, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp1, op1, token[0]);
	check_equalmem(tmp2, op2, token[0]);
	check_equalmem(tmp3, op3, token[0]);


	/* result == tmp1 */
	mpd_init_rand(tmp1);
	mpd_init_rand(tmp2);
	mpd_init_rand(tmp3);
	mpd_copy(tmp1, op1, ctx);
	mpd_copy(tmp2, op2, ctx);
	mpd_copy(tmp3, op3, ctx);
	ctx->status = 0;

	mpd_set_alloc_count(ctx);
	func(tmp1, tmp1, tmp2, tmp3, ctx);
	mpd_set_alloc(ctx);

	calc = mpd_to_sci(tmp1, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp2, op2, token[0]);
	check_equalmem(tmp3, op3, token[0]);

	/* Allocation failures */
	incr = 1;
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail += incr) {
		mpd_init_rand(tmp1);
		mpd_init_rand(tmp2);
		mpd_init_rand(tmp3);
		mpd_copy(tmp1, op1, ctx);
		mpd_copy(tmp2, op2, ctx);
		mpd_copy(tmp3, op3, ctx);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		func(tmp1, tmp1, tmp2, tmp3, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(tmp1))

		if (alloc_fail > 100) {
			incr = (int)(alloc_count*0.02) + 1;
		}
	}
	calc = mpd_to_sci(tmp1, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp2, op2, token[0]);
	check_equalmem(tmp3, op3, token[0]);


	/* result == tmp2 */
	mpd_init_rand(tmp1);
	mpd_init_rand(tmp2);
	mpd_init_rand(tmp3);
	mpd_copy(tmp1, op1, ctx);
	mpd_copy(tmp2, op2, ctx);
	mpd_copy(tmp3, op3, ctx);
	ctx->status = 0;

	mpd_set_alloc_count(ctx);
	func(tmp2, tmp1, tmp2, tmp3, ctx);
	mpd_set_alloc(ctx);

	calc = mpd_to_sci(tmp2, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp1, op1, token[0]);
	check_equalmem(tmp3, op3, token[0]);

	/* Allocation failures */
	incr = 1;
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail += incr) {
		mpd_init_rand(tmp1);
		mpd_init_rand(tmp2);
		mpd_init_rand(tmp3);
		mpd_copy(tmp1, op1, ctx);
		mpd_copy(tmp2, op2, ctx);
		mpd_copy(tmp3, op3, ctx);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		func(tmp2, tmp1, tmp2, tmp3, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(tmp2))

		if (alloc_fail > 100) {
			incr = (int)(alloc_count*0.02) + 1;
		}
	}
	calc = mpd_to_sci(tmp2, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp1, op1, token[0]);
	check_equalmem(tmp3, op3, token[0]);


	/* result == tmp3 */
	mpd_init_rand(tmp1);
	mpd_init_rand(tmp2);
	mpd_init_rand(tmp3);
	mpd_copy(tmp1, op1, ctx);
	mpd_copy(tmp2, op2, ctx);
	mpd_copy(tmp3, op3, ctx);
	ctx->status = 0;

	mpd_set_alloc_count(ctx);
	func(tmp3, tmp1, tmp2, tmp3, ctx);
	mpd_set_alloc(ctx);

	calc = mpd_to_sci(tmp3, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp1, op1, token[0]);
	check_equalmem(tmp2, op2, token[0]);

	/* Allocation failures */
	incr = 1;
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail += incr) {
		mpd_init_rand(tmp1);
		mpd_init_rand(tmp2);
		mpd_init_rand(tmp3);
		mpd_copy(tmp1, op1, ctx);
		mpd_copy(tmp2, op2, ctx);
		mpd_copy(tmp3, op3, ctx);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		func(tmp3, tmp1, tmp2, tmp3, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(tmp3))

		if (alloc_fail > 100) {
			incr = (int)(alloc_count*0.02) + 1;
		}
	}
	calc = mpd_to_sci(tmp3, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp1, op1, token[0]);
	check_equalmem(tmp2, op2, token[0]);
}

/* Test a ternary function, first and second operand equal */
static void
_Res_EqEqOp_Ctx(char *token[], void (*func)(mpd_t *, const mpd_t *, const mpd_t *, const mpd_t *, mpd_context_t *), mpd_context_t *ctx)
{
	mpd_context_t maxctx;
	char *calc;
	char *expected;
	uint32_t expstatus;
	int n;

	mpd_readcontext(&maxctx);
	maxctx.traps = MPD_Malloc_error;

	n = scan_2ops_result(op1, op2, &expected, token, &maxctx);

	/* scan expected conditions */
	expstatus = scan_conditions(token+n);


	/* distinct result */
	mpd_init_rand(tmp1);
	mpd_init_rand(tmp2);
	mpd_copy(tmp1, op1, ctx);
	mpd_copy(tmp2, op2, ctx);
	mpd_init_rand(result);
	ctx->status = 0;

	func(result, tmp1, tmp1, tmp2, ctx);

	calc = mpd_to_sci(result, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp1, op1, token[0]);
	check_equalmem(tmp2, op2, token[0]);

	/* Allocation failures */
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		mpd_init_rand(tmp1);
		mpd_init_rand(tmp2);
		mpd_copy(tmp1, op1, ctx);
		mpd_copy(tmp2, op2, ctx);
		mpd_minalloc(result);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		func(result, tmp1, tmp1, tmp2, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(result))
	}
	calc = mpd_to_sci(result, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp1, op1, token[0]);
	check_equalmem(tmp2, op2, token[0]);


	/* result == tmp1 */
	mpd_init_rand(tmp1);
	mpd_init_rand(tmp2);
	mpd_copy(tmp1, op1, ctx);
	mpd_copy(tmp2, op2, ctx);
	ctx->status = 0;

	func(tmp1, tmp1, tmp1, tmp2, ctx);

	calc = mpd_to_sci(tmp1, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp2, op2, token[0]);

	/* Allocation failures */
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		mpd_init_rand(tmp1);
		mpd_init_rand(tmp2);
		mpd_copy(tmp1, op1, ctx);
		mpd_copy(tmp2, op2, ctx);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		func(tmp1, tmp1, tmp1, tmp2, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(tmp1))
	}
	calc = mpd_to_sci(tmp1, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp2, op2, token[0]);


	/* result == tmp2 */
	mpd_init_rand(tmp1);
	mpd_init_rand(tmp2);
	mpd_copy(tmp1, op1, ctx);
	mpd_copy(tmp2, op2, ctx);
	ctx->status = 0;

	func(tmp2, tmp1, tmp1, tmp2, ctx);

	calc = mpd_to_sci(tmp2, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp1, op1, token[0]);

	/* Allocation failures */
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		mpd_init_rand(tmp1);
		mpd_init_rand(tmp2);
		mpd_copy(tmp1, op1, ctx);
		mpd_copy(tmp2, op2, ctx);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		func(tmp2, tmp1, tmp1, tmp2, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(tmp2))
	}
	calc = mpd_to_sci(tmp2, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp1, op1, token[0]);
}

/* Test a ternary function, first and third operand equal */
static void
_Res_EqOpEq_Ctx(char *token[], void (*func)(mpd_t *, const mpd_t *, const mpd_t *, const mpd_t *, mpd_context_t *), mpd_context_t *ctx)
{
	mpd_context_t maxctx;
	char *calc;
	char *expected;
	uint32_t expstatus;
	int n;

	mpd_readcontext(&maxctx);
	maxctx.traps = MPD_Malloc_error;

	n = scan_2ops_result(op1, op2, &expected, token, &maxctx);

	/* scan expected conditions */
	expstatus = scan_conditions(token+n);


	/* distinct result */
	mpd_init_rand(tmp1);
	mpd_init_rand(tmp2);
	mpd_copy(tmp1, op1, ctx);
	mpd_copy(tmp2, op2, ctx);
	mpd_init_rand(result);
	ctx->status = 0;

	func(result, tmp1, tmp2, tmp1, ctx);

	calc = mpd_to_sci(result, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp1, op1, token[0]);
	check_equalmem(tmp2, op2, token[0]);

	/* Allocation failures */
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		mpd_init_rand(tmp1);
		mpd_init_rand(tmp2);
		mpd_copy(tmp1, op1, ctx);
		mpd_copy(tmp2, op2, ctx);
		mpd_minalloc(result);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		func(result, tmp1, tmp2, tmp1, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(result))
	}
	calc = mpd_to_sci(result, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp1, op1, token[0]);
	check_equalmem(tmp2, op2, token[0]);


	/* result == tmp1 */
	mpd_init_rand(tmp1);
	mpd_init_rand(tmp2);
	mpd_copy(tmp1, op1, ctx);
	mpd_copy(tmp2, op2, ctx);
	ctx->status = 0;

	func(tmp1, tmp1, tmp2, tmp1, ctx);

	calc = mpd_to_sci(tmp1, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp2, op2, token[0]);

	/* Allocation failures */
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		mpd_init_rand(tmp1);
		mpd_init_rand(tmp2);
		mpd_copy(tmp1, op1, ctx);
		mpd_copy(tmp2, op2, ctx);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		func(tmp1, tmp1, tmp2, tmp1, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(tmp1))
	}
	calc = mpd_to_sci(tmp1, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp2, op2, token[0]);


	/* result == tmp2 */
	mpd_init_rand(tmp1);
	mpd_init_rand(tmp2);
	mpd_copy(tmp1, op1, ctx);
	mpd_copy(tmp2, op2, ctx);
	ctx->status = 0;

	func(tmp2, tmp1, tmp2, tmp1, ctx);

	calc = mpd_to_sci(tmp2, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp1, op1, token[0]);

	/* Allocation failures */
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		mpd_init_rand(tmp1);
		mpd_init_rand(tmp2);
		mpd_copy(tmp1, op1, ctx);
		mpd_copy(tmp2, op2, ctx);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		func(tmp2, tmp1, tmp2, tmp1, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(tmp2))
	}
	calc = mpd_to_sci(tmp2, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp1, op1, token[0]);
}

/* Test a ternary function, second and third operand equal */
static void
_Res_OpEqEq_Ctx(char *token[], void (*func)(mpd_t *, const mpd_t *, const mpd_t *, const mpd_t *, mpd_context_t *), mpd_context_t *ctx)
{
	mpd_context_t maxctx;
	char *calc;
	char *expected;
	uint32_t expstatus;
	int n;

	mpd_readcontext(&maxctx);
	maxctx.traps = MPD_Malloc_error;

	n = scan_2ops_result(op1, op2, &expected, token, &maxctx);

	/* scan expected conditions */
	expstatus = scan_conditions(token+n);


	/* distinct result */
	mpd_init_rand(tmp1);
	mpd_init_rand(tmp2);
	mpd_copy(tmp1, op1, ctx);
	mpd_copy(tmp2, op2, ctx);
	mpd_init_rand(result);
	ctx->status = 0;

	func(result, tmp2, tmp1, tmp1, ctx);

	calc = mpd_to_sci(result, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp1, op1, token[0]);
	check_equalmem(tmp2, op2, token[0]);

	/* Allocation failures */
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		mpd_init_rand(tmp1);
		mpd_init_rand(tmp2);
		mpd_copy(tmp1, op1, ctx);
		mpd_copy(tmp2, op2, ctx);
		mpd_minalloc(result);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		func(result, tmp2, tmp1, tmp1, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(result))
	}
	calc = mpd_to_sci(result, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp1, op1, token[0]);
	check_equalmem(tmp2, op2, token[0]);


	/* result == tmp1 */
	mpd_init_rand(tmp1);
	mpd_init_rand(tmp2);
	mpd_copy(tmp1, op1, ctx);
	mpd_copy(tmp2, op2, ctx);
	ctx->status = 0;

	func(tmp1, tmp2, tmp1, tmp1, ctx);

	calc = mpd_to_sci(tmp1, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp2, op2, token[0]);

	/* Allocation failures */
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		mpd_init_rand(tmp1);
		mpd_init_rand(tmp2);
		mpd_copy(tmp1, op1, ctx);
		mpd_copy(tmp2, op2, ctx);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		func(tmp1, tmp2, tmp1, tmp1, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(tmp1))
	}
	calc = mpd_to_sci(tmp1, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp2, op2, token[0]);


	/* result == tmp2 */
	mpd_init_rand(tmp1);
	mpd_init_rand(tmp2);
	mpd_copy(tmp1, op1, ctx);
	mpd_copy(tmp2, op2, ctx);
	ctx->status = 0;

	func(tmp2, tmp2, tmp1, tmp1, ctx);

	calc = mpd_to_sci(tmp2, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp1, op1, token[0]);

	/* Allocation failures */
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		mpd_init_rand(tmp1);
		mpd_init_rand(tmp2);
		mpd_copy(tmp1, op1, ctx);
		mpd_copy(tmp2, op2, ctx);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		func(tmp2, tmp2, tmp1, tmp1, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(tmp2))
	}
	calc = mpd_to_sci(tmp2, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp1, op1, token[0]);
}

/* Test a ternary function, first, second and third operand equal */
static void
_Res_EqEqEq_Ctx(char *token[], void (*func)(mpd_t *, const mpd_t *, const mpd_t *, const mpd_t *, mpd_context_t *), mpd_context_t *ctx)
{
	mpd_context_t maxctx;
	char *calc;
	char *expected;
	uint32_t expstatus;
	int n;

	mpd_readcontext(&maxctx);
	maxctx.traps = MPD_Malloc_error;

	n = scan_1op_result(op, &expected, token, &maxctx);

	/* scan expected conditions */
	expstatus = scan_conditions(token+n);


	/* distinct result */
	mpd_init_rand(tmp);
	mpd_copy(tmp, op, ctx);
	mpd_init_rand(result);
	ctx->status = 0;

	func(result, tmp, tmp, tmp, ctx);

	calc = mpd_to_sci(result, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp, op, token[0]);

	/* Allocation failures */
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		mpd_init_rand(tmp);
		mpd_copy(tmp, op, ctx);
		mpd_minalloc(result);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		func(result, tmp, tmp, tmp, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(result))
	}
	calc = mpd_to_sci(result, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp, op, token[0]);


	/* result == tmp */
	mpd_init_rand(tmp);
	mpd_copy(tmp, op, ctx);
	ctx->status = 0;

	func(tmp, tmp, tmp, tmp, ctx);

	calc = mpd_to_sci(tmp, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	/* Allocation failures */
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		mpd_init_rand(tmp);
		mpd_copy(tmp, op, ctx);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		func(tmp, tmp, tmp, tmp, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(tmp))
	}
	calc = mpd_to_sci(tmp, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
}

/*
 * Test a binary function that returns an additional integer result.
 * Used for the comparison functions.
 */
static void
_Int_Res_Binop_Ctx(char *token[], int (*func)(mpd_t *, const mpd_t *, const mpd_t *, mpd_context_t *), mpd_context_t *ctx)
{
	mpd_context_t maxctx;
	char *calc;
	char *expected;
	int int_result;
	char buf[11];
	uint32_t expstatus;
	int n;

	mpd_readcontext(&maxctx);
	maxctx.traps = MPD_Malloc_error;

	n = scan_2ops_result(op1, op2, &expected, token, &maxctx);

	/* scan expected conditions */
	expstatus = scan_conditions(token+n);


	/* three distinct decimals */
	mpd_init_rand(tmp1);
	mpd_init_rand(tmp2);
	mpd_copy(tmp1, op1, ctx);
	mpd_copy(tmp2, op2, ctx);
	mpd_init_rand(result);
	ctx->status = 0;

	int_result = func(result, tmp1, tmp2, ctx);

	calc = mpd_to_sci(result, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	snprintf(buf, 11, "%d", int_result);
	if (int_result != INT_MAX) { /* NaN cases are skipped for the int_retval */
		compare_expected(buf, expected, expstatus, token[0], ctx);
	}
	check_equalmem(tmp1, op1, token[0]);
	check_equalmem(tmp2, op2, token[0]);

	/* Allocation failures */
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		mpd_init_rand(tmp1);
		mpd_init_rand(tmp2);
		mpd_copy(tmp1, op1, ctx);
		mpd_copy(tmp2, op2, ctx);
		mpd_minalloc(result);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		int_result = func(result, tmp1, tmp2, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(result))
	}
	calc = mpd_to_sci(result, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	snprintf(buf, 11, "%d", int_result);
	if (int_result != INT_MAX) { /* NaN cases are skipped for the int_retval */
		compare_expected(buf, expected, expstatus, token[0], ctx);
	}
	check_equalmem(tmp1, op1, token[0]);
	check_equalmem(tmp2, op2, token[0]);


	/* result == tmp1 */
	mpd_init_rand(tmp1);
	mpd_init_rand(tmp2);
	mpd_copy(tmp1, op1, ctx);
	mpd_copy(tmp2, op2, ctx);
	ctx->status = 0;

	int_result = func(tmp1, tmp1, tmp2, ctx);

	calc = mpd_to_sci(tmp1, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	snprintf(buf, 11, "%d", int_result);
	if (int_result != INT_MAX) { /* NaN cases are skipped for the int_retval */
		compare_expected(buf, expected, expstatus, token[0], ctx);
	}
	check_equalmem(tmp2, op2, token[0]);

	/* Allocation failures */
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		mpd_init_rand(tmp1);
		mpd_init_rand(tmp2);
		mpd_copy(tmp1, op1, ctx);
		mpd_copy(tmp2, op2, ctx);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		int_result = func(tmp1, tmp1, tmp2, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(tmp1))
	}
	calc = mpd_to_sci(tmp1, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	snprintf(buf, 11, "%d", int_result);
	if (int_result != INT_MAX) { /* NaN cases are skipped for the int_retval */
		compare_expected(buf, expected, expstatus, token[0], ctx);
	}
	check_equalmem(tmp2, op2, token[0]);


	/* result == tmp2 */
	mpd_init_rand(tmp1);
	mpd_init_rand(tmp2);
	mpd_copy(tmp1, op1, ctx);
	mpd_copy(tmp2, op2, ctx);
	ctx->status = 0;

	int_result = func(tmp2, tmp1, tmp2, ctx);

	calc = mpd_to_sci(tmp2, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	snprintf(buf, 11, "%d", int_result);
	if (int_result != INT_MAX) { /* NaN cases are skipped for the int_retval */
		compare_expected(buf, expected, expstatus, token[0], ctx);
	}
	check_equalmem(tmp1, op1, token[0]);

	/* Allocation failures */
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		mpd_init_rand(tmp1);
		mpd_init_rand(tmp2);
		mpd_copy(tmp1, op1, ctx);
		mpd_copy(tmp2, op2, ctx);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		int_result = func(tmp2, tmp1, tmp2, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(tmp2))
	}
	calc = mpd_to_sci(tmp2, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	snprintf(buf, 11, "%d", int_result);
	if (int_result != INT_MAX) { /* NaN cases are skipped for the int_retval */
		compare_expected(buf, expected, expstatus, token[0], ctx);
	}
	check_equalmem(tmp1, op1, token[0]);
}

/*
 * Test a binary function that returns an additional integer result.
 * Equal operands.
 * Used for the comparison functions.
 */
static void
_Int_Res_EqualBinop_Ctx(char *token[], int (*func)(mpd_t *, const mpd_t *, const mpd_t *, mpd_context_t *), mpd_context_t *ctx)
{
	mpd_context_t maxctx;
	char *calc;
	char *expected;
	int int_result;
	char buf[11];
	uint32_t expstatus;
	int n;

	mpd_readcontext(&maxctx);
	maxctx.traps = MPD_Malloc_error;

	n = scan_1op_result(op, &expected, token, &maxctx);

	/* scan expected conditions */
	expstatus = scan_conditions(token+n);


	/* equal operands */
	mpd_init_rand(tmp);
	mpd_copy(tmp, op, ctx);
	mpd_init_rand(result);
	ctx->status = 0;

	int_result = func(result, tmp, tmp, ctx);

	calc = mpd_to_sci(result, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	snprintf(buf, 11, "%d", int_result);
	if (int_result != INT_MAX) { /* NaN cases are skipped for the int_retval */
		compare_expected(buf, expected, expstatus, token[0], ctx);
	}
	check_equalmem(tmp, op, token[0]);

	/* Allocation failures */
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		mpd_init_rand(tmp);
		mpd_copy(tmp, op, ctx);
		mpd_minalloc(result);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		int_result = func(result, tmp, tmp, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(result))
	}
	calc = mpd_to_sci(result, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	snprintf(buf, 11, "%d", int_result);
	if (int_result != INT_MAX) { /* NaN cases are skipped for the int_retval */
		compare_expected(buf, expected, expstatus, token[0], ctx);
	}
	check_equalmem(tmp, op, token[0]);


	/* all parameters equal */
	mpd_init_rand(tmp);
	mpd_copy(tmp, op, ctx);
	ctx->status = 0;

	int_result = func(tmp, tmp, tmp, ctx);

	calc = mpd_to_sci(tmp, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	snprintf(buf, 11, "%d", int_result);
	if (int_result != INT_MAX) { /* NaN cases are skipped for the int_retval */
		compare_expected(buf, expected, expstatus, token[0], ctx);
	}

	/* Allocation failures */
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		mpd_init_rand(tmp);
		mpd_copy(tmp, op, ctx);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		int_result = func(tmp, tmp, tmp, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(tmp))
	}
	calc = mpd_to_sci(tmp, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	snprintf(buf, 11, "%d", int_result);
	if (int_result != INT_MAX) { /* NaN cases are skipped for the int_retval */
		compare_expected(buf, expected, expstatus, token[0], ctx);
	}
}

/*
 * Test a binary function that returns an additional integer result.
 * Function does not take a context argument.
 * Used for the comparison functions.
 */
static void
_Int_Res_Binop(char *token[], int (*func)(mpd_t *, const mpd_t *, const mpd_t *), mpd_context_t *ctx)
{
	mpd_context_t maxctx;
	char *calc;
	char *expected;
	int int_result;
	char buf[11];
	uint32_t expstatus;
	int n;

	mpd_readcontext(&maxctx);
	maxctx.traps = MPD_Malloc_error;

	n = scan_2ops_result(op1, op2, &expected, token, &maxctx);

	/* scan expected conditions */
	expstatus = scan_conditions(token+n);


	/* three distinct decimals */
	mpd_init_rand(tmp1);
	mpd_init_rand(tmp2);
	mpd_copy(tmp1, op1, ctx);
	mpd_copy(tmp2, op2, ctx);
	mpd_init_rand(result);
	ctx->status = 0;

	int_result = func(result, tmp1, tmp2);

	calc = mpd_to_sci(result, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	snprintf(buf, 11, "%d", int_result);
	if (int_result != INT_MAX) { /* NaN cases are skipped for the int_retval */
		compare_expected(buf, expected, expstatus, token[0], ctx);
	}
	check_equalmem(tmp1, op1, token[0]);
	check_equalmem(tmp2, op2, token[0]);

	/* Allocation failures */
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		mpd_init_rand(tmp1);
		mpd_init_rand(tmp2);
		mpd_copy(tmp1, op1, ctx);
		mpd_copy(tmp2, op2, ctx);
		mpd_minalloc(result);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		int_result = func(result, tmp1, tmp2);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(result))
	}
	calc = mpd_to_sci(result, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	snprintf(buf, 11, "%d", int_result);
	if (int_result != INT_MAX) { /* NaN cases are skipped for the int_retval */
		compare_expected(buf, expected, expstatus, token[0], ctx);
	}
	check_equalmem(tmp1, op1, token[0]);
	check_equalmem(tmp2, op2, token[0]);


	/* result == tmp1 */
	mpd_init_rand(tmp1);
	mpd_init_rand(tmp2);
	mpd_copy(tmp1, op1, ctx);
	mpd_copy(tmp2, op2, ctx);
	ctx->status = 0;

	int_result = func(tmp1, tmp1, tmp2);

	calc = mpd_to_sci(tmp1, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	snprintf(buf, 11, "%d", int_result);
	if (int_result != INT_MAX) { /* NaN cases are skipped for the int_retval */
		compare_expected(buf, expected, expstatus, token[0], ctx);
	}
	check_equalmem(tmp2, op2, token[0]);

	/* Allocation failures */
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		mpd_init_rand(tmp1);
		mpd_init_rand(tmp2);
		mpd_copy(tmp1, op1, ctx);
		mpd_copy(tmp2, op2, ctx);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		int_result = func(tmp1, tmp1, tmp2);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(tmp1))
	}
	calc = mpd_to_sci(tmp1, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	snprintf(buf, 11, "%d", int_result);
	if (int_result != INT_MAX) { /* NaN cases are skipped for the int_retval */
		compare_expected(buf, expected, expstatus, token[0], ctx);
	}
	check_equalmem(tmp2, op2, token[0]);


	/* result == tmp2 */
	mpd_init_rand(tmp1);
	mpd_init_rand(tmp2);
	mpd_copy(tmp1, op1, ctx);
	mpd_copy(tmp2, op2, ctx);
	ctx->status = 0;

	int_result = func(tmp2, tmp1, tmp2);

	calc = mpd_to_sci(tmp2, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	snprintf(buf, 11, "%d", int_result);
	if (int_result != INT_MAX) { /* NaN cases are skipped for the int_retval */
		compare_expected(buf, expected, expstatus, token[0], ctx);
	}
	check_equalmem(tmp1, op1, token[0]);

	/* Allocation failures */
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		mpd_init_rand(tmp1);
		mpd_init_rand(tmp2);
		mpd_copy(tmp1, op1, ctx);
		mpd_copy(tmp2, op2, ctx);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		int_result = func(tmp2, tmp1, tmp2);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(tmp2))
	}
	calc = mpd_to_sci(tmp2, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	snprintf(buf, 11, "%d", int_result);
	if (int_result != INT_MAX) { /* NaN cases are skipped for the int_retval */
		compare_expected(buf, expected, expstatus, token[0], ctx);
	}
	check_equalmem(tmp1, op1, token[0]);
}

/*
 * Test a binary function that returns an additional integer result.
 * Function does not take a context argument.
 * Equal operands.
 * Used for the comparison functions.
 */
static void
_Int_Res_EqualBinop(char *token[], int (*func)(mpd_t *, const mpd_t *, const mpd_t *), mpd_context_t *ctx)
{
	mpd_context_t maxctx;
	char *calc;
	char *expected;
	int int_result;
	char buf[11];
	uint32_t expstatus;
	int n;

	mpd_readcontext(&maxctx);
	maxctx.traps = MPD_Malloc_error;

	n = scan_1op_result(op, &expected, token, &maxctx);

	/* scan expected conditions */
	expstatus = scan_conditions(token+n);


	/* equal operands */
	mpd_init_rand(tmp);
	mpd_copy(tmp, op, ctx);
	mpd_init_rand(result);
	ctx->status = 0;

	int_result = func(result, tmp, tmp);

	calc = mpd_to_sci(result, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	snprintf(buf, 11, "%d", int_result);
	if (int_result != INT_MAX) { /* NaN cases are skipped for the int_retval */
		compare_expected(buf, expected, expstatus, token[0], ctx);
	}
	check_equalmem(tmp, op, token[0]);

	/* Allocation failures */
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		mpd_init_rand(tmp);
		mpd_copy(tmp, op, ctx);
		mpd_minalloc(result);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		int_result = func(result, tmp, tmp);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(result))
	}
	calc = mpd_to_sci(result, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	snprintf(buf, 11, "%d", int_result);
	if (int_result != INT_MAX) { /* NaN cases are skipped for the int_retval */
		compare_expected(buf, expected, expstatus, token[0], ctx);
	}
	check_equalmem(tmp, op, token[0]);


	/* all parameters equal */
	mpd_init_rand(tmp);
	mpd_copy(tmp, op, ctx);
	ctx->status = 0;

	int_result = func(tmp, tmp, tmp);

	calc = mpd_to_sci(tmp, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	snprintf(buf, 11, "%d", int_result);
	if (int_result != INT_MAX) { /* NaN cases are skipped for the int_retval */
		compare_expected(buf, expected, expstatus, token[0], ctx);
	}

	/* Allocation failures */
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		mpd_init_rand(tmp);
		mpd_copy(tmp, op, ctx);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		int_result = func(tmp, tmp, tmp);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(tmp))
	}
	calc = mpd_to_sci(tmp, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	snprintf(buf, 11, "%d", int_result);
	if (int_result != INT_MAX) { /* NaN cases are skipped for the int_retval */
		compare_expected(buf, expected, expstatus, token[0], ctx);
	}
}

/*
 * Test a binary function that returns only an integer result.
 * Used for the cmp functions.
 */
enum {SKIP_NONE, SKIP_NAN, SKIP_NONINT};
static void
_Int_Binop_Ctx(int skip, char *token[], int (*func)(const mpd_t *, const mpd_t *, mpd_context_t *), mpd_context_t *ctx)
{
	mpd_context_t maxctx;
	int int_result;
	char buf[11];
	char *expected;
	uint32_t expstatus;
	int n;

	mpd_readcontext(&maxctx);
	maxctx.traps = MPD_Malloc_error;

	n = scan_2ops_result(op1, op2, &expected, token, &maxctx);

	/* scan expected conditions */
	expstatus = scan_conditions(token+n);


	/* two distinct decimals */
	mpd_init_rand(tmp1);
	mpd_init_rand(tmp2);
	mpd_copy(tmp1, op1, ctx);
	mpd_copy(tmp2, op2, ctx);
	ctx->status = 0;

	int_result = func(tmp1, tmp2, ctx);

	snprintf(buf, 11, "%d", int_result);
	if (!(skip && int_result == INT_MAX)) { /* NaN cases are skipped for the int_retval */
		compare_expected(buf, expected, expstatus, token[0], ctx);
	}
	check_equalmem(tmp1, op1, token[0]);
	check_equalmem(tmp2, op2, token[0]);

	/* Allocation failures */
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		mpd_init_rand(tmp1);
		mpd_init_rand(tmp2);
		mpd_copy(tmp1, op1, ctx);
		mpd_copy(tmp2, op2, ctx);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		int_result = func(tmp1, tmp2, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(int_result== INT_MAX)
	}
	snprintf(buf, 11, "%d", int_result);
	if (!(skip && int_result == INT_MAX)) { /* NaN cases are skipped for the int_retval */
		compare_expected(buf, expected, expstatus, token[0], ctx);
	}
	check_equalmem(tmp1, op1, token[0]);
	check_equalmem(tmp2, op2, token[0]);
}

/*
 * Test a binary function that returns only an integer result.
 * Equal operands.
 * Used for the cmp functions.
 */
static void
_Int_EqualBinop_Ctx(int skip, char *token[], int (*func)(const mpd_t *, const mpd_t *, mpd_context_t *), mpd_context_t *ctx)
{
	mpd_context_t maxctx;
	int int_result;
	char buf[11];
	char *expected;
	uint32_t expstatus;
	int n;

	mpd_readcontext(&maxctx);
	maxctx.traps = MPD_Malloc_error;

	n = scan_1op_result(op, &expected, token, &maxctx);

	/* scan expected conditions */
	expstatus = scan_conditions(token+n);


	/* equal operands */
	mpd_init_rand(tmp);
	mpd_copy(tmp, op, ctx);
	ctx->status = 0;

	int_result = func(tmp, tmp, ctx);

	snprintf(buf, 11, "%d", int_result);
	if (!(skip && int_result == INT_MAX)) { /* NaN cases are skipped for the int_retval */
		compare_expected(buf, expected, expstatus, token[0], ctx);
	}
	check_equalmem(tmp, op, token[0]);

	/* Allocation failures */
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		mpd_init_rand(tmp);
		mpd_copy(tmp, op, ctx);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		int_result = func(tmp, tmp, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(int_result== INT_MAX)
	}
	snprintf(buf, 11, "%d", int_result);
	if (!(skip && int_result == INT_MAX)) { /* NaN cases are skipped for the int_retval */
		compare_expected(buf, expected, expstatus, token[0], ctx);
	}
	check_equalmem(tmp, op, token[0]);
}

/*
 * Test a binary function that returns an int.
 * The function does not take a context argument.
 */
static void
_Int_Binop(char *token[], int (*func)(const mpd_t *, const mpd_t *), mpd_context_t *ctx)
{
	mpd_context_t maxctx;
	int int_result;
	char buf[11];
	char *expected;
	uint32_t expstatus;
	int n;

	mpd_readcontext(&maxctx);
	maxctx.traps = MPD_Malloc_error;

	n = scan_2ops_result(op1, op2, &expected, token, &maxctx);

	/* scan expected conditions */
	expstatus = scan_conditions(token+n);


	/* two distinct decimals */
	mpd_init_rand(tmp1);
	mpd_init_rand(tmp2);
	mpd_copy(tmp1, op1, ctx);
	mpd_copy(tmp2, op2, ctx);
	ctx->status = 0;

	int_result = func(tmp1, tmp2);

	snprintf(buf, 11, "%d", int_result);
	compare_expected(buf, expected, expstatus, token[0], ctx);
	check_equalmem(tmp1, op1, token[0]);
	check_equalmem(tmp2, op2, token[0]);

	/* Allocation failures */
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		mpd_init_rand(tmp1);
		mpd_init_rand(tmp2);
		mpd_copy(tmp1, op1, ctx);
		mpd_copy(tmp2, op2, ctx);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		int_result = func(tmp1, tmp2);
		mpd_set_alloc(ctx);

		if (int_result != INT_MAX) {
			break;
		}
	}
	snprintf(buf, 11, "%d", int_result);
	compare_expected(buf, expected, expstatus, token[0], ctx);
	check_equalmem(tmp1, op1, token[0]);
	check_equalmem(tmp2, op2, token[0]);
}

/*
 * Test a binary function that returns an int.
 * Equal operands.
 * The function does not take a context argument.
 */
static void
_Int_EqualBinop(char *token[], int (*func)(const mpd_t *, const mpd_t *), mpd_context_t *ctx)
{
	mpd_context_t maxctx;
	int int_result;
	char buf[11];
	char *expected;
	uint32_t expstatus;
	int n;

	mpd_readcontext(&maxctx);
	maxctx.traps = MPD_Malloc_error;

	n = scan_1op_result(op, &expected, token, &maxctx);

	/* scan expected conditions */
	expstatus = scan_conditions(token+n);


	/* equal operands */
	mpd_init_rand(tmp);
	mpd_copy(tmp, op, ctx);
	ctx->status = 0;

	int_result = func(tmp, tmp);

	snprintf(buf, 11, "%d", int_result);
	compare_expected(buf, expected, expstatus, token[0], ctx);
	check_equalmem(tmp, op, token[0]);

	/* Allocation failures */
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		mpd_init_rand(tmp);
		mpd_copy(tmp, op, ctx);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		int_result = func(tmp, tmp);
		mpd_set_alloc(ctx);

		if (int_result != INT_MAX) {
			break;
		}
	}
	snprintf(buf, 11, "%d", int_result);
	compare_expected(buf, expected, expstatus, token[0], ctx);
	check_equalmem(tmp, op, token[0]);
}

static mpd_ssize_t
scan_ssize(char *token[])
{
	errno = 0;
	if (token[1] == NULL) {
		errno = 1;
		return MPD_SSIZE_MAX;
	}
	return mpd_strtossize(token[1], NULL, 10);
}

/*
 * Test a function with an mpd_t and an mpd_ssize_t operand.
 * Used for the shift functions.
 */
static void
_Res_Op_Lsize_Ctx(int skip, char *token[], void (*func)(mpd_t *, const mpd_t *, mpd_ssize_t, mpd_context_t *), mpd_context_t *ctx)
{
	mpd_context_t maxctx;
	char *calc;
	char *expected;
	uint32_t expstatus;
	mpd_ssize_t ssize;
	int n;

	mpd_readcontext(&maxctx);
	maxctx.traps = MPD_Malloc_error;

	n = scan_2ops_result(op1, op2, &expected, token, &maxctx);

	/* scan expected conditions */
	expstatus = scan_conditions(token+n);


	/* only integers are allowed for ssize */
	if (skip && (mpd_isspecial(op2) || op2->exp != 0)) {
		/* fprintf(stderr, "SKIP: %s\n", token[0]); */
		return;
	}
	ssize = mpd_get_ssize(op2, &maxctx);
	if (maxctx.status&MPD_Invalid_operation) {
		return;
	}

	/* two distinct decimals */
	mpd_init_rand(tmp1);
	mpd_copy(tmp1, op1, ctx);
	mpd_init_rand(result);
	ctx->status = 0;

	func(result, tmp1, ssize, ctx);

	calc = mpd_to_sci(result, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp1, op1, token[0]);

	/* Allocation failures */
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		mpd_init_rand(tmp1);
		mpd_copy(tmp1, op1, ctx);
		mpd_minalloc(result);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		func(result, tmp1, ssize, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(result))
	}
	calc = mpd_to_sci(result, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	check_equalmem(tmp1, op1, token[0]);


	/* result == tmp1 */
	mpd_init_rand(tmp1);
	mpd_copy(tmp1, op1, ctx);
	ctx->status = 0;

	func(tmp1, tmp1, ssize, ctx);

	calc = mpd_to_sci(tmp1, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);

	/* Allocation failures */
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		mpd_init_rand(tmp1);
		mpd_copy(tmp1, op1, ctx);
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		func(tmp1, tmp1, ssize, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(tmp1))
	}
	calc = mpd_to_sci(tmp1, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
}

static void
_Baseconv(char *token[], mpd_context_t *ctx)
{
	mpd_context_t maxctx;
	uint32_t base;
	uint16_t *data16;
	uint32_t *data32;
	size_t len16, len32;
	size_t exp_len16, exp_len32;
	char *expected;
	uint32_t expstatus;
	char *calc;
	int n = 0;
	int i, iter = 0;

	mpd_readcontext(&maxctx);
	maxctx.traps = MPD_Malloc_error;

	n = scan_1op_result(op1, &expected, token, &maxctx);
	ASSERT(mpd_isinteger(op1))

	/* scan expected conditions */
	expstatus = scan_conditions(token+n);

	base = (1<<15);
	len16 = mpd_sizeinbase(op1, base);
	data16 = mpd_alloc((mpd_size_t)len16, sizeof *data16);
	exp_len16 = mpd_export_u16(data16, len16, base, op1, ctx);
	if (exp_len16 == SIZE_MAX) {
		mpd_err_fatal("export_to_base failed");
	}

	mpd_import_u16(result, data16, exp_len16, MPD_POS, base, ctx);
	calc = mpd_to_sci(result, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);

	__mingw_dfp_get_globals()->mpd_free(calc);
	__mingw_dfp_get_globals()->mpd_free(data16);

	/* Allocation failures */
	base = (1<<15);
	len16 = mpd_sizeinbase(op1, base);
	data16 = mpd_alloc((mpd_size_t)len16, sizeof *data16);

	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		exp_len16 = mpd_export_u16(data16, len16, base, op1, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(exp_len16 == SIZE_MAX)
	}
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		mpd_import_u16(result, data16, exp_len16, MPD_POS, base, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(result))
	}
	calc = mpd_to_sci(result, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	__mingw_dfp_get_globals()->mpd_free(data16);


	base = (1U<<16);
	len16 = mpd_sizeinbase(op1, base);
	data16 = mpd_alloc((mpd_size_t)len16, sizeof *data16);
	len16 = mpd_export_u16(data16, len16, base, op1, ctx);
	if (len16 == SIZE_MAX) {
		mpd_err_fatal("export_to_base failed");
	}

	mpd_import_u16(result, data16, len16, MPD_POS, base, ctx);
	calc = mpd_to_sci(result, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);

	__mingw_dfp_get_globals()->mpd_free(calc);
	__mingw_dfp_get_globals()->mpd_free(data16);


	base = 9999;
	len16 = mpd_sizeinbase(op1, base);
	data16 = mpd_alloc((mpd_size_t)len16, sizeof *data16);
	exp_len16 = mpd_export_u16(data16, len16, base, op1, ctx);
	if (exp_len16 == SIZE_MAX) {
		mpd_err_fatal("export_to_base failed");
	}

	mpd_import_u16(result, data16, exp_len16, MPD_POS, base, ctx);
	calc = mpd_to_sci(result, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);

	__mingw_dfp_get_globals()->mpd_free(calc);
	__mingw_dfp_get_globals()->mpd_free(data16);


#ifdef RT_EXT_BASECONV
	iter = 16;
#endif
	for (i = 2; i <= iter; i++) {

		base = i;
		len16 = mpd_sizeinbase(op1, base);
		data16 = mpd_alloc((mpd_size_t)len16, sizeof *data16);
		len16 = mpd_export_u16(data16, len16, base, op1, ctx);
		if (len16 == SIZE_MAX) {
			mpd_err_fatal("export_to_base failed");
		}

		mpd_import_u16(result, data16, len16, MPD_POS, base, ctx);
		calc = mpd_to_sci(result, 1);
		compare_expected(calc, expected, expstatus, token[0], ctx);

		__mingw_dfp_get_globals()->mpd_free(calc);
		__mingw_dfp_get_globals()->mpd_free(data16);
	}

#ifdef RT_EXT_BASECONV
	iter = 100;
#endif
	for (i = 0; i < iter; i++) {

		base = random() % UINT16_MAX;
		if (base < 2) base = 2;

		len16 = mpd_sizeinbase(op1, base);
		data16 = mpd_alloc((mpd_size_t)len16, sizeof *data16);
		len16 = mpd_export_u16(data16, len16, base, op1, ctx);
		if (len16 == SIZE_MAX) {
			mpd_err_fatal("export_to_base failed");
		}

		mpd_import_u16(result, data16, len16, MPD_POS, base, ctx);
		calc = mpd_to_sci(result, 1);
		compare_expected(calc, expected, expstatus, token[0], ctx);

		__mingw_dfp_get_globals()->mpd_free(calc);
		__mingw_dfp_get_globals()->mpd_free(data16);
	}


	base = 1000000000;
	len32 = mpd_sizeinbase(op1, base);
	data32 = mpd_alloc((mpd_size_t)len32, sizeof *data32);
	exp_len32 = mpd_export_u32(data32, len32, base, op1, ctx);
	if (exp_len32 == SIZE_MAX) {
		mpd_err_fatal("export_to_base failed");
	}

	mpd_import_u32(result, data32, len32, MPD_POS, base, ctx);
	calc = mpd_to_sci(result, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);

	__mingw_dfp_get_globals()->mpd_free(calc);
	__mingw_dfp_get_globals()->mpd_free(data32);

	/* Allocation failures */
	base = 1000000000;
	len32 = mpd_sizeinbase(op1, base);
	data32 = mpd_alloc((mpd_size_t)len32, sizeof *data32);

	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		exp_len32 = mpd_export_u32(data32, len32, base, op1, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(exp_len32 == SIZE_MAX)
	}
	for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) {
		ctx->status = 0;

		mpd_set_alloc_fail(ctx);
		mpd_import_u32(result, data32, exp_len32, MPD_POS, base, ctx);
		mpd_set_alloc(ctx);

		if (!(ctx->status&MPD_Malloc_error)) {
			break;
		}
		ASSERT(mpd_isnan(result))
	}
	calc = mpd_to_sci(result, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);
	__mingw_dfp_get_globals()->mpd_free(calc);
	__mingw_dfp_get_globals()->mpd_free(data32);


	base = (1<<30);
	len32 = mpd_sizeinbase(op1, base);
	data32 = mpd_alloc((mpd_size_t)len32, sizeof *data32);
	len32 = mpd_export_u32(data32, len32, base, op1, ctx);
	if (len32 == SIZE_MAX) {
		mpd_err_fatal("export_to_base failed");
	}

	mpd_import_u32(result, data32, len32, MPD_POS, base, ctx);
	calc = mpd_to_sci(result, 1);
	compare_expected(calc, expected, expstatus, token[0], ctx);

	__mingw_dfp_get_globals()->mpd_free(calc);
	__mingw_dfp_get_globals()->mpd_free(data32);

	for (i = 2; i <= 16; i++) {

		base = i;
		len32 = mpd_sizeinbase(op1, base);
		data32 = mpd_alloc((mpd_size_t)len32, sizeof *data32);
		len32 = mpd_export_u32(data32, len32, base, op1, ctx);
		if (len32 == SIZE_MAX) {
			mpd_err_fatal("export_to_base failed");
		}

		mpd_import_u32(result, data32, len32, MPD_POS, base, ctx);
		calc = mpd_to_sci(result, 1);
		compare_expected(calc, expected, expstatus, token[0], ctx);

		__mingw_dfp_get_globals()->mpd_free(calc);
		__mingw_dfp_get_globals()->mpd_free(data32);
	}

	for (i = 0; i < 100; i++) {

		base = random() % UINT32_MAX;
		if (base < 2) base = 2;

		len32 = mpd_sizeinbase(op1, base);
		data32 = mpd_alloc((mpd_size_t)len32, sizeof *data32);
		len32 = mpd_export_u32(data32, len32, base, op1, ctx);
		if (len32 == SIZE_MAX) {
			mpd_err_fatal("export_to_base failed");
		}

		mpd_import_u32(result, data32, len32, MPD_POS, base, ctx);
		calc = mpd_to_sci(result, 1);
		compare_expected(calc, expected, expstatus, token[0], ctx);

		__mingw_dfp_get_globals()->mpd_free(calc);
		__mingw_dfp_get_globals()->mpd_free(data32);
	}
}

/*
 * Test a function returning an mpd_uint_t, accepting:
 *     op, context
 *
 * This function is used for:
 *   - mpd_get_uint
 *   - mpd_abs_uint
 *   - mpd_get_u64
 *   - mpd_get_u32
 */
static void
_uint_MpdCtx(char **token, mpd_uint_t (*func)(const mpd_t *, mpd_context_t *), mpd_context_t *ctx)
{
	mpd_context_t maxctx;
	mpd_uint_t calc_uint;
	char calc[23];
	char *expected;
	uint32_t expstatus;
	int n;

	mpd_readcontext(&maxctx);
	maxctx.traps = MPD_Malloc_error;

	/* conversion should be done as if there were no limits */
	n = scan_1op_result(op, &expected, token, &maxctx);

	expstatus = scan_conditions(token+n);

	mpd_init_rand(tmp);
	mpd_copy(tmp, op, ctx);
	ctx->status = 0;

	calc_uint = func(tmp, ctx);
	snprintf(calc, 23, "%" PRI_mpd_uint_t, calc_uint);

	/* compare the calculated result to the expected result */
	compare_expected(calc, expected, expstatus, token[0], ctx);
	check_equalmem(tmp, op, token[0]);
}

/*
 * Test a function returning an mpd_ssize_t, accepting:
 *     op, fmt, context
 *
 * This function is used for:
 *   - mpd_get_ssize
 *   - mpd_get_i64
 *   - mpd_get_i32
 */
static void
_ssize_MpdCtx(char **token, mpd_ssize_t (*func)(const mpd_t *, mpd_context_t *), mpd_context_t *ctx)
{
	mpd_context_t maxctx;
	mpd_ssize_t calc_ssize;
	char calc[23];
	char *expected;
	uint32_t expstatus;
	int n;

	mpd_readcontext(&maxctx);
	maxctx.traps = MPD_Malloc_error;

	/* conversion should be done as if there were no limits */
	n = scan_1op_result(op, &expected, token, &maxctx);

	expstatus = scan_conditions(token+n);

	mpd_init_rand(tmp);
	mpd_copy(tmp, op, ctx);
	ctx->status = 0;

	calc_ssize = func(tmp, ctx);
	snprintf(calc, 23, "%" PRI_mpd_ssize_t, calc_ssize);

	/* compare the calculated result to the expected result */
	compare_expected(calc, expected, expstatus, token[0], ctx);
	check_equalmem(tmp, op, token[0]);
}


/* process a file */
static void
doit(char *filename)
{
	FILE *file;
	mpd_context_t ctx;
	char *line;
	char *tmpline;
	char *token[MAXTOKEN+1];
	uint32_t testno;
	mpd_ssize_t l;


	mpd_testcontext(&ctx);

	ctx.traps = MPD_Malloc_error;

	if (strcmp(filename, "-") == 0) {
		file = stdin;
	}
	else {
		if ((file = fopen(filename, "r")) == NULL) {
			mpd_err_fatal("could not open %s", filename);
		}
	}

	if ((line = mpd_alloc(MAXLINE+1, sizeof *line)) == NULL) {
		mpd_err_fatal("out of memory");
	}
	if ((tmpline = mpd_alloc(MAXLINE+1, sizeof *line)) == NULL) {
		mpd_err_fatal("out of memory");
	}


	while (fgets(line, MAXLINE+1, file) != NULL) {

		/* split a line into tokens */
		strcpy(tmpline, line);
		if (split(token, tmpline) == 0) {
			goto cleanup;
		}


		/* comments */
		if (startswith(token[0], "--")) {
			goto cleanup;
		}
		/* end comments */

		/* skip bool* tests in extra.decTest */
		if (startswith(token[0], "bool")) {
			goto cleanup;
		}
		/* end skips */


		/* directives */
		if (startswith(token[0], "Precision")) {
			l = scan_ssize(token);
			if (errno != 0) {
				mpd_err_fatal("%s: %s", filename, line);
			}
			/*if (!mpd_qsetprec(&ctx, l)) {
				mpd_err_fatal("%s: %s", filename, line);
			}*/
			/* use a wider range than officially allowed */
			ctx.prec = l;
			goto cleanup;
		}

		if (startswith(token[0], "Rounding")) {
			if (eqtoken(token[1], "Ceiling"))
				ctx.round = MPD_ROUND_CEILING;
			else if (eqtoken(token[1], "Up"))
				ctx.round = MPD_ROUND_UP;
			else if (eqtoken(token[1], "Half_up"))
				ctx.round = MPD_ROUND_HALF_UP;
			else if (eqtoken(token[1], "Half_even"))
				ctx.round = MPD_ROUND_HALF_EVEN;
			else if (eqtoken(token[1], "Half_down"))
				ctx.round = MPD_ROUND_HALF_DOWN;
			else if (eqtoken(token[1], "Down"))
				ctx.round = MPD_ROUND_DOWN;
			else if (eqtoken(token[1], "Floor"))
				ctx.round = MPD_ROUND_FLOOR;
			else if (eqtoken(token[1], "05up"))
				ctx.round = MPD_ROUND_05UP;
			else
				mpd_err_fatal("%s: %s", filename, line);
			goto cleanup;
		}

		if (startswith(token[0], "MaxExponent")) {
			l = scan_ssize(token);
			if (errno != 0) {
				mpd_err_fatal("%s: %s", filename, line);
			}
			/*if (!mpd_qsetemax(&ctx, l)) {
				mpd_err_fatal("%s: %s", filename, line);
			}*/
			/* use a wider range than officially allowed */
			ctx.emax = l;
			goto cleanup;
		}

		if (startswith(token[0], "MinExponent")) {
			l = scan_ssize(token);
			if (errno != 0) {
				mpd_err_fatal("%s: %s", filename, line);
			}
			/*if (!mpd_qsetemin(&ctx, l)) {
				mpd_err_fatal("%s: %s", filename, line);
			}*/
			/* use a wider range than officially allowed */
			ctx.emin = l;
			goto cleanup;
		}

		if (startswith(token[0], "Dectest")) {
			if (token[1] == NULL) {
				mpd_err_fatal("%s: %s", filename, line);
			}
			doit(token[1]);
			goto cleanup;
		}
		/* end directives */


		/* optional directives */
		if (startswith(token[0], "Version")) {
			goto cleanup;
		}

		if (startswith(token[0], "Extended")) {
			goto cleanup;
		}

		if (startswith(token[0], "Clamp")) {
			l = scan_ssize(token);
			if (errno != 0) {
				mpd_err_fatal("%s: %s", filename, line);
			}
			if (!mpd_qsetclamp(&ctx, (int)l)) {
				mpd_err_fatal("%s: %s", filename, line);
			}
			goto cleanup;
		}
		if (startswith(token[0], "Locale")) {
			if (token[1] == NULL) {
				mpd_err_fatal("%s: %s", filename, line);
			}
			fprintf(stderr, "locale: %s\n", token[1]);
			if (setlocale(LC_NUMERIC, token[1]) == NULL) {
				mpd_err_fatal("%s: %s", filename, line);
			}
			goto cleanup;
		}
		/* end optional directives */


		/*
		 * Actual tests start here:
		 *   - token[0] is the id
		 *   - token[1] is the operation type
		 *   - testno can be used for setting a watchpoint in the debugger
		 */
		testno = get_testno(token[0]);
		(void)testno;

		/* The id is in the skip list */
		if (check_skip(token[0])) {
			goto cleanup;
		}
#ifdef CONFIG_32
		/* Skip coverage tests with excessive run time. */
		if (startswith(token[0], "cov64")) {
			goto cleanup;
		}
#endif
		/* Translate operation type for powmod */
		if (startswith(token[0], "pwmx")) {
			free(token[1]);
			token[1] = malloc(sizeof("powmod"));
			strcpy(token[1], "powmod");
		}
		/* end skips */


		/* Unary functions with char * result */
		if (eqtoken(token[1], "tosci") || eqtoken(token[1], "apply")) {
			_cp_MpdCtx(token, mpd_to_sci, &ctx);
		}
		else if (eqtoken(token[1], "toeng")) {
			_cp_MpdCtx(token, mpd_to_eng, &ctx);
		}
		else if (eqtoken(token[1], "format")) {
			_cp_MpdFmtCtx(token, mpd_format, &ctx);
		}
		/* Unary function with const char * result */
		else if (eqtoken(token[1], "class")) {
			_ccp_MpdCtx(token, mpd_class, &ctx);
		}

		/* Unary functions with mpd_t * result */
		else if (eqtoken(token[1], "abs")) {
			_Res_Op_Ctx(token, mpd_abs, &ctx);
		}
		else if (eqtoken(token[1], "copy")) {
			_Res_Op_Ctx(token, mpd_copy, &ctx);
		}
		else if (eqtoken(token[1], "copyabs")) {
			_Res_Op_Ctx(token, mpd_copy_abs, &ctx);
		}
		else if (eqtoken(token[1], "copynegate")) {
			_Res_Op_Ctx(token, mpd_copy_negate, &ctx);
		}
		else if (eqtoken(token[1], "exp")) {
			ctx.allcr = 0;
			_Res_Op_Ctx(token, mpd_exp, &ctx);
			ctx.allcr = 1;
			_Res_Op_Ctx(token, mpd_exp, &ctx);
		}
		else if (eqtoken(token[1], "invert")) {
			_Res_Op_Ctx(token, mpd_invert, &ctx);
		}
		else if (eqtoken(token[1], "invroot")) {
			_Res_Op_Ctx(token, mpd_invroot, &ctx);
		}
		else if (eqtoken(token[1], "ln")) {
			ctx.allcr = 0;
			_Res_Op_Ctx(token, mpd_ln, &ctx);
			ctx.allcr = 1;
			_Res_Op_Ctx(token, mpd_ln, &ctx);
		}
		else if (eqtoken(token[1], "log10")) {
			ctx.allcr = 0;
			_Res_Op_Ctx(token, mpd_log10, &ctx);
			ctx.allcr = 1;
			_Res_Op_Ctx(token, mpd_log10, &ctx);
		}
		else if (eqtoken(token[1], "logb")) {
			_Res_Op_Ctx(token, mpd_logb, &ctx);
		}
		else if (eqtoken(token[1], "minus")) {
			_Res_Op_Ctx(token, mpd_minus, &ctx);
		}
		else if (eqtoken(token[1], "nextminus")) {
			_Res_Op_Ctx(token, mpd_next_minus, &ctx);
		}
		else if (eqtoken(token[1], "nextplus")) {
			_Res_Op_Ctx(token, mpd_next_plus, &ctx);
		}
		else if (eqtoken(token[1], "plus")) {
			_Res_Op_Ctx(token, mpd_plus, &ctx);
		}
		else if (eqtoken(token[1], "reduce")) {
			_Res_Op_Ctx(token, mpd_reduce, &ctx);
		}
		else if (eqtoken(token[1], "squareroot")) {
			_Res_Op_Ctx(token, mpd_sqrt, &ctx);
		}
		else if (eqtoken(token[1], "tointegral")) {
			_Res_Op_Ctx(token, mpd_round_to_int, &ctx);
		}
		else if (eqtoken(token[1], "tointegralx")) {
			_Res_Op_Ctx(token, mpd_round_to_intx, &ctx);
		}
		else if (eqtoken(token[1], "floor")) {
			_Res_Op_Ctx(token, mpd_floor, &ctx);
		}
		else if (eqtoken(token[1], "ceil")) {
			_Res_Op_Ctx(token, mpd_ceil, &ctx);
		}
		else if (eqtoken(token[1], "trunc")) {
			_Res_Op_Ctx(token, mpd_trunc, &ctx);
		}


		/* Binary function returning an int */
		else if (eqtoken(token[1], "samequantum")) {
			_Int_Binop(token, mpd_same_quantum, &ctx);
		}
		/* Binary function returning an int, equal operands */
		else if (eqtoken(token[1], "samequantum_eq")) {
			_Int_EqualBinop(token, mpd_same_quantum, &ctx);
		}

		/* Binary functions with mpd_t * result */
		else if (eqtoken(token[1], "add")) {
			_Res_Binop_Ctx(token, mpd_add, &ctx);
		}
		else if (eqtoken(token[1], "and")) {
			_Res_Binop_Ctx(token, mpd_and, &ctx);
		}
		else if (eqtoken(token[1], "copysign")) {
			_Res_Binop_Ctx(token, mpd_copy_sign, &ctx);
		}
		else if (eqtoken(token[1], "divide")) {
			_Res_Binop_Ctx(token, mpd_div, &ctx);
			_Res_Binop_Ctx(token, mpd_test_newtondiv, &ctx);
		}
		else if (eqtoken(token[1], "divideint")) {
			_Res_Binop_Ctx(token, mpd_divint, &ctx);
			_Res_Binop_Ctx(token, mpd_test_newtondivint, &ctx);
		}
		else if (eqtoken(token[1], "max")) {
			_Res_Binop_Ctx(token, mpd_max, &ctx);
		}
		else if (eqtoken(token[1], "maxmag")) {
			_Res_Binop_Ctx(token, mpd_max_mag, &ctx);
		}
		else if (eqtoken(token[1], "min")) {
			_Res_Binop_Ctx(token, mpd_min, &ctx);
		}
		else if (eqtoken(token[1], "minmag")) {
			_Res_Binop_Ctx(token, mpd_min_mag, &ctx);
		}
		else if (eqtoken(token[1], "multiply")) {
			_Res_Binop_Ctx(token, mpd_mul, &ctx);
		}
		else if (eqtoken(token[1], "nexttoward")) {
			_Res_Binop_Ctx(token, mpd_next_toward, &ctx);
		}
		else if (eqtoken(token[1], "or")) {
			_Res_Binop_Ctx(token, mpd_or, &ctx);
		}
		else if (eqtoken(token[1], "power")) {
			ctx.allcr = 0;
			_Res_Binop_Ctx(token, mpd_pow, &ctx);
			ctx.allcr = 1;
			_Res_Binop_Ctx(token, mpd_pow, &ctx);
		}
		else if (eqtoken(token[1], "quantize")) {
			_Res_Binop_Ctx(token, mpd_quantize, &ctx);
		}
		else if (eqtoken(token[1], "resc")) {
			_Res_Op_Lsize_Ctx(SKIP_NONINT, token, mpd_rescale, &ctx);
		}
		else if (eqtoken(token[1], "remainder")) {
			_Res_Binop_Ctx(token, mpd_rem, &ctx);
			_Res_Binop_Ctx(token, mpd_test_newtonrem, &ctx);
		}
		else if (eqtoken(token[1], "remaindernear")) {
			_Res_Binop_Ctx(token, mpd_rem_near, &ctx);
		}
		else if (eqtoken(token[1], "rotate")) {
			_Res_Binop_Ctx(token, mpd_rotate, &ctx);
		}
		else if (eqtoken(token[1], "scaleb")) {
			_Res_Binop_Ctx(token, mpd_scaleb, &ctx);
		}
		else if (eqtoken(token[1], "shift")) {
			_Res_Binop_Ctx(token, mpd_shift, &ctx);
			_Res_Op_Lsize_Ctx(SKIP_NONINT, token, mpd_shiftn, &ctx);
		}
		else if (eqtoken(token[1], "subtract")) {
			_Res_Binop_Ctx(token, mpd_sub, &ctx);
		}
		else if (eqtoken(token[1], "xor")) {
			_Res_Binop_Ctx(token, mpd_xor, &ctx);
		}

		/* Binary functions with mpd_t result, equal operands */
		else if (eqtoken(token[1], "add_eq")) {
			_Res_EqualBinop_Ctx(token, mpd_add, &ctx);
		}
		else if (eqtoken(token[1], "and_eq")) {
			_Res_EqualBinop_Ctx(token, mpd_and, &ctx);
		}
		else if (eqtoken(token[1], "copysign_eq")) {
			_Res_EqualBinop_Ctx(token, mpd_copy_sign, &ctx);
		}
		else if (eqtoken(token[1], "divide_eq")) {
			_Res_EqualBinop_Ctx(token, mpd_div, &ctx);
			_Res_EqualBinop_Ctx(token, mpd_test_newtondiv, &ctx);
		}
		else if (eqtoken(token[1], "divideint_eq")) {
			_Res_EqualBinop_Ctx(token, mpd_divint, &ctx);
			_Res_EqualBinop_Ctx(token, mpd_test_newtondivint, &ctx);
		}
		else if (eqtoken(token[1], "max_eq")) {
			_Res_EqualBinop_Ctx(token, mpd_max, &ctx);
		}
		else if (eqtoken(token[1], "maxmag_eq")) {
			_Res_EqualBinop_Ctx(token, mpd_max_mag, &ctx);
		}
		else if (eqtoken(token[1], "min_eq")) {
			_Res_EqualBinop_Ctx(token, mpd_min, &ctx);
		}
		else if (eqtoken(token[1], "minmag_eq")) {
			_Res_EqualBinop_Ctx(token, mpd_min_mag, &ctx);
		}
		else if (eqtoken(token[1], "multiply_eq")) {
			_Res_EqualBinop_Ctx(token, mpd_mul, &ctx);
		}
		else if (eqtoken(token[1], "nexttoward_eq")) {
			_Res_EqualBinop_Ctx(token, mpd_next_toward, &ctx);
		}
		else if (eqtoken(token[1], "or_eq")) {
			_Res_EqualBinop_Ctx(token, mpd_or, &ctx);
		}
		else if (eqtoken(token[1], "power_eq")) {
			ctx.allcr = 0;
			_Res_EqualBinop_Ctx(token, mpd_pow, &ctx);
			ctx.allcr = 1;
			_Res_EqualBinop_Ctx(token, mpd_pow, &ctx);
		}
		else if (eqtoken(token[1], "quantize_eq")) {
			_Res_EqualBinop_Ctx(token, mpd_quantize, &ctx);
		}
		else if (eqtoken(token[1], "remainder_eq")) {
			_Res_EqualBinop_Ctx(token, mpd_rem, &ctx);
			_Res_EqualBinop_Ctx(token, mpd_test_newtonrem, &ctx);
		}
		else if (eqtoken(token[1], "remaindernear_eq")) {
			_Res_EqualBinop_Ctx(token, mpd_rem_near, &ctx);
		}
		else if (eqtoken(token[1], "rotate_eq")) {
			_Res_EqualBinop_Ctx(token, mpd_rotate, &ctx);
		}
		else if (eqtoken(token[1], "scaleb_eq")) {
			_Res_EqualBinop_Ctx(token, mpd_scaleb, &ctx);
		}
		else if (eqtoken(token[1], "shift_eq")) {
			_Res_EqualBinop_Ctx(token, mpd_shift, &ctx);
		}
		else if (eqtoken(token[1], "subtract_eq")) {
			_Res_EqualBinop_Ctx(token, mpd_sub, &ctx);
		}
		else if (eqtoken(token[1], "xor_eq")) {
			_Res_EqualBinop_Ctx(token, mpd_xor, &ctx);
		}

		/* Binary function with binary result */
		else if (eqtoken(token[1], "divmod")) {
			_Binres_Binop_Ctx(token, mpd_divmod, &ctx);
			_Binres_Binop_Ctx(token, mpd_test_newtondivmod, &ctx);
		}

		/* Binary function with binary result, equal operands */
		else if (eqtoken(token[1], "divmod_eq")) {
			_Binres_EqualBinop_Ctx(token, mpd_divmod, &ctx);
			_Binres_EqualBinop_Ctx(token, mpd_test_newtondivmod, &ctx);
		}


		/* Ternary functions with mpd_t result */
		else if (eqtoken(token[1], "fma")) {
			_Res_Ternop_Ctx(token, mpd_fma, &ctx);
		}
		else if (eqtoken(token[1], "powmod")) {
			_Res_Ternop_Ctx(token, mpd_powmod, &ctx);
		}

		/* Ternary functions with mpd_t result, eq_eq_op */
		else if (eqtoken(token[1], "fma_eq_eq_op")) {
			_Res_EqEqOp_Ctx(token, mpd_fma, &ctx);
		}
		else if (eqtoken(token[1], "powmod_eq_eq_op")) {
			_Res_EqEqOp_Ctx(token, mpd_powmod, &ctx);
		}

		/* Ternary functions with mpd_t result, eq_op_eq */
		else if (eqtoken(token[1], "fma_eq_op_eq")) {
			_Res_EqOpEq_Ctx(token, mpd_fma, &ctx);
		}
		else if (eqtoken(token[1], "powmod_eq_op_eq")) {
			_Res_EqOpEq_Ctx(token, mpd_powmod, &ctx);
		}

		/* Ternary functions with mpd_t result, op_eq_eq */
		else if (eqtoken(token[1], "fma_op_eq_eq")) {
			_Res_OpEqEq_Ctx(token, mpd_fma, &ctx);
		}
		else if (eqtoken(token[1], "powmod_op_eq_eq")) {
			_Res_OpEqEq_Ctx(token, mpd_powmod, &ctx);
		}

		/* Ternary functions with mpd_t result, eq_eq_eq */
		else if (eqtoken(token[1], "fma_eq_eq_eq")) {
			_Res_EqEqEq_Ctx(token, mpd_fma, &ctx);
		}
		else if (eqtoken(token[1], "powmod_eq_eq_eq")) {
			_Res_EqEqEq_Ctx(token, mpd_powmod, &ctx);
		}

		/* Special cases for the comparison functions */
		else if (eqtoken(token[1], "compare")) {
			_Int_Res_Binop_Ctx(token, mpd_compare, &ctx);
			_Int_Binop_Ctx(SKIP_NAN, token, mpd_cmp, &ctx);
		}
		else if (eqtoken(token[1], "comparesig")) {
			_Int_Res_Binop_Ctx(token, mpd_compare_signal, &ctx);
		}
		else if (eqtoken(token[1], "comparetotal")) {
			_Int_Res_Binop(token, mpd_compare_total, &ctx);
			_Int_Binop(token, mpd_cmp_total, &ctx);
		}
		else if (eqtoken(token[1], "comparetotmag")) {
			_Int_Res_Binop(token, mpd_compare_total_mag, &ctx);
			_Int_Binop(token, mpd_cmp_total_mag, &ctx);
		}

		/* Special cases for the comparison functions, equal operands */
		else if (eqtoken(token[1], "compare_eq")) {
			_Int_Res_EqualBinop_Ctx(token, mpd_compare, &ctx);
			_Int_EqualBinop_Ctx(SKIP_NAN, token, mpd_cmp, &ctx);
		}
		else if (eqtoken(token[1], "comparesig_eq")) {
			_Int_Res_EqualBinop_Ctx(token, mpd_compare_signal, &ctx);
		}
		else if (eqtoken(token[1], "comparetotal_eq")) {
			_Int_Res_EqualBinop(token, mpd_compare_total, &ctx);
			_Int_EqualBinop(token, mpd_cmp_total, &ctx);
		}
		else if (eqtoken(token[1], "comparetotmag_eq")) {
			_Int_Res_EqualBinop(token, mpd_compare_total_mag, &ctx);
			_Int_EqualBinop(token, mpd_cmp_total_mag, &ctx);
		}

		/* Special cases for the shift functions */
		else if (eqtoken(token[1], "shiftleft")) {
			_Res_Op_Lsize_Ctx(SKIP_NONINT, token, mpd_shiftl, &ctx);
		}
		else if (eqtoken(token[1], "shiftright")) {
			_Res_Op_Lsize_Ctx(SKIP_NONINT, token,
			(void (*)(mpd_t *, const mpd_t *, mpd_ssize_t, mpd_context_t *))mpd_shiftr, &ctx);
		}

		/* Special case for the base conversion functions */
		else if (eqtoken(token[1], "baseconv")) {
			_Baseconv(token, &ctx);
		}

		/* Special cases for the get_int functions */
#ifdef CONFIG_64
		else if (eqtoken(token[1], "get_uint64")) {
			_uint_MpdCtx(token, mpd_get_uint, &ctx);
		}
		else if (eqtoken(token[1], "get_uint64_abs")) {
			_uint_MpdCtx(token, mpd_abs_uint, &ctx);
		}
		else if (eqtoken(token[1], "get_u64")) {
			_uint_MpdCtx(token, mpd_get_u64, &ctx);
		}
		else if (eqtoken(token[1], "get_ssize64")) {
			_ssize_MpdCtx(token, mpd_get_ssize, &ctx);
		}
		else if (eqtoken(token[1], "get_i64")) {
			_ssize_MpdCtx(token, mpd_get_i64, &ctx);
		}
#else
		else if (eqtoken(token[1], "get_uint32")) {
			_uint_MpdCtx(token, mpd_get_uint, &ctx);
		}
		else if (eqtoken(token[1], "get_uint32_abs")) {
			_uint_MpdCtx(token, mpd_abs_uint, &ctx);
		}
		else if (eqtoken(token[1], "get_u32")) {
			_uint_MpdCtx(token, mpd_get_u32, &ctx);
		}
		else if (eqtoken(token[1], "get_ssize32")) {
			_ssize_MpdCtx(token, mpd_get_ssize, &ctx);
		}
		else if (eqtoken(token[1], "get_i32")) {
			_ssize_MpdCtx(token, mpd_get_i32, &ctx);
		}
#endif

		else if (startswith(token[1], "get_")) {
			;
		}

		else if (eqtoken(token[1], "rescale")) {
			;
		}

		/* unknown operation */
		else {
			mpd_err_fatal("%s: unknown operation: %s", filename, line);
		}
		/* end tests */

		cleanup:
		freetoken(token);
	}

	__mingw_dfp_get_globals()->mpd_free(line);
	__mingw_dfp_get_globals()->mpd_free(tmpline);
	if (file != stdin) {
		fclose(file);
	}
}


int main(int argc, char **argv)
{
	mpd_ssize_t ma, limit;
	int n = 1;

	if (argc == 2) {
		limit = 2;
	}
	else if (argc == 3) {
		if (strcmp(argv[n++], "--all") != 0) {
			fputs("runtest: usage: runtest [--all] testfile\n", stderr);
			exit(EXIT_FAILURE);
		}
		limit = MPD_MINALLOC_MAX;
	}
	else {
		fputs("runtest: usage: runtest [--all] testfile\n", stderr);
		exit(EXIT_FAILURE);
	}

	srand((unsigned int)time(NULL));

	for (ma = MPD_MINALLOC_MIN; ma <= limit; ma++) {

		/* DON'T do this in a real program. You have to be sure
		 * that no previously allocated decimals will ever be used. */
		__mingw_dfp_get_globals()->MPD_MINALLOC = ma;
		if (n == 2) {
			fprintf(stderr, "minalloc: %" PRI_mpd_ssize_t "\n", __mingw_dfp_get_globals()->MPD_MINALLOC);
		}

		op = mpd_qnew();
		op1 = mpd_qnew();
		op2 = mpd_qnew();
		op3 = mpd_qnew();
		tmp = mpd_qnew();
		tmp1 = mpd_qnew();
		tmp2 = mpd_qnew();
		tmp3 = mpd_qnew();
		result = mpd_qnew();
		result1 = mpd_qnew();
		result2 = mpd_qnew();

		doit(argv[n]);

		mpd_del(op);
		mpd_del(op1);
		mpd_del(op2);
		mpd_del(op3);
		mpd_del(tmp);
		mpd_del(tmp1);
		mpd_del(tmp2);
		mpd_del(tmp3);
		mpd_del(result);
		mpd_del(result1);
		mpd_del(result2);

		if (have_printed) {
			fputc('\n', stderr);
		}
	}

	/* Valgrind */
	mpd_del(&__mingw_dfp_get_globals()->mpd_ln10);

	return have_fail;
}