fpc/packages/gmp/examples/gmp_test_impl.inc

{$ifopt c-}
{$error 'Must enable assertions'}
{$endif}

const
  BASE10 = 10;
  BASE16 = 16;
  Z_FMT = '%Zd';
  Q_FMT = '%Qd';

function alloc_func(alloc_size: sizeuint): pointer; cdecl;
begin
  result := getmem(alloc_size);
end;

procedure free_proc(p: pointer; size: sizeuint); cdecl;
begin
  assert(size = size); // hint off
  freemem(p);
end;

function reallocate_func(p: pointer; old_size, new_size: sizeuint): pointer; cdecl;
begin
  assert(old_size = old_size); // hint off
  result := reallocmem(p, new_size);
end;

function rnd_test(var state: randstate_t): boolean;
const N = 1000000;
var r1, r2, r3: valuint;
begin
  r1 := mp_urandomm_ui(state, N);
  r2 := mp_urandomm_ui(state, N);
  r3 := mp_urandomm_ui(state, N);
  result := (r1 < N) and (r2 < N) and (r3 < N) and ((r1 <> r2) or (r1 <> r3) or (r2 <> r3));
end;

{ TTestGmpBinding }

procedure TTestGmpBinding.mp_set_memory_functions_test;
var
  af0, af: alloc_func_t;
  rf0, rf: reallocate_func_t;
  fp0, fp: free_proc_t;
begin
  mp_get_memory_functions(@af0, @rf0, @fp0);
  try
    mp_set_memory_functions(@alloc_func, @reallocate_func, @free_proc);
    mp_get_memory_functions(@af, @rf, @fp);
    assert(af = @alloc_func);
    assert(rf = @reallocate_func);
    assert(fp = @free_proc);
  finally
    mp_set_memory_functions(af0, rf0, fp0);
    mp_get_memory_functions(@af, @rf, @fp);
    assert(af = af0);
    assert(rf = rf0);
    assert(fp = fp0);
  end;
end;

procedure TTestGmpBinding.mp_get_memory_functions_test;
var
  af: alloc_func_t;
  fp: free_proc_t;
  rf: reallocate_func_t;
begin
  af := nil;
  fp := nil;
  rf := nil;
  mp_get_memory_functions(nil, nil, nil);
  assert(af = nil);
  assert(fp = nil);
  assert(rf = nil);

  mp_get_memory_functions(@af, nil, nil);
  assert(af <> nil);
  assert(fp = nil);
  assert(rf = nil);

  af := nil;
  mp_get_memory_functions(nil, @rf, nil);
  assert(af = nil);
  assert(fp = nil);
  assert(rf <> nil);

  rf := nil;
  mp_get_memory_functions(nil, nil, @fp);
  assert(af = nil);
  assert(fp <> nil);
  assert(rf = nil);
end;

procedure TTestGmpBinding.mp_randinit_default_test;
var state: randstate_t;
begin
  mp_randinit_default(state);
  assert(rnd_test(state));
  mp_randclear(state);
end;

procedure TTestGmpBinding.mp_randinit_mt_test;
var state: randstate_t;
begin
  mp_randinit_mt(state);
  assert(rnd_test(state));
  mp_randclear(state);
end;

procedure TTestGmpBinding.mp_randinit_lc_2exp_test;
const
  A_ =  3;
  C = 5;
  M2EXP = 8;
var
  state: randstate_t;
  a: mpz_t;
begin
  mpz_init_set_ui(a, A_);
  mp_randinit_lc_2exp(state, a, C, M2EXP);
  assert(rnd_test(state));
  mp_randclear(state);
  mpz_clear(a);
end;

procedure TTestGmpBinding.mp_randinit_lc_2exp_size_test;
var state: randstate_t;
begin
  assert(longbool(mp_randinit_lc_2exp_size(state, 0)));
  assert(rnd_test(state));
  mp_randclear(state);
end;

procedure TTestGmpBinding.mp_randinit_set_test;
var rop, op: randstate_t;
begin
  mp_randinit_default(op);
  mp_randinit_set(rop, op);
  assert(rnd_test(rop));
  mp_randclear(rop);
  mp_randclear(op);
end;

procedure TTestGmpBinding.mp_randclear_test;
var state: randstate_t;
begin
  mp_randinit_default(state);
  mp_randclear(state);
end;

procedure TTestGmpBinding.mp_randseed_test;
var
  state: randstate_t;
  seed: mpz_t;
begin
  mp_randinit_default(state);
  mpz_init_set_ui(seed, 0);
  mp_randseed(state, seed);
  mp_randclear(state);
  mpz_clear(seed);
end;

procedure TTestGmpBinding.mp_randseed_ui_test;
var state: randstate_t;
begin
  mp_randinit_default(state);
  mp_randseed_ui(state, 0);
  mp_randclear(state);
end;

procedure TTestGmpBinding.mp_urandomb_ui_test;
const
  B = 8 * (sizeof(valuint) - 1);
  N = 1 shl B;
var
  state: randstate_t;
  r1, r2, r3: valuint;
begin
  mp_randinit_default(state);
  r1 := mp_urandomb_ui(state, B);
  r2 := mp_urandomb_ui(state, B);
  r3 := mp_urandomb_ui(state, B);
  assert((r1 < N) and (r2 < N) and (r3 < N) and ((r1 <> r2) or (r1 <> r3) or (r2 <> r3)));
  mp_randclear(state);
end;

procedure TTestGmpBinding.mp_urandomm_ui_test;
const  N = high(valuint);
var
  state: randstate_t;
  r1, r2, r3: valuint;
begin
  mp_randinit_default(state);
  r1 := mp_urandomm_ui(state, N);
  r2 := mp_urandomm_ui(state, N);
  r3 := mp_urandomm_ui(state, N);
  assert((r1 < N) and (r2 < N) and (r3 < N) and ((r1 <> r2) or (r1 <> r3) or (r2 <> r3)));
  mp_randclear(state);
end;

procedure TTestGmpBinding.mp_asprintf_test;
const
  N = 123456;
  S = '123456';
var
  z: mpz_t;
  p: pchar;
begin
  mpz_init_set_ui(z, N);
  assert(mp_asprintf(p, Z_FMT, [@z]) = length(S));
  assert(p = S);
  freemem(p);
  mpz_clear(z);
end;

procedure TTestGmpBinding.mp_asprintf_test2;
const
  N = 123456;
  S = '123456';
var
  z: mpz_t;
  p: pchar;
begin
  mpz_init_set_ui(z, N);
  assert(mp_asprintf(p, Z_FMT, @z) = length(S));
  assert(p = S);
  freemem(p);
  mpz_clear(z);
end;

procedure TTestGmpBinding.mp_snprintf_test;
const
  N = 123456;
  S = '123456';
var
  z: mpz_t;
  buf: pchar;
begin
  mpz_init_set_ui(z, N);
  getmem(buf, length(S) + 1);
  assert(mp_snprintf(buf, length(S) + 1, Z_FMT, [@z]) = length(S));
  assert(buf = S);
  freemem(buf);
  mpz_clear(z);
end;

procedure TTestGmpBinding.mp_snprintf_test2;
const
  N = 123456;
  S = '123456';
var
  z: mpz_t;
  buf: pchar;
begin
  mpz_init_set_ui(z, N);
  getmem(buf, length(S) + 1);
  assert(mp_snprintf(buf, length(S) + 1, Z_FMT, @z) = length(S));
  assert(buf = S);
  freemem(buf);
  mpz_clear(z);
end;

procedure TTestGmpBinding.mp_sprintf_test;
const
  N = 123456;
  S = '123456';
var
  z: mpz_t;
  buf: pchar;
begin
  mpz_init_set_ui(z, N);
  getmem(buf, length(S) + 1);
  assert(mp_sprintf(buf, Z_FMT, [@z]) = length(S));
  assert(buf = S);
  freemem(buf);
  mpz_clear(z);
end;

procedure TTestGmpBinding.mp_sprintf_test2;
const
  N = 123456;
  S = '123456';
var
  z: mpz_t;
  buf: pchar;
begin
  mpz_init_set_ui(z, N);
  getmem(buf, length(S) + 1);
  assert(mp_sprintf(buf, Z_FMT, @z) = length(S));
  assert(buf = S);
  freemem(buf);
  mpz_clear(z);
end;

procedure TTestGmpBinding.mp_sscanf_test;
const
  N = 3;
  D = 2;
var q: mpq_t;
begin
  mpq_init(q);
  assert(mp_sscanf(pchar(inttostr(N) + '/' + inttostr(D)), Q_FMT, [@q]) = 1);
  assert(mpq_cmp_ui(q, N, D) = 0);
  mpq_clear(q);
end;

procedure TTestGmpBinding.mp_sscanf_test2;
const
  N = 3;
  D = 2;
var q: mpq_t;
begin
  mpq_init(q);
  assert(mp_sscanf(pchar(inttostr(N) + '/' + inttostr(D)), Q_FMT, @q) = 1);
  assert(mpq_cmp_ui(q, N, D) = 0);
  mpq_clear(q);
end;

procedure TTestGmpBinding.mpz_init_test;
var integer_: mpz_t;
begin
  mpz_init(integer_);
  assert(mpz_get_si(integer_) = 0);
  mpz_clear(integer_);
end;

procedure TTestGmpBinding.mpz_clear_test;
const N = 1000000;
var integer_: mpz_t;
begin
  mpz_init2(integer_, N);
  assert(mpz_get_si(integer_) = 0);
  mpz_clear(integer_);
end;

procedure TTestGmpBinding.mpz_init2_test;
const N = 1000000;
var integer_: mpz_t;
begin
  mpz_init2(integer_, N);
  assert(mpz_get_si(integer_) = 0);
  mpz_clear(integer_);
end;

procedure TTestGmpBinding.mpz_init_set_si_test;
const N = -1000000;
var rop: mpz_t;
begin
  mpz_init_set_si(rop, N);
  assert(mpz_get_si(rop) = N);
  mpz_clear(rop);
end;

procedure TTestGmpBinding.mpz_init_set_ui_test;
const N = 1000000;
var rop: mpz_t;
begin
  mpz_init_set_ui(rop, N);
  assert(mpz_get_ui(rop) = N);
  mpz_clear(rop);
end;

procedure TTestGmpBinding.mpz_init_set_d_test;
const N = -1000000;
var rop: mpz_t;
begin
  mpz_init_set_d(rop, N);
  assert(mpz_get_si(rop) = N);
  mpz_clear(rop);
end;

procedure TTestGmpBinding.mpz_init_set_test;
const N = -1000000;
var rop, op: mpz_t;
begin
  mpz_init_set_si(op, N);
  mpz_init_set(rop, op);
  assert(mpz_get_si(rop) = N);
  mpz_clear(rop);
  mpz_clear(op);
end;

procedure TTestGmpBinding.mpz_init_set_str_test;
const N = 1000000;
var rop: mpz_t;
begin
  assert(mpz_init_set_str(rop, pchar(inttostr(N)), BASE10) = 0);
  assert(mpz_get_si(rop) = N);
  mpz_clear(rop);
end;

procedure TTestGmpBinding.mpz_realloc_test;
const N = 1000;
var integer_: mpz_t;
begin
  mpz_init(integer_);
  mpz_realloc(integer_, N);
  mpz_clear(integer_)
end;

procedure TTestGmpBinding.mpz_realloc2_test;
const N = 1000;
var integer_: mpz_t;
begin
  mpz_init(integer_);
  mpz_realloc2(integer_, N);
  mpz_clear(integer_)
end;

procedure TTestGmpBinding.mpz_getlimbn_test;
const N = 1234;
var op: mpz_t;
begin
  mpz_init_set_ui(op, N);
  assert(mpz_getlimbn(op, 0) = N);
  mpz_clear(op);
end;

procedure TTestGmpBinding.mpz_export_test;
type t = word;
const
  N = 1000000;
  BUF_HIGH = sizeof(N) div sizeof(t);
var
  export_op, import_op: mpz_t;
  buf: array[0..BUF_HIGH] of t;
  count: sizeuint;
begin
  mpz_init_set_si(export_op, N);
  mpz_init(import_op);
  mpz_export(buf, count, -1, sizeof(t), 0, 0, export_op);
  mpz_import(import_op, count, -1, sizeof(t), 0, 0, buf);
  assert(mpz_get_si(export_op) =mpz_get_si(import_op));
  mpz_clear(export_op);
  mpz_clear(import_op);
end;

procedure TTestGmpBinding.mpz_import_test;
type t = word;
const
  N = 1000000;
  BUF_HIGH = sizeof(N) div sizeof(t);
var
  export_op, import_op: mpz_t;
  buf: array[0..BUF_HIGH] of t;
  count: sizeuint;
begin
  mpz_init_set_si(export_op, N);
  mpz_init(import_op);
  mpz_export(buf, count, -1, sizeof(t), 0, 0, export_op);
  mpz_import(import_op, count, -1, sizeof(t), 0, 0, buf);
  assert(mpz_get_si(export_op) =mpz_get_si(import_op));
  mpz_clear(export_op);
  mpz_clear(import_op);
end;

procedure TTestGmpBinding.mpz_swap_test;
const
  ROP_1 = -1000;
  ROP_2 = 1000000;
var rop1, rop2: mpz_t;
begin
  mpz_init_set_si(rop1, ROP_1);
  mpz_init_set_si(rop2, ROP_2);
  mpz_swap(rop1, rop2);
  assert(mpz_get_si(rop1) = ROP_2);
  assert(mpz_get_si(rop2) = ROP_1);
  mpz_clear(rop1);
  mpz_clear(rop2);
end;

procedure TTestGmpBinding.mpz_set_test;
const OP_ = 1000000;
var rop, op: mpz_t;
begin
  mpz_init(rop);
  mpz_init_set_si(op, OP_);
  mpz_set(rop, op);
  assert(mpz_get_si(rop) = OP_);
  mpz_clear(rop);
  mpz_clear(op);
end;

procedure TTestGmpBinding.mpz_set_d_test;
const OP_ = 1000000;
var rop: mpz_t;
begin
  mpz_init(rop);
  mpz_set_d(rop, OP_);
  assert(mpz_get_si(rop) = OP_);
  mpz_clear(rop);
end;

procedure TTestGmpBinding.mpz_set_f_test;
const OP_ = -10;
var
  op: mpf_t;
  rop: mpz_t;
begin
  mpf_init_set_si(op, OP_);
  mpz_init(rop);
  mpz_set_f(rop, op);
  assert(mpz_get_si(rop) = OP_);
  mpz_clear(rop);
  mpf_clear(op);
end;

procedure TTestGmpBinding.mpz_set_q_test;
const OP_ = -10;
var
  op: mpq_t;
  rop: mpz_t;
begin
  mpq_init(op);
  mpz_init(rop);
  mpq_set_si(op, OP_, 1);
  mpz_set_q(rop, op);
  assert(mpz_get_si(rop) = OP_);
  mpz_clear(rop);
  mpq_clear(op);
end;

procedure TTestGmpBinding.mpz_set_si_test;
const OP_ = -1000000;
var rop: mpz_t;
begin
  mpz_init(rop);
  mpz_set_si(rop, OP_);
  assert(mpz_get_si(rop) = OP_);
  mpz_clear(rop);
end;

procedure TTestGmpBinding.mpz_set_str_test;
const OP_ = -1000000;
var rop: mpz_t;
begin
  mpz_init(rop);
  assert(mpz_set_str(rop, pchar(inttostr(OP_)), BASE10) = 0);
  assert(mpz_get_si(rop) = OP_);
  mpz_clear(rop);
end;

procedure TTestGmpBinding.mpz_set_ui_test;
const OP_ = 1000000;
var rop: mpz_t;
begin
  mpz_init(rop);
  mpz_set_ui(rop, OP_);
  assert(mpz_get_si(rop) = OP_);
  mpz_clear(rop);
end;

procedure TTestGmpBinding.mpz_get_d_test;
const N = -1000;
var op: mpz_t;
begin
  mpz_init_set_si(op, N);
  assert(mpz_get_d(op) = N);
  mpz_clear(op)
end;

procedure TTestGmpBinding.mpz_get_d_2exp_test;
const
  N_LG2 = 4;
  N = 1 shl N_LG2;
var
  op: mpz_t;
  exp: mp_exp_t;
begin
  mpz_init_set_si(op, N);
  assert(mpz_get_d_2exp(exp, op) = 1 / 2);
  assert(exp = N_LG2 + 1);
  mpz_clear(op)
end;

procedure TTestGmpBinding.mpz_get_si_test;
const N = -1000000;
var op: mpz_t;
begin
  mpz_init_set_si(op, N);
  assert(mpz_get_si(op) = N);
  mpz_clear(op)
end;

procedure TTestGmpBinding.mpz_get_str_test;
const N = -1000000;
var
  op: mpz_t;
  p: pchar;
  s0, s1: string;
begin
  mpz_init_set_si(op, N);
  s0 := inttostr(N);
  p :=mpz_get_str(nil, BASE10, op);
  assert(s0 = p);
  freemem(p);
  setlength(s1, length(s0));
  assert(pointer(mpz_get_str(pchar(s1), BASE10, op)) = pointer(s1));
  assert(s0 = s1);
  mpz_clear(op)
end;

procedure TTestGmpBinding.mpz_get_ui_test;
const N = 1000000;
var op: mpz_t;
begin
  mpz_init_set_ui(op, N);
  assert(mpz_get_ui(op) = N);
  mpz_clear(op)
end;

procedure TTestGmpBinding.mpz_add_test;
const
  OP_1 = -1000;
  OP_2 = 1000000;
var rop, op1, op2: mpz_t;
begin
  mpz_init(rop);
  mpz_init_set_si(op1, OP_1);
  mpz_init_set_si(op2, OP_2);
  mpz_add(rop, op1, op2);
  assert(mpz_get_si(rop) = OP_1 + OP_2);
  mpz_clear(rop);
  mpz_clear(op1);
  mpz_clear(op2);
end;

procedure TTestGmpBinding.mpz_add_ui_test;
const
  OP_1 = -1000;
  OP_2 = 1000000;
var rop, op1: mpz_t;
begin
  mpz_init(rop);
  mpz_init_set_si(op1, OP_1);
  mpz_add_ui(rop, op1, OP_2);
  assert(mpz_get_si(rop) = OP_1 + OP_2);
  mpz_clear(rop);
  mpz_clear(op1);
end;

procedure TTestGmpBinding.mpz_sub_test;
const
  OP_1 = -1000;
  OP_2 = 1000000;
var rop, op1, op2: mpz_t;
begin
  mpz_init(rop);
  mpz_init_set_si(op1, OP_1);
  mpz_init_set_si(op2, OP_2);
  mpz_sub(rop, op1, op2);
  assert(mpz_get_si(rop) = OP_1 - OP_2);
  mpz_clear(rop);
  mpz_clear(op1);
  mpz_clear(op2);
end;

procedure TTestGmpBinding.mpz_sub_ui_test;
const
  OP_1 = -1000;
  OP_2 = 1000000;
var rop, op1: mpz_t;
begin
  mpz_init(rop);
  mpz_init_set_si(op1, OP_1);
  mpz_sub_ui(rop, op1, OP_2);
  assert(mpz_get_si(rop) = OP_1 - OP_2);
  mpz_clear(rop);
  mpz_clear(op1);
end;

procedure TTestGmpBinding.mpz_ui_sub_test;
const
  OP_1 = 1000;
  OP_2 = 1000000;
var rop, op2: mpz_t;
begin
  mpz_init(rop);
  mpz_init_set_si(op2, OP_2);
  mpz_ui_sub(rop, OP_1, op2);
  assert(mpz_get_si(rop) = OP_1 - OP_2);
  mpz_clear(rop);
  mpz_clear(op2);
end;

procedure TTestGmpBinding.mpz_mul_test;
const
  OP_1 = -10;
  OP_2 = 1000;
var rop, op1, op2: mpz_t;
begin
  mpz_init(rop);
  mpz_init_set_si(op1, OP_1);
  mpz_init_set_si(op2, OP_2);
  mpz_mul(rop, op1, op2);
  assert(mpz_get_si(rop) = OP_1 * OP_2);
  mpz_clear(rop);
  mpz_clear(op1);
  mpz_clear(op2);
end;

procedure TTestGmpBinding.mpz_mul_si_test;
const
  OP_1 = 10;
  OP_2 = -1000;
var rop, op1: mpz_t;
begin
  mpz_init(rop);
  mpz_init_set_si(op1, OP_1);
  mpz_mul_si(rop, op1, OP_2);
  assert(mpz_get_si(rop) = OP_1 * OP_2);
  mpz_clear(rop);
  mpz_clear(op1);
end;

procedure TTestGmpBinding.mpz_mul_ui_test;
const
  OP_1 = -10;
  OP_2 = 1000;
var rop, op1: mpz_t;
begin
  mpz_init(rop);
  mpz_init_set_si(op1, OP_1);
  mpz_mul_ui(rop, op1, OP_2);
  assert(mpz_get_si(rop) = OP_1 * OP_2);
  mpz_clear(rop);
  mpz_clear(op1);
end;

procedure TTestGmpBinding.mpz_addmul_test;
const
  ROP_ = 10;
  OP_1 = -100;
  OP_2 = 1000;
var rop, op1, op2: mpz_t;
begin
  mpz_init_set_si(rop, ROP_);
  mpz_init_set_si(op1, OP_1);
  mpz_init_set_si(op2, OP_2);
  mpz_addmul(rop, op1, op2);
  assert(mpz_get_si(rop) = ROP_ + OP_1 * OP_2);
  mpz_clear(rop);
  mpz_clear(op1);
  mpz_clear(op2);
end;

procedure TTestGmpBinding.mpz_addmul_ui_test;
const
  ROP_ = 10;
  OP_1 = -100;
  OP_2 = 1000;
var rop, op1: mpz_t;
begin
  mpz_init_set_si(rop, ROP_);
  mpz_init_set_si(op1, OP_1);
  mpz_addmul_ui(rop, op1, OP_2);
  assert(mpz_get_si(rop) = ROP_ + OP_1 * OP_2);
  mpz_clear(rop);
  mpz_clear(op1);
end;

procedure TTestGmpBinding.mpz_submul_test;
const
  ROP_ = 10;
  OP_1 = -100;
  OP_2 = 1000;
var rop, op1, op2: mpz_t;
begin
  mpz_init_set_si(rop, ROP_);
  mpz_init_set_si(op1, OP_1);
  mpz_init_set_si(op2, OP_2);
  mpz_submul(rop, op1, op2);
  assert(mpz_get_si(rop) = ROP_ - OP_1 * OP_2);
  mpz_clear(rop);
  mpz_clear(op1);
  mpz_clear(op2);
end;

procedure TTestGmpBinding.mpz_submul_ui_test;
const
  ROP_ = 10;
  OP_1 = -100;
  OP_2 = 1000;
var rop, op1: mpz_t;
begin
  mpz_init_set_si(rop, ROP_);
  mpz_init_set_si(op1, OP_1);
  mpz_submul_ui(rop, op1, OP_2);
  assert(mpz_get_si(rop) = ROP_ - OP_1 * OP_2);
  mpz_clear(rop);
  mpz_clear(op1);
end;

procedure TTestGmpBinding.mpz_mul_2exp_test;
const
  OP_1 = 10;
  OP_2 = 10;
var rop, op1: mpz_t;
begin
  mpz_init(rop);
  mpz_init_set_si(op1, OP_1);
  mpz_mul_2exp(rop, op1, OP_2);
  assert(mpz_get_si(rop) = OP_1 * (1 shl OP_2));
  mpz_clear(rop);
  mpz_clear(op1);
end;

procedure TTestGmpBinding.mpz_neg_test;
const OP_ = 1000;
var rop, op: mpz_t;
begin
  mpz_init(rop);
  mpz_init_set_si(op, OP_);
  mpz_neg(rop, op);
  assert(mpz_get_si(rop) = -OP_);
  mpz_clear(rop);
  mpz_clear(op);
end;

procedure TTestGmpBinding.mpz_abs_test;
const OP_ = -1000;
var rop, op: mpz_t;
begin
  mpz_init(rop);
  mpz_init_set_si(op, OP_);
  mpz_abs(rop, op);
  assert(mpz_get_si(rop) = abs(OP_));
  mpz_clear(rop);
  mpz_clear(op);
end;

procedure TTestGmpBinding.mpz_cdiv_q_test;
const
  N_ = -17;
  D_ = 4;
var q, n, d: mpz_t;
begin
  mpz_init(q);
  mpz_init_set_si(n, N_);
  mpz_init_set_si(d, D_);
  mpz_cdiv_q(q, n, d);
  assert(mpz_get_si(q) = ceil(N_ / D_));
  mpz_clear(q);
  mpz_clear(n);
  mpz_clear(d);
end;

procedure TTestGmpBinding.mpz_fdiv_q_test;
const
  N_ = -17;
  D_ = 4;
var q, n, d: mpz_t;
begin
  mpz_init(q);
  mpz_init_set_si(n, N_);
  mpz_init_set_si(d, D_);
  mpz_fdiv_q(q, n, d);
  assert(mpz_get_si(q) = floor(N_ / D_));
  mpz_clear(q);
  mpz_clear(n);
  mpz_clear(d);
end;

procedure TTestGmpBinding.mpz_tdiv_q_test;
const
  N_ = -17;
  D_ = 4;
var q, n, d: mpz_t;
begin
  mpz_init(q);
  mpz_init_set_si(n, N_);
  mpz_init_set_si(d, D_);
  mpz_tdiv_q(q, n, d);
  assert(mpz_get_si(q) = trunc(N_ / D_));
  mpz_clear(q);
  mpz_clear(n);
  mpz_clear(d);
end;

procedure TTestGmpBinding.mpz_cdiv_q_2exp_test;
const
  N_ = -17;
  B_ = 2;
  D_ = 1 shl B_;
var q, n: mpz_t;
begin
  mpz_init(q);
  mpz_init_set_si(n, N_);
  mpz_cdiv_q_2exp(q, n, B_);
  assert(mpz_get_si(q) = ceil(N_ / D_));
  mpz_clear(q);
  mpz_clear(n);
end;

procedure TTestGmpBinding.mpz_fdiv_q_2exp_test;
const
  N_ = -17;
  B_ = 2;
  D_ = 1 shl B_;
var q, n: mpz_t;
begin
  mpz_init(q);
  mpz_init_set_si(n, N_);
  mpz_fdiv_q_2exp(q, n, B_);
  assert(mpz_get_si(q) = floor(N_ / D_));
  mpz_clear(q);
  mpz_clear(n);
end;

procedure TTestGmpBinding.mpz_tdiv_q_2exp_test;
const
  N_ = -17;
  B_ = 2;
  D_ = 1 shl B_;
var q, n: mpz_t;
begin
  mpz_init(q);
  mpz_init_set_si(n, N_);
  mpz_tdiv_q_2exp(q, n, B_);
  assert(mpz_get_si(q) = trunc(N_ / D_));
  mpz_clear(q);
  mpz_clear(n);
end;

procedure TTestGmpBinding.mpz_cdiv_q_ui_test;
const
  N_ = -17;
  D_ = 4;
var
  q, n: mpz_t;
  ur: valuint;
begin
  mpz_init(q);
  mpz_init_set_si(n, N_);
  ur :=mpz_cdiv_q_ui(q, n, D_);
  assert(mpz_get_si(q) = ceil(N_ / D_));
  assert(ur - abs(N_ -mpz_get_si(q) * D_) = 0);
  mpz_clear(q);
  mpz_clear(n);
end;

procedure TTestGmpBinding.mpz_fdiv_q_ui_test;
const
  N_ = -17;
  D_ = 4;
var
  q, n: mpz_t;
  ur: valuint;
begin
  mpz_init(q);
  mpz_init_set_si(n, N_);
  ur :=mpz_fdiv_q_ui(q, n, D_);
  assert(mpz_get_si(q) = floor(N_ / D_));
  assert(ur - abs(N_ -mpz_get_si(q) * D_) = 0);
  mpz_clear(q);
  mpz_clear(n);
end;

procedure TTestGmpBinding.mpz_tdiv_q_ui_test;
const
  N_ = -17;
  D_ = 4;
var
  q, n: mpz_t;
  ur: valuint;
begin
  mpz_init(q);
  mpz_init_set_si(n, N_);
  ur :=mpz_tdiv_q_ui(q, n, D_);
  assert(mpz_get_si(q) = trunc(N_ / D_));
  assert(ur - abs(N_ -mpz_get_si(q) * D_) = 0);
  mpz_clear(q);
  mpz_clear(n);
end;

procedure TTestGmpBinding.mpz_cdiv_qr_test;
const
  N_ = -17;
  D_ = 4;
var q, r, n, d: mpz_t;
begin
  mpz_init(q);
  mpz_init(r);
  mpz_init_set_si(n, N_);
  mpz_init_set_si(d, D_);
  mpz_cdiv_qr(q, r, n, d);
  assert(mpz_get_si(q) = ceil(N_ / D_));
  assert(mpz_get_si(q) * D_ + mpz_get_si(r) = N_);
  mpz_clear(q);
  mpz_clear(r);
  mpz_clear(n);
  mpz_clear(d);
end;

procedure TTestGmpBinding.mpz_fdiv_qr_test;
const
  N_ = -17;
  D_ = 4;
var q, r, n, d: mpz_t;
begin
  mpz_init(q);
  mpz_init(r);
  mpz_init_set_si(n, N_);
  mpz_init_set_si(d, D_);
  mpz_fdiv_qr(q, r, n, d);
  assert(mpz_get_si(q) = floor(N_ / D_));
  assert(mpz_get_si(q) * D_ + mpz_get_si(r) = N_);
  mpz_clear(q);
  mpz_clear(r);
  mpz_clear(n);
  mpz_clear(d);
end;

procedure TTestGmpBinding.mpz_tdiv_qr_test;
const
  N_ = -17;
  D_ = 4;
var q, r, n, d: mpz_t;
begin
  mpz_init(q);
  mpz_init(r);
  mpz_init_set_si(n, N_);
  mpz_init_set_si(d, D_);
  mpz_tdiv_qr(q, r, n, d);
  assert(mpz_get_si(q) = trunc(N_ / D_));
  assert(mpz_get_si(q) * D_ + mpz_get_si(r) = N_);
  mpz_clear(q);
  mpz_clear(r);
  mpz_clear(n);
  mpz_clear(d);
end;

procedure TTestGmpBinding.mpz_cdiv_qr_ui_test;
const
  N_ = -17;
  D_ = 4;
var
  q, r, n: mpz_t;
  ur: valuint;
begin
  mpz_init(q);
  mpz_init(r);
  mpz_init_set_si(n, N_);
  ur :=mpz_cdiv_qr_ui(q, r, n, D_);
  assert(mpz_get_si(q) = ceil(N_ / D_));
  assert(mpz_get_si(q) * D_ + mpz_get_si(r) = N_);
  assert(ur - abs(mpz_get_si(r)) = 0);
  mpz_clear(q);
  mpz_clear(r);
  mpz_clear(n);
end;

procedure TTestGmpBinding.mpz_fdiv_qr_ui_test;
const
  N_ = -17;
  D_ = 4;
var
  q, r, n: mpz_t;
  ur: valuint;
begin
  mpz_init(q);
  mpz_init(r);
  mpz_init_set_si(n, N_);
  ur :=mpz_fdiv_qr_ui(q, r, n, D_);
  assert(mpz_get_si(q) = floor(N_ / D_));
  assert(mpz_get_si(q) * D_ + mpz_get_si(r) = N_);
  assert(ur - abs(mpz_get_si(r)) = 0);
  mpz_clear(q);
  mpz_clear(r);
  mpz_clear(n);
end;

procedure TTestGmpBinding.mpz_tdiv_qr_ui_test;
const
  N_ = -17;
  D_ = 4;
var
  q, r, n: mpz_t;
  ur: valuint;
begin
  mpz_init(q);
  mpz_init(r);
  mpz_init_set_si(n, N_);
  ur :=mpz_tdiv_qr_ui(q, r, n, D_);
  assert(mpz_get_si(q) = trunc(N_ / D_));
  assert(mpz_get_si(q) * D_ + mpz_get_si(r) = N_);
  assert(ur - abs(mpz_get_si(r)) = 0);
  mpz_clear(q);
  mpz_clear(r);
  mpz_clear(n);
end;

procedure TTestGmpBinding.mpz_cdiv_r_test;
const
  N_ = -17;
  D_ = 4;
var r, n, d: mpz_t;
begin
  mpz_init(r);
  mpz_init_set_si(n, N_);
  mpz_init_set_si(d, D_);
  mpz_cdiv_r(r, n, d);
  assert(ceil(N_ / D_) * D_ + mpz_get_si(r) = N_);
  mpz_clear(r);
  mpz_clear(n);
  mpz_clear(d);
end;

procedure TTestGmpBinding.mpz_fdiv_r_test;
const
  N_ = -17;
  D_ = 4;
var r, n, d: mpz_t;
begin
  mpz_init(r);
  mpz_init_set_si(n, N_);
  mpz_init_set_si(d, D_);
  mpz_fdiv_r(r, n, d);
  assert(floor(N_ / D_) * D_ + mpz_get_si(r) = N_);
  mpz_clear(r);
  mpz_clear(n);
  mpz_clear(d);
end;

procedure TTestGmpBinding.mpz_tdiv_r_test;
const
  N_ = -17;
  D_ = 4;
var r, n, d: mpz_t;
begin
  mpz_init(r);
  mpz_init_set_si(n, N_);
  mpz_init_set_si(d, D_);
  mpz_tdiv_r(r, n, d);
  assert(trunc(N_ / D_) * D_ + mpz_get_si(r) = N_);
  mpz_clear(r);
  mpz_clear(n);
  mpz_clear(d);
end;

procedure TTestGmpBinding.mpz_cdiv_r_2exp_test;
const
  N_ = -17;
  B_ = 2;
  D_ = 1 shl B_;
var r, n: mpz_t;
begin
  mpz_init(r);
  mpz_init_set_si(n, N_);
  mpz_cdiv_r_2exp(r, n, B_);
  assert(ceil(N_ / D_) * D_ + mpz_get_si(r) = N_);
  mpz_clear(r);
  mpz_clear(n);
end;

procedure TTestGmpBinding.mpz_fdiv_r_2exp_test;
const
  N_ = -17;
  B_ = 2;
  D_ = 1 shl B_;
var r, n: mpz_t;
begin
  mpz_init(r);
  mpz_init_set_si(n, N_);
  mpz_fdiv_r_2exp(r, n, B_);
  assert(floor(N_ / D_) * D_ + mpz_get_si(r) = N_);
  mpz_clear(r);
  mpz_clear(n);
end;

procedure TTestGmpBinding.mpz_tdiv_r_2exp_test;
const
  N_ = -17;
  B_ = 2;
  D_ = 1 shl B_;
var r, n: mpz_t;
begin
  mpz_init(r);
  mpz_init_set_si(n, N_);
  mpz_tdiv_r_2exp(r, n, B_);
  assert(trunc(N_ / D_) * D_ + mpz_get_si(r) = N_);
  mpz_clear(r);
  mpz_clear(n);
end;

procedure TTestGmpBinding.mpz_cdiv_r_ui_test;
const
  N_ = -17;
  D_ = 4;
var
  r, n: mpz_t;
  ur: valuint;
begin
  mpz_init(r);
  mpz_init_set_si(n, N_);
  ur :=mpz_cdiv_r_ui(r, n, D_);
  assert(ceil(N_ / D_) * D_ + mpz_get_si(r) = N_);
  assert(ur - abs(mpz_get_si(r)) = 0);
  mpz_clear(r);
  mpz_clear(n);
end;

procedure TTestGmpBinding.mpz_fdiv_r_ui_test;
const
  N_ = -17;
  D_ = 4;
var
  r, n: mpz_t;
  ur: valuint;
begin
  mpz_init(r);
  mpz_init_set_si(n, N_);
  ur :=mpz_fdiv_r_ui(r, n, D_);
  assert(floor(N_ / D_) * D_ + mpz_get_si(r) = N_);
  assert(ur - abs(mpz_get_si(r)) = 0);
  mpz_clear(r);
  mpz_clear(n);
end;

procedure TTestGmpBinding.mpz_tdiv_r_ui_test;
const
  N_ = -17;
  D_ = 4;
var
  r, n: mpz_t;
  ur: valuint;
begin
  mpz_init(r);
  mpz_init_set_si(n, N_);
  ur :=mpz_tdiv_r_ui(r, n, D_);
  assert(trunc(N_ / D_) * D_ + mpz_get_si(r) = N_);
  assert(ur - abs(mpz_get_si(r)) = 0);
  mpz_clear(r);
  mpz_clear(n);
end;

procedure TTestGmpBinding.mpz_cdiv_ui_test;
const
  N_ = -17;
  D_ = 4;
var n: mpz_t;
begin
  mpz_init_set_si(n, N_);
  assert(mpz_cdiv_ui(n, D_) - abs(N_ - ceil(N_ / D_) * D_) = 0);
  mpz_clear(n);
end;

procedure TTestGmpBinding.mpz_fdiv_ui_test;
const
  N_ = -17;
  D_ = 4;
var n: mpz_t;
begin
  mpz_init_set_si(n, N_);
  assert(mpz_fdiv_ui(n, D_) - abs(N_ - floor(N_ / D_) * D_) = 0);
  mpz_clear(n);
end;

procedure TTestGmpBinding.mpz_tdiv_ui_test;
const
  N_ = -17;
  D_ = 4;
var n: mpz_t;
begin
  mpz_init_set_si(n, N_);
  assert(mpz_tdiv_ui(n, D_) = abs(N_ - trunc(N_ / D_) * D_));
  mpz_clear(n);
end;

procedure TTestGmpBinding.mpz_mod_test;
const
  N_ = 17;
  D_ = -4;
var r, n, d: mpz_t;
begin
  mpz_init(r);
  mpz_init_set_si(n, N_);
  mpz_init_set_si(d, D_);
  mpz_mod(r, n, d);
  assert(mpz_get_si(r) = N_ mod abs(D_));
  mpz_clear(r);
  mpz_clear(n);
  mpz_clear(d);
end;

procedure TTestGmpBinding.mpz_divexact_test;
const
  N_ = -16;
  D_ = 4;
var q, n, d: mpz_t;
begin
  mpz_init(q);
  mpz_init_set_si(n, N_);
  mpz_init_set_si(d, D_);
  mpz_divexact(q, n, d);
  assert(mpz_get_si(q) * D_ = N_);
  mpz_clear(q);
  mpz_clear(n);
  mpz_clear(d);
end;

procedure TTestGmpBinding.mpz_divexact_ui_test;
const
  N_ = -16;
  D_ = 4;
var q, n: mpz_t;
begin
  mpz_init(q);
  mpz_init_set_si(n, N_);
  mpz_divexact_ui(q, n, D_);
  assert(mpz_get_si(q) * D_ = N_);
  mpz_clear(q);
  mpz_clear(n);
end;

procedure TTestGmpBinding.mpz_divisible_p_test;
const
  N_ = -16;
  D_ = 4;
var n, d: mpz_t;
begin
  mpz_init_set_si(n, N_);
  mpz_init_set_si(d, D_);
  assert(mpz_divisible_p(n, d) <> 0);
  mpz_set_si(n,mpz_get_si(n) + 1);
  assert(mpz_divisible_p(n, d) = 0);
  mpz_clear(n);
  mpz_clear(d);
end;

procedure TTestGmpBinding.mpz_divisible_ui_p_test;
const
  N_ = -16;
  D_ = 4;
var n: mpz_t;
begin
  mpz_init_set_si(n, N_);
  assert(mpz_divisible_ui_p(n, D_) <> 0);
  mpz_set_si(n,mpz_get_si(n) + 1);
  assert(mpz_divisible_ui_p(n, D_) = 0);
  mpz_clear(n);
end;

procedure TTestGmpBinding.mpz_divisible_2exp_p_test;
const
  N_ = -16;
  B_ = 2;
var n: mpz_t;
begin
  mpz_init_set_si(n, N_);
  assert(mpz_divisible_2exp_p(n, B_) <> 0);
  mpz_set_si(n,mpz_get_si(n) + 1);
  assert(mpz_divisible_ui_p(n, B_) = 0);
  mpz_clear(n);
end;

procedure TTestGmpBinding.mpz_congruent_p_test;
const
  N_ = 23;
  C_ = 6;
  D_ = 17;
var n, c, d: mpz_t;
begin
  mpz_init_set_si(n, N_);
  mpz_init_set_si(c, C_);
  mpz_init_set_si(d, D_);
  assert(mpz_congruent_p(n, c, d) <> 0);
  mpz_set_si(n,mpz_get_si(n) + 1);
  assert(mpz_congruent_p(n, c, d) = 0);
  mpz_clear(n);
  mpz_clear(c);
  mpz_clear(d);
end;

procedure TTestGmpBinding.mpz_congruent_2exp_p_test;
const
  N_ = 23;
  C_ = 7;
  B_ = 4;
var n, c: mpz_t;
begin
  mpz_init_set_si(n, N_);
  mpz_init_set_si(c, C_);
  assert(mpz_congruent_2exp_p(n, c, B_) <> 0);
  mpz_set_si(n,mpz_get_si(n) + 1);
  assert(mpz_congruent_2exp_p(n, c, B_) = 0);
  mpz_clear(n);
  mpz_clear(c);
end;

procedure TTestGmpBinding.mpz_congruent_ui_p_test;
const
  N_ = 23;
  C_ = 6;
  D_ = 17;
var n: mpz_t;
begin
  mpz_init_set_si(n, N_);
  assert(mpz_congruent_ui_p(n, C_, D_) <> 0);
  mpz_set_si(n,mpz_get_si(n) + 1);
  assert(mpz_congruent_ui_p(n, C_, D_) = 0);
  mpz_clear(n);
end;

procedure TTestGmpBinding.mpz_powm_test;
const
  N_EXP = 3;
  N_MOD = 16;
  ROP_ = 8;
var rop, base, exp, mod_: mpz_t;
begin
  mpz_init(rop);
  mpz_init_set_si(base, BASE10);
  mpz_init_set_si(exp, N_EXP);
  mpz_init_set_si(mod_, N_MOD);
  mpz_powm(rop, base, exp, mod_);
  assert(mpz_get_si(rop) = ROP_);
  mpz_clear(rop);
  mpz_clear(base);
  mpz_clear(exp);
  mpz_clear(mod_);
end;

procedure TTestGmpBinding.mpz_powm_ui_test;
const
  N_EXP = 3;
  N_MOD = 16;
  ROP_ = 8;
var rop, base, mod_: mpz_t;
begin
  mpz_init(rop);
  mpz_init_set_si(base, BASE10);
  mpz_init_set_si(mod_, N_MOD);
  mpz_powm_ui(rop, base, N_EXP, mod_);
  assert(mpz_get_si(rop) = ROP_);
  mpz_clear(rop);
  mpz_clear(base);
  mpz_clear(mod_);
end;

procedure TTestGmpBinding.mpz_pow_ui_test;
const
  BASE_ = 10;
  EXP = 3;
var rop, base: mpz_t;
begin
  mpz_init(rop);
  mpz_init_set_si(base, BASE_);
  mpz_pow_ui(rop, base, EXP);
  assert(mpz_get_si(rop) = BASE_ ** EXP);
  mpz_clear(rop);
  mpz_clear(base);
end;

procedure TTestGmpBinding.mpz_ui_pow_ui_test;
const
  BASE_ = 10;
  EXP = 3;
var rop: mpz_t;
begin
  mpz_init(rop);
  mpz_ui_pow_ui(rop, BASE_, EXP);
  assert(mpz_get_si(rop) = BASE_ ** EXP);
  mpz_clear(rop);
end;

procedure TTestGmpBinding.mpz_root_test;
const
  ROOT = 5;
  N_ = 3;
var rop, op: mpz_t;
begin
  mpz_init(rop);
  mpz_init_set_si(op, ROOT ** N_);
  assert(mpz_root(rop, op, N_) <> 0);
  assert(mpz_get_si(rop) = ROOT);
  mpz_set_si(op, ROOT ** N_ + 1);
  assert(mpz_root(rop, op, N_) = 0);
  assert(mpz_get_si(rop) = ROOT);
  mpz_clear(rop);
  mpz_clear(op);
end;

procedure TTestGmpBinding.mpz_rootrem_test;
const
  ROOT_ = 5;
  N_ = 3;
  REM_ = 1;
var root, rem, u: mpz_t;
begin
  assert(REM_ < ROOT_);
  mpz_init(root);
  mpz_init(rem);
  mpz_init_set_si(u, ROOT_ ** N_);
  mpz_rootrem(root, rem, u, N_);
  assert(mpz_get_si(root) = ROOT_);
  assert(mpz_get_si(rem) = 0);
  mpz_set_si(u, ROOT_ ** N_ + REM_);
  mpz_rootrem(root, rem, u, N_);
  assert(mpz_get_si(root) = ROOT_);
  assert(mpz_get_si(rem) = REM_);
  mpz_clear(root);
  mpz_clear(rem);
  mpz_clear(u);
end;

procedure TTestGmpBinding.mpz_sqrt_test;
const ROOT = 5;
var rop, op: mpz_t;
begin
  mpz_init(rop);
  mpz_init_set_si(op, ROOT ** 2);
  mpz_sqrt(rop, op);
  assert(mpz_get_si(rop) = ROOT);
  mpz_clear(rop);
  mpz_clear(op);
end;

procedure TTestGmpBinding.mpz_sqrtrem_test;
const
  ROOT = 5;
  REM = 1;
var rop1, rop2, op: mpz_t;
begin
  mpz_init(rop1);
  mpz_init(rop2);
  mpz_init_set_si(op, ROOT ** 2 + REM);
  mpz_sqrtrem(rop1, rop2, op);
  assert(mpz_get_si(rop1) = ROOT);
  assert(mpz_get_si(rop2) = REM);
  mpz_clear(rop1);
  mpz_clear(rop2);
  mpz_clear(op);
end;

procedure TTestGmpBinding.mpz_perfect_power_p_test;
const
  ROOT = 3;
  EXP = 3;
var op: mpz_t;
begin
  mpz_init_set_si(op, ROOT ** EXP);
  assert(mpz_perfect_power_p(op) <> 0);
  mpz_set_si(op, ROOT ** EXP + 1);
  assert(mpz_perfect_power_p(op) = 0);
  mpz_clear(op);
end;

procedure TTestGmpBinding.mpz_perfect_square_p_test;
const ROOT = 3;
var op: mpz_t;
begin
  mpz_init_set_si(op, ROOT ** 2);
  assert(mpz_perfect_square_p(op) <> 0);
  mpz_set_si(op, ROOT ** 2 or 2);
  assert(mpz_perfect_square_p(op) = 0);
  mpz_clear(op);
end;

procedure TTestGmpBinding.mpz_probab_prime_p_test;
const
  N_ = 127;
  REPS = 5;
var n: mpz_t;
begin
  mpz_init_set_si(n, N_);
  assert(mpz_probab_prime_p(n, REPS) = 2);
  mpz_set_si(n, N_ + 1);
  assert(mpz_probab_prime_p(n, REPS) = 0);
  mpz_clear(n);
end;

procedure TTestGmpBinding.mpz_nextprime_test;
const
  PRIME3 = 5;
  PRIME4 = 7;
var rop, op: mpz_t;
begin
  mpz_init(rop);
  mpz_init_set_si(op, PRIME3);
  mpz_nextprime(rop, op);
  assert(mpz_get_si(rop) = PRIME4);
  mpz_clear(rop);
  mpz_clear(op);
end;

procedure TTestGmpBinding.mpz_gcd_test;
const
  OP_1 = 42;
  OP_2 = 56;
  ROP_ = 14;
var rop, op1, op2: mpz_t;
begin
  mpz_init(rop);
  mpz_init_set_si(op1, OP_1);
  mpz_init_set_si(op2, OP_2);
  mpz_gcd(rop, op1, op2);
  assert(mpz_get_si(rop) = ROP_);
  mpz_clear(rop);
  mpz_clear(op1);
  mpz_clear(op2);
end;

procedure TTestGmpBinding.mpz_gcd_ui_test;
const
  OP_1 = 42;
  OP_2 = 56;
  ROP_ = 14;
var rop, op1: mpz_t;
begin
  mpz_init(rop);
  mpz_init_set_si(op1, OP_1);
  assert(mpz_gcd_ui(rop, op1, OP_2) = ROP_);
  assert(mpz_get_si(rop) = ROP_);
  mpz_clear(rop);
  mpz_clear(op1);
end;

procedure TTestGmpBinding.mpz_gcdext_test;
const
  A_ = 42;
  B_ = 56;
  G_ = 14;
var g, s, t, a, b: mpz_t;
begin
  mpz_init(g);
  mpz_init(s);
  mpz_init(t);
  mpz_init_set_si(a, A_);
  mpz_init_set_si(b, B_);
  mpz_gcdext(g, s, t, a, b);
  assert(mpz_get_si(g) = G_);
  assert(A_ *mpz_get_si(s) + B_ *mpz_get_si(t) = G_);
  mpz_clear(g);
  mpz_clear(s);
  mpz_clear(t);
  mpz_clear(a);
  mpz_clear(b);
end;

procedure TTestGmpBinding.mpz_lcm_test;
const
  OP_1 = 21;
  OP_2 = 6;
  ROP_ = 42;
var rop, op1, op2: mpz_t;
begin
  mpz_init(rop);
  mpz_init_set_si(op1, OP_1);
  mpz_init_set_si(op2, OP_2);
  mpz_lcm(rop, op1, op2);
  assert(mpz_get_si(rop) = ROP_);
  mpz_clear(rop);
  mpz_clear(op1);
  mpz_clear(op2);
end;

procedure TTestGmpBinding.mpz_lcm_ui_test;
const
  OP_1 = 21;
  OP_2 = 6;
  ROP_ = 42;
var rop, op1: mpz_t;
begin
  mpz_init(rop);
  mpz_init_set_si(op1, OP_1);
  mpz_lcm_ui(rop, op1, OP_2);
  assert(mpz_get_si(rop) = ROP_);
  mpz_clear(rop);
  mpz_clear(op1);
end;

procedure TTestGmpBinding.mpz_invert_test;
const
  OP_1 = 256;
  OP_2 = 337;
  ROP_ = 104;
var rop, op1, op2: mpz_t;
begin
  mpz_init(rop);
  mpz_init_set_si(op1, OP_1);
  mpz_init_set_si(op2, OP_2);
  assert(mpz_invert(rop, op1, op2) <> 0);
  assert(mpz_get_si(rop) = ROP_);
  mpz_clear(rop);
  mpz_clear(op1);
  mpz_clear(op2);
end;

procedure TTestGmpBinding.mpz_jacobi_test;
const
  B0 = 11;
  A0 = 13 * B0;
  AM1 = 1001;
  BM1 = 9907;
  A1 = 4;
  B1 = 7;
var a, b: mpz_t;
begin
  mpz_init_set_si(a, A0);
  mpz_init_set_si(b, B0);
  assert(mpz_jacobi(a, b) = 0);
  mpz_set_si(a, AM1);
  mpz_set_si(b, BM1);
  assert(mpz_jacobi(a, b) = -1);
  mpz_set_si(a, A1);
  mpz_set_si(b, B1);
  assert(mpz_jacobi(a, b) = 1);
  mpz_clear(a);
  mpz_clear(b);
end;

procedure TTestGmpBinding.mpz_kronecker_si_test;
const
  A_ = 8;
  B0 = 6;
  BM1 = 5;
  B1 = 7;
var a: mpz_t;
begin
  mpz_init_set_si(a, A_);
  assert(mpz_kronecker_si(a, B1) = 1);
  assert(mpz_kronecker_si(a, B0) = 0);
  assert(mpz_kronecker_si(a, BM1) = -1);
  mpz_clear(a);
end;

procedure TTestGmpBinding.mpz_kronecker_ui_test;
const
  A_ = 8;
  B0 = 6;
  BM1 = 5;
  B1 = 7;
var a: mpz_t;
begin
  mpz_init_set_si(a, A_);
  assert(mpz_kronecker_ui(a, B1) = 1);
  assert(mpz_kronecker_ui(a, B0) = 0);
  assert(mpz_kronecker_ui(a, BM1) = -1);
  mpz_clear(a);
end;

procedure TTestGmpBinding.mpz_si_kronecker_test;
const
  A_ = 8;
  B0 = 6;
  BM1 = 5;
  B1 = 7;
var b: mpz_t;
begin
  mpz_init_set_si(b, B1);
  assert(mpz_si_kronecker(A_, b) = 1);
  mpz_set_si(b, B0);
  assert(mpz_si_kronecker(A_, b) = 0);
  mpz_set_si(b, BM1);
  assert(mpz_si_kronecker(A_, b) = -1);
  mpz_clear(b);
end;

procedure TTestGmpBinding.mpz_ui_kronecker_test;
const
  A_ = 8;
  B0 = 6;
  BM1 = 5;
  B1 = 7;
var b: mpz_t;
begin
  mpz_init_set_si(b, B1);
  assert(mpz_ui_kronecker(A_, b) = 1);
  mpz_set_si(b, B0);
  assert(mpz_ui_kronecker(A_, b) = 0);
  mpz_set_si(b, BM1);
  assert(mpz_ui_kronecker(A_, b) = -1);
  mpz_clear(b);
end;

procedure TTestGmpBinding.mpz_remove_test;
const
  F_ = 5;
  OP_ = 3 * F_ * 7;
  ROP_ = OP_ div F_;
var rop, op, f: mpz_t;
begin
  mpz_init(rop);
  mpz_init_set_si(op, OP_);
  mpz_init_set_si(f, F_);
  assert(mpz_remove(rop, op, f) = 1);
  assert(mpz_get_si(rop) = ROP_);
  mpz_clear(rop);
  mpz_clear(op);
  mpz_clear(f);
end;

procedure TTestGmpBinding.mpz_fac_ui_test;
const
  OP = 4;
  ROP_ = 2 * 3 * 4;
var rop: mpz_t;
begin
  mpz_init(rop);
  mpz_fac_ui(rop, OP);
  assert(mpz_get_si(rop) = ROP_);
  mpz_clear(rop);
end;

procedure TTestGmpBinding.mpz_bin_ui_test;
const
  N_ = 7;
  K = 3;
  ROP_ = 35;
var rop, n: mpz_t;
begin
  mpz_init(rop);
  mpz_init_set_si(n, N_);
  mpz_bin_ui(rop, n, K);
  assert(mpz_get_si(rop) = ROP_);
  mpz_clear(rop);
  mpz_clear(n);
end;

procedure TTestGmpBinding.mpz_bin_uiui_test;
const
  N = 7;
  K = 3;
  ROP_ = 35;
var rop: mpz_t;
begin
  mpz_init(rop);
  mpz_bin_uiui(rop, N, K);
  assert(mpz_get_si(rop) = ROP_);
  mpz_clear(rop);
end;

procedure TTestGmpBinding.mpz_fib_ui_test;
const
  N = 10;
  FN_ = 55;
var fn: mpz_t;
begin
  mpz_init(fn);
  mpz_fib_ui(fn, N);
  assert(mpz_get_si(fn) = FN_);
  mpz_clear(fn);
end;

procedure TTestGmpBinding.mpz_fib2_ui_test;
const
  N = 10;
  FN_ = 55;
  FNSUB1_ = 34;
var fn, fnsub1: mpz_t;
begin
  mpz_init(fn);
  mpz_init(fnsub1);
  mpz_fib2_ui(fn, fnsub1, N);
  assert(mpz_get_si(fn) = FN_);
  assert(mpz_get_si(fnsub1) = FNSUB1_);
  mpz_clear(fn);
  mpz_clear(fnsub1);
end;

procedure TTestGmpBinding.mpz_lucnum_ui_test;
const
  N = 10;
  LN_ = 123;
var ln: mpz_t;
begin
  mpz_init(ln);
  mpz_lucnum_ui(ln, N);
  assert(mpz_get_si(ln) = LN_);
  mpz_clear(ln);
end;

procedure TTestGmpBinding.mpz_lucnum2_ui_test;
const
  N = 10;
  LN_ = 123;
  LNSUB1_ = 76;
var ln, lnsub1: mpz_t;
begin
  mpz_init(ln);
  mpz_init(lnsub1);
  mpz_lucnum2_ui(ln, lnsub1, N);
  assert(mpz_get_si(ln) = LN_);
  assert(mpz_get_si(lnsub1) = LNSUB1_);
  mpz_clear(ln);
  mpz_clear(lnsub1);
end;

procedure TTestGmpBinding.mpz_cmp_test;
const
  OP_1 = -10;
  OP_2 = OP_1 - 1;
var op1, op2: mpz_t;
begin
  mpz_init_set_si(op1, OP_1);
  mpz_init_set_si(op2, OP_2);
  assert(mpz_cmp(op1, op2) > 0);
  mpz_set_si(op2, OP_1);
  assert(mpz_cmp(op1, op2) = 0);
  mpz_set_si(op2, OP_1 + 1);
  assert(mpz_cmp(op1, op2) < 0);
  mpz_clear(op1);
  mpz_clear(op2);
end;

procedure TTestGmpBinding.mpz_cmp_d_test;
const
  OP_1 = -10;
var op1: mpz_t;
begin
  mpz_init_set_si(op1, OP_1);
  assert(mpz_cmp_d(op1, OP_1 - 1) > 0);
  assert(mpz_cmp_d(op1, OP_1) = 0);
  assert(mpz_cmp_d(op1, OP_1 + 1) < 0);
  mpz_clear(op1);
end;

procedure TTestGmpBinding.mpz_cmp_si_test;
const
  OP_1 = -10;
var op1: mpz_t;
begin
  mpz_init_set_si(op1, OP_1);
  assert(mpz_cmp_si(op1, OP_1 - 1) > 0);
  assert(mpz_cmp_si(op1, OP_1) = 0);
  assert(mpz_cmp_si(op1, OP_1 + 1) < 0);
  mpz_clear(op1);
end;

procedure TTestGmpBinding.mpz_cmp_ui_test;
const
  OP_1 = 10;
var op1: mpz_t;
begin
  mpz_init_set_si(op1, OP_1);
  assert(mpz_cmp_ui(op1, OP_1 - 1) > 0);
  assert(mpz_cmp_ui(op1, OP_1) = 0);
  assert(mpz_cmp_ui(op1, OP_1 + 1) < 0);
  mpz_clear(op1);
end;

procedure TTestGmpBinding.mpz_cmpabs_test;
const
  OP_1 = -10;
  OP_2 = -OP_1 - 1;
var op1, op2: mpz_t;
begin
  mpz_init_set_si(op1, OP_1);
  mpz_init_set_si(op2, -OP_2);
  assert(mpz_cmpabs(op1, op2) > 0);
  mpz_set_si(op2, -OP_1);
  assert(mpz_cmpabs(op1, op2) = 0);
  mpz_set_si(op2, -OP_1 + 1);
  assert(mpz_cmpabs(op1, op2) < 0);
  mpz_clear(op1);
  mpz_clear(op2);
end;

procedure TTestGmpBinding.mpz_cmpabs_d_test;
const OP_1 = -10;
var op1: mpz_t;
begin
  mpz_init_set_si(op1, OP_1);
  assert(mpz_cmpabs_d(op1, -OP_1 - 1) > 0);
  assert(mpz_cmpabs_d(op1, -OP_1) = 0);
  assert(mpz_cmpabs_d(op1, -OP_1 + 1) < 0);
  mpz_clear(op1);
end;

procedure TTestGmpBinding.mpz_cmpabs_ui_test;
const OP_1 = -10;
var op1: mpz_t;
begin
  mpz_init_set_si(op1, OP_1);
  assert(mpz_cmpabs_ui(op1, -OP_1 - 1) > 0);
  assert(mpz_cmpabs_ui(op1, -OP_1) = 0);
  assert(mpz_cmpabs_ui(op1, -OP_1 + 1) < 0);
  mpz_clear(op1);
end;

procedure TTestGmpBinding.mpz_and_test;
const
  OP_1 = $c;
  OP_2 = $a;
var rop, op1, op2: mpz_t;
begin
  mpz_init(rop);
  mpz_init_set_si(op1, OP_1);
  mpz_init_set_si(op2, OP_2);
  mpz_and(rop, op1, op2);
  assert(mpz_get_si(rop) = OP_1 and OP_2);
  mpz_clear(rop);
  mpz_clear(op1);
  mpz_clear(op2);
end;

procedure TTestGmpBinding.mpz_ior_test;
const
  OP_1 = $c;
  OP_2 = $a;
var rop, op1, op2: mpz_t;
begin
  mpz_init(rop);
  mpz_init_set_si(op1, OP_1);
  mpz_init_set_si(op2, OP_2);
  mpz_ior(rop, op1, op2);
  assert(mpz_get_si(rop) = OP_1 or OP_2);
  mpz_clear(rop);
  mpz_clear(op1);
  mpz_clear(op2);
end;

procedure TTestGmpBinding.mpz_xor_test;
const
  OP_1 = $c;
  OP_2 = $a;
var rop, op1, op2: mpz_t;
begin
  mpz_init(rop);
  mpz_init_set_si(op1, OP_1);
  mpz_init_set_si(op2, OP_2);
  mpz_xor(rop, op1, op2);
  assert(mpz_get_si(rop) = OP_1 xor OP_2);
  mpz_clear(rop);
  mpz_clear(op1);
  mpz_clear(op2);
end;

procedure TTestGmpBinding.mpz_com_test;
const
  OP_1 = 2;
var rop, op1: mpz_t;
begin
  mpz_init(rop);
  mpz_init_set_si(op1, OP_1);
  mpz_com(rop, op1);
  assert(mpz_get_si(rop) = not OP_1 );
  mpz_clear(rop);
  mpz_clear(op1);
end;

procedure TTestGmpBinding.mpz_popcount_test;
const
  OP_ = $55AA;
  N = 8;
var op: mpz_t;
begin
  mpz_init_set_si(op, OP_);
  assert(mpz_popcount(op) = N);
  mpz_clear(op);
end;

procedure TTestGmpBinding.mpz_hamdist_test;
const
  OP_1 = $55;
  OP_2 = $7A;
  N = 5;
var op1, op2: mpz_t;
begin
  mpz_init_set_si(op1, OP_1);
  mpz_init_set_si(op2, OP_2);
  assert(mpz_hamdist(op1, op2) = N);
  mpz_clear(op1);
  mpz_clear(op2);
end;

procedure TTestGmpBinding.mpz_scan0_test;
const
  OP_ = $F75;
  STARTING_BIT = 4;
  N = 7;
var op: mpz_t;
begin
  mpz_init_set_si(op, OP_);
  assert(mpz_scan0(op, STARTING_BIT) = N);
  mpz_clear(op);
end;

procedure TTestGmpBinding.mpz_scan1_test;
const
  OP_ = $85;
  STARTING_BIT = 4;
  N = 7;
var op: mpz_t;
begin
  mpz_init_set_si(op, OP_);
  assert(mpz_scan1(op, STARTING_BIT) = N);
  mpz_clear(op);
end;

procedure TTestGmpBinding.mpz_setbit_test;
const
  ROP_ = $F75;
  BIT_INDEX = 7;
var rop: mpz_t;
begin
  mpz_init_set_ui(rop, ROP_);
  mpz_setbit(rop, BIT_INDEX);
  assert(mpz_get_ui(rop) = ROP_ or (1 shl BIT_INDEX));
  mpz_clear(rop);
end;

procedure TTestGmpBinding.mpz_clrbit_test;
const
  ROP_ = $F75;
  BIT_INDEX = 9;
var rop: mpz_t;
begin
  mpz_init_set_ui(rop, ROP_);
  mpz_clrbit(rop, BIT_INDEX);
  assert(mpz_get_ui(rop) = ROP_ and not (1 shl BIT_INDEX));
  mpz_clear(rop);
end;

procedure TTestGmpBinding.mpz_combit_test;
const
  ROP_ = $F75;
  BIT_INDEX = 7;
var rop: mpz_t;
begin
  mpz_init_set_ui(rop, ROP_);
  mpz_combit(rop, BIT_INDEX);
  assert(mpz_get_ui(rop) = ROP_ xor (1 shl BIT_INDEX));
  mpz_clear(rop);
end;

procedure TTestGmpBinding.mpz_tstbit_test;
const
  ROP_ = $F75;
  BIT_INDEX1 = 7;
  BIT_INDEX2 = 8;
var rop: mpz_t;
begin
  mpz_init_set_ui(rop, ROP_);
  assert(longbool(mpz_tstbit(rop, BIT_INDEX1)) = longbool(ROP_ and (1 shl BIT_INDEX1)));
  assert(longbool(mpz_tstbit(rop, BIT_INDEX2)) = longbool(ROP_ and (1 shl BIT_INDEX2)));
  mpz_clear(rop);
end;

procedure TTestGmpBinding.mpz_urandomb_test;
const
  B = 8 * (sizeof(valuint) - 1);
  N = 1 shl B;
var
  rop: mpz_t;
  state: randstate_t;
begin
  mp_randinit_default(state);
  mpz_init(rop);
  mpz_urandomb(rop, state, B);
  assert(mpz_cmp_ui(rop, N) < 0);
  mpz_clear(rop);
  mp_randclear(state);
end;

procedure TTestGmpBinding.mpz_urandomm_test;
const
  N_ = 1000000;
var
  rop, n: mpz_t;
  state: randstate_t;
begin
  mp_randinit_default(state);
  mpz_init(rop);
  mpz_init_set_ui(n, N_);
  mpz_urandomm(rop, state, n);
  assert(mpz_cmp_ui(rop, N_) < 0);
  mpz_clear(rop);
  mpz_clear(n);
  mp_randclear(state);
end;

procedure TTestGmpBinding.mpz_rrandomb_test;
const
  B = 8 * sizeof(valuint) - 2;
  N = 1 shl B;
var
  rop: mpz_t;
  state: randstate_t;
begin
  mp_randinit_default(state);
  mpz_init(rop);
  mpz_rrandomb(rop, state, B);
  assert(mpz_cmp_ui(rop, N) < 0);
  mpz_clear(rop);
  mp_randclear(state);
end;

procedure TTestGmpBinding.mpz_fits_ushort_p_test;
var op: mpz_t;
begin
  mpz_init_set_ui(op, high(word));
  assert(longbool(mpz_fits_ushort_p(op)));
  mpz_add_ui(op, op, 1);
  assert(not longbool(mpz_fits_ushort_p(op)));
  mpz_clear(op);
end;

procedure TTestGmpBinding.mpz_fits_sshort_p_test;
var op: mpz_t;
begin
  mpz_init_set_si(op, high(smallint));
  assert(longbool(mpz_fits_sshort_p(op)));
  mpz_add_ui(op, op, 1);
  assert(not longbool(mpz_fits_sshort_p(op)));
  mpz_clear(op);
end;

procedure TTestGmpBinding.mpz_fits_uint_p_test;
var op: mpz_t;
begin
  mpz_init_set_ui(op, high(cardinal));
  assert(longbool(mpz_fits_uint_p(op)));
  mpz_add_ui(op, op, 1);
  assert(not longbool(mpz_fits_uint_p(op)));
  mpz_clear(op);
end;

procedure TTestGmpBinding.mpz_fits_sint_p_test;
var op: mpz_t;
begin
  mpz_init_set_si(op, high(integer));
  assert(longbool(mpz_fits_sint_p(op)));
  mpz_add_ui(op, op, 1);
  assert(not longbool(mpz_fits_sint_p(op)));
  mpz_clear(op);
end;

procedure TTestGmpBinding.mpz_fits_ulong_p_test;
var op: mpz_t;
begin
  mpz_init_set_ui(op, high(valuint));
  assert(longbool(mpz_fits_ulong_p(op)));
  mpz_add_ui(op, op, 1);
  assert(not longbool(mpz_fits_ulong_p(op)));
  mpz_clear(op);
end;

procedure TTestGmpBinding.mpz_fits_slong_p_test;
var op: mpz_t;
begin
  mpz_init_set_si(op, high(valsint));
  assert(longbool(mpz_fits_slong_p(op)));
  mpz_add_ui(op, op, 1);
  assert(not longbool(mpz_fits_slong_p(op)));
  mpz_clear(op);
end;

procedure TTestGmpBinding.mpz_sizeinbase_test;
const
  OP_ = 1000000;
var rop: mpz_t;
begin
  mpz_init_set_ui(rop, OP_);
  assert(mpz_sizeinbase(rop, BASE10) - length(inttostr(OP_)) = 0);
  mpz_clear(rop);
end;

procedure TTestGmpBinding.mpz_size_test;
var rop: mpz_t;
begin
  mpz_init(rop);
  assert(mpz_size(rop) = 0);
  mpz_add_ui(rop, rop, 1);
  assert(mpz_size(rop) = 1);
  mpz_clear(rop);
end;

procedure TTestGmpBinding.mpq_init_test;
var rational: mpq_t;
begin
  mpq_init(rational);
  assert(mpq_cmp_ui(rational, 0, 1) = 0);
  mpq_clear(rational);
end;

procedure TTestGmpBinding.mpq_clear_test;
var rational: mpq_t;
begin
  mpq_init(rational);
  mpq_clear(rational);
end;

procedure TTestGmpBinding.mpq_set_ui_test;
const
  OP_1 = 13;
  OP_2 = 17;
var rational: mpq_t;
begin
  mpq_init(rational);
  mpq_set_ui(rational, OP_1, OP_2);
  assert(mpq_cmp_ui(rational, OP_1, OP_2) = 0);
  mpq_clear(rational);
end;

procedure TTestGmpBinding.mpq_set_si_test;
const
  OP_1 = -13;
  OP_2 = 17;
var rational: mpq_t;
begin
  mpq_init(rational);
  mpq_set_si(rational, OP_1, OP_2);
  assert(mpq_cmp_si(rational, OP_1, OP_2) = 0);
  mpq_clear(rational);
end;

procedure TTestGmpBinding.mpq_canonicalize_test;
const
  OP_1 = -13;
  OP_2 = 17;
  CF = 11;
var rational: mpq_t;
begin
  mpq_init(rational);
  mpq_set_si(rational, CF * OP_1, CF * OP_2);
  mpq_canonicalize(rational);
  assert(mpq_cmp_si(rational, OP_1, OP_2) = 0);
  mpq_clear(rational);
end;

procedure TTestGmpBinding.mpq_set_test;
const
  OP_1 = -13;
  OP_2 = 17;
var rational1, rational2: mpq_t;
begin
  mpq_init(rational1);
  mpq_init(rational2);
  mpq_set_si(rational2, OP_1, OP_2);
  mpq_set(rational1, rational2);
  assert(mpq_cmp_si(rational1, OP_1, OP_2) = 0);
  mpq_clear(rational1);
  mpq_clear(rational2);
end;

procedure TTestGmpBinding.mpq_setmpz_test;
const
  OP_1 = -13;
var
  rational: mpq_t;
  op: mpz_t;
begin
  mpq_init(rational);
  mpz_init_set_si(op, OP_1);
  mpq_set_z(rational, op);
  assert(mpq_cmp_si(rational, OP_1, 1) = 0);
  mpq_clear(rational);
  mpz_clear(op);
end;

procedure TTestGmpBinding.mpq_set_str_test;
const
  OP_1 = -13;
  OP_2 = 17;
var rational: mpq_t;
begin
  mpq_init(rational);
  assert(mpq_set_str(rational, pchar(inttostr(OP_1) + '/' + inttostr(OP_2)), BASE10) = 0);
  assert(mpq_cmp_si(rational, OP_1, OP_2) = 0);
  assert(mpq_set_str(rational, pchar(inttostr(OP_1) + '*' + inttostr(OP_2)), BASE10) <> 0);
  mpq_clear(rational);
end;

procedure TTestGmpBinding.mpq_swap_test;
const
  ROP_1N = -13;
  ROP_1D = 17;
  ROP_2N = -23;
  ROP_2D = 31;
var rop1, rop2: mpq_t;
begin
  mpq_init(rop1);
  mpq_init(rop2);
  mpq_set_si(rop1, ROP_1N, ROP_1D);
  mpq_set_si(rop2, ROP_2N, ROP_2D);
  mpq_swap(rop1, rop2);
  assert(mpq_cmp_si(rop1, ROP_2N, ROP_2D) = 0);
  assert(mpq_cmp_si(rop2, ROP_1N, ROP_1D) = 0);
  mpq_clear(rop1);
  mpq_clear(rop2);
end;

procedure TTestGmpBinding.mpq_get_d_test;
const
  OP_1 = -1;
  OP_2 = 2;
var op: mpq_t;
begin
  mpq_init(op);
  mpq_set_si(op, OP_1, OP_2);
  assert(mpq_get_d(op) = OP_1 / OP_2);
  mpq_clear(op);
end;

procedure TTestGmpBinding.mpq_set_d_test;
const
  OP_1 = -1;
  OP_2 = 2;
var rop: mpq_t;
begin
  mpq_init(rop);
  mpq_set_d(rop, OP_1 / OP_2);
  assert(mpq_cmp_si(rop, OP_1, OP_2) = 0);
  mpq_clear(rop);
end;

procedure TTestGmpBinding.mpq_set_f_test;
const OP_ = -10;
var
  op: mpf_t;
  rop: mpq_t;
begin
  mpf_init_set_si(op, OP_);
  mpq_init(rop);
  mpq_set_f(rop, op);
  assert(mpq_get_d(rop) = OP_);
  mpq_clear(rop);
  mpf_clear(op);
end;

procedure TTestGmpBinding.mpq_get_str_test;
const
  OP_1 = -1;
  OP_2 = 2;
var
  op: mpq_t;
  p: pchar;
begin
  mpq_init(op);
  mpq_set_si(op, OP_1, OP_2);
  p := mpq_get_str(nil, BASE10, op);
  assert(p = inttostr(OP_1) + '/' + inttostr(OP_2));
  freemem(p);
  mpq_clear(op);
end;

procedure TTestGmpBinding.mpq_add_test;
const
  N1 = 5;
  D1 = 2;
  N2 = -7;
  D2 = 3;
var sum, addend1, addend2: mpq_t;
begin
  mpq_init(sum);
  mpq_init(addend1);
  mpq_init(addend2);
  mpq_set_si(addend1, N1, D1);
  mpq_set_si(addend2, N2, D2);
  mpq_add(sum, addend1, addend2);
  assert(mpq_cmp_si(sum, N1 * D2 + N2 * D1, D1 * D2) = 0);
  mpq_clear(sum);
  mpq_clear(addend1);
  mpq_clear(addend2);
end;

procedure TTestGmpBinding.mpq_sub_test;
const
  N1 = 5;
  D1 = 2;
  N2 = -7;
  D2 = 3;
var difference, minuend, subtrahend: mpq_t;
begin
  mpq_init(difference);
  mpq_init(minuend);
  mpq_init(subtrahend);
  mpq_set_si(minuend, N1, D1);
  mpq_set_si(subtrahend, N2, D2);
  mpq_sub(difference, minuend, subtrahend);
  assert(mpq_cmp_si(difference, N1 * D2 - N2 * D1, D1 * D2) = 0);
  mpq_clear(difference);
  mpq_clear(minuend);
  mpq_clear(subtrahend);
end;

procedure TTestGmpBinding.mpq_mul_test;
const
  N1 = 5;
  D1 = 2;
  N2 = -7;
  D2 = 3;
var product, multiplier, multiplicant: mpq_t;
begin
  mpq_init(product);
  mpq_init(multiplier);
  mpq_init(multiplicant);
  mpq_set_si(multiplier, N1, D1);
  mpq_set_si(multiplicant, N2, D2);
  mpq_mul(product, multiplier, multiplicant);
  assert(mpq_cmp_si(product, N1 * N2, D1 * D2) = 0);
  mpq_clear(product);
  mpq_clear(multiplier);
  mpq_clear(multiplicant);
end;

procedure TTestGmpBinding.mpq_mul_2exp_test;
const
  N1 = 5;
  D1 = 3;
  OP_2 = 2;
var rop, op1: mpq_t;
begin
  mpq_init(rop);
  mpq_init(op1);
  mpq_set_si(op1, N1, D1);
  mpq_mul_2exp(rop, op1, OP_2);
  assert(mpq_cmp_si(rop, N1 * (1 shl OP_2), D1) = 0);
  mpq_clear(rop);
  mpq_clear(op1);
end;

procedure TTestGmpBinding.mpq_div_test;
const
  N1 = 5;
  D1 = 2;
  N2 = -7;
  D2 = 3;
var quotient, dividend, divisor: mpq_t;
begin
  mpq_init(quotient);
  mpq_init(dividend);
  mpq_init(divisor);
  mpq_set_si(dividend, N1, D1);
  mpq_set_si(divisor, N2, D2);
  mpq_div(quotient, dividend, divisor);
  assert(mpq_cmp_si(quotient, -N1 * D2, -D1 * N2) = 0);
  mpq_clear(quotient);
  mpq_clear(dividend);
  mpq_clear(divisor);
end;

procedure TTestGmpBinding.mpq_div_2exp_test;
const
  N1 = 5;
  D1 = 3;
  OP_2 = 2;
var rop, op1: mpq_t;
begin
  mpq_init(rop);
  mpq_init(op1);
  mpq_set_si(op1, N1, D1);
  mpq_div_2exp(rop, op1, OP_2);
  assert(mpq_cmp_si(rop, N1, D1 * (1 shl OP_2)) = 0);
  mpq_clear(rop);
  mpq_clear(op1);
end;

procedure TTestGmpBinding.mpq_neg_test;
const
  N1 = -5;
  D1 = 3;
var negated_operand, operand: mpq_t;
begin
  mpq_init(negated_operand);
  mpq_init(operand);
  mpq_set_si(operand, N1, D1);
  mpq_neg(negated_operand, operand);
  assert(mpq_cmp_si(negated_operand, -N1, D1) = 0);
  mpq_clear(negated_operand);
  mpq_clear(operand);
end;

procedure TTestGmpBinding.mpq_abs_test;
const
  N1 = 5;
  D1 = 3;
var rop, op: mpq_t;
begin
  mpq_init(rop);
  mpq_init(op);
  mpq_set_si(op, -N1, D1);
  mpq_abs(rop, op);
  assert(mpq_cmp_si(rop, N1, D1) = 0);
  mpq_clear(rop);
  mpq_clear(op);
end;

procedure TTestGmpBinding.mpq_inv_test;
const
  N1 = -5;
  D1 = 3;
var inverted_number, number: mpq_t;
begin
  mpq_init(inverted_number);
  mpq_init(number);
  mpq_set_si(number, N1, D1);
  mpq_inv(inverted_number, number);
  assert(mpq_cmp_si(inverted_number, -D1, -N1) = 0);
  mpq_clear(inverted_number);
  mpq_clear(number);
end;

procedure TTestGmpBinding.mpq_cmp_test;
const
  N1 = -7;
  D1 = 5;
var op1, op2: mpq_t;
begin
  mpq_init(op1);
  mpq_init(op2);
  mpq_set_si(op1, N1, D1);
  mpq_set_si(op2, N1, D1);
  assert(mpq_cmp(op1, op2) = 0);
  mpq_set_si(op1, N1 + 1, D1);
  assert(mpq_cmp(op1, op2) > 0);
  mpq_set_si(op1, N1 - 1, D1);
  assert(mpq_cmp(op1, op2) < 0);
  mpq_clear(op1);
  mpq_clear(op2);
end;

procedure TTestGmpBinding.mpq_cmp_si_test;
const
  N1 = -7;
  D1 = 5;
var op1: mpq_t;
begin
  mpq_init(op1);
  mpq_set_si(op1, N1, D1);
  assert(mpq_cmp_si(op1, N1, D1) = 0);
  assert(mpq_cmp_si(op1, N1 - 1, D1) > 0);
  assert(mpq_cmp_si(op1, N1 + 1, D1) < 0);
  mpq_clear(op1);
end;

procedure TTestGmpBinding.mpq_cmp_ui_test;
const
  N1 = 7;
  D1 = 5;
var op1: mpq_t;
begin
  mpq_init(op1);
  mpq_set_si(op1, N1, D1);
  assert(mpq_cmp_ui(op1, N1, D1) = 0);
  assert(mpq_cmp_ui(op1, N1 - 1, D1) > 0);
  assert(mpq_cmp_ui(op1, N1 + 1, D1) < 0);
  mpq_clear(op1);
end;

procedure TTestGmpBinding.mpq_equal_test;
const
  N1 = -7;
  D1 = 5;
var op1, op2: mpq_t;
begin
  mpq_init(op1);
  mpq_init(op2);
  mpq_set_si(op1, N1, D1);
  mpq_set_si(op2, N1, D1);
  assert(longbool(mpq_equal(op1, op2)));
  mpq_set_si(op1, N1 + 1, D1);
  assert(not longbool(mpq_equal(op1, op2)));
  mpq_set_si(op1, N1 - 1, D1);
  assert(not longbool(mpq_equal(op1, op2)));
  mpq_clear(op1);
  mpq_clear(op2);
end;

procedure TTestGmpBinding.mpq_get_num_test;
const
  N1 = -7;
  D1 = 5;
var
  rational: mpq_t;
  numerator: mpz_t;
begin
  mpq_init(rational);
  mpz_init(numerator);
  mpq_set_si(rational, N1, D1);
  mpq_get_num(numerator, rational);
  assert(mpz_get_si(numerator) = N1);
  mpq_clear(rational);
  mpz_clear(numerator);
end;

procedure TTestGmpBinding.mpq_get_den_test;
const
  N1 = -7;
  D1 = 5;
var
  rational: mpq_t;
  denominator: mpz_t;
begin
  mpq_init(rational);
  mpz_init(denominator);
  mpq_set_si(rational, N1, D1);
  mpq_get_den(denominator, rational);
  assert(mpz_get_si(denominator) = D1);
  mpq_clear(rational);
  mpz_clear(denominator);
end;

procedure TTestGmpBinding.mpq_set_num_test;
const
  N1 = -7;
  D1 = 5;
  N2 = 3;
var
  rational: mpq_t;
  numerator: mpz_t;
begin
  mpq_init(rational);
  mpz_init_set_si(numerator, N2);
  mpq_set_si(rational, N1, D1);
  mpq_set_num(rational, numerator);
  assert(mpq_cmp_si(rational, N2, D1) = 0);
  mpq_clear(rational);
  mpz_clear(numerator);
end;

procedure TTestGmpBinding.mpq_set_den_test;
const
  N1 = -7;
  D1 = 5;
  D2 = 3;
var
  rational: mpq_t;
  denominator: mpz_t;
begin
  mpq_init(rational);
  mpz_init_set_si(denominator, D2);
  mpq_set_si(rational, N1, D1);
  mpq_set_den(rational, denominator);
  assert(mpq_cmp_si(rational, N1, D2) = 0);
  mpq_clear(rational);
  mpz_clear(denominator);
end;

procedure TTestGmpBinding.mpf_get_default_prec_test;
begin
  assert(mpf_get_default_prec > 0);
end;

procedure TTestGmpBinding.mpf_set_default_prec_test;
var prec: valuint;
begin
  prec := mpf_get_default_prec;
  mpf_set_default_prec(2 * prec);
  assert(mpf_get_default_prec  = 2 * prec);
  mpf_set_default_prec(prec);
end;

procedure TTestGmpBinding.mpf_init_test;
var x: mpf_t;
begin
  mpf_init(x);
  assert(mpf_get_prec(x) = mpf_get_default_prec);
  mpf_clear(x);
end;

procedure TTestGmpBinding.mpf_init2_test;
var x: mpf_t;
begin
  mpf_init2(x, 2 * mpf_get_default_prec);
  assert(mpf_get_prec(x) = 2 * mpf_get_default_prec);
  mpf_clear(x);
end;

procedure TTestGmpBinding.mpf_clear_test;
var x: mpf_t;
begin
  mpf_init(x);
  mpf_clear(x);
end;

procedure TTestGmpBinding.mpf_get_prec_test;
var x: mpf_t;
begin
  mpf_init(x);
  mpf_set_prec(x, 2 * mpf_get_default_prec);
  assert(mpf_get_prec(x) = 2 * mpf_get_default_prec);
  mpf_clear(x);
end;

procedure TTestGmpBinding.mpf_set_prec_test;
var x: mpf_t;
begin
  mpf_init(x);
  mpf_set_prec(x, 2 * mpf_get_default_prec);
  assert(mpf_get_prec(x) = 2 * mpf_get_default_prec);
  mpf_clear(x);
end;

procedure TTestGmpBinding.mpf_set_prec_raw_test;
const N = 10;
var x: mpf_t;
begin
  mpf_init2(x, N * mpf_get_default_prec);
  mpf_set_prec_raw(x, mpf_get_default_prec);
  mpf_set_prec_raw(x, N * mpf_get_default_prec);
  mpf_clear(x);
end;

procedure TTestGmpBinding.mpf_set_q_test;
const OP_ = -10;
var
  op: mpq_t;
  rop: mpf_t;
begin
  mpq_init(op);
  mpf_init(rop);
  mpq_set_si(op, OP_, 1);
  mpf_set_q(rop, op);
  assert(mpf_get_si(rop) = OP_);
  mpf_clear(rop);
  mpq_clear(op);
end;

procedure TTestGmpBinding.mpf_set_ui_test;
const OP = 1000000;
var rop: mpf_t;
begin
  mpf_init(rop);
  mpf_set_ui(rop, OP);
  assert(mpf_get_ui(rop) = OP);
  mpf_clear(rop);
end;

procedure TTestGmpBinding.mpf_get_ui_test;
const OP = 1000000;
var rop: mpf_t;
begin
  mpf_init(rop);
  mpf_set_ui(rop, OP);
  assert(mpf_get_ui(rop) = OP);
  mpf_clear(rop);
end;

procedure TTestGmpBinding.mpf_set_si_test;
const OP = -1000000;
var rop: mpf_t;
begin
  mpf_init(rop);
  mpf_set_si(rop, OP);
  assert(mpf_get_si(rop) = OP);
  mpf_clear(rop);
end;

procedure TTestGmpBinding.mpf_get_si_test;
const OP = -1000000;
var rop: mpf_t;
begin
  mpf_init(rop);
  mpf_set_si(rop, OP);
  assert(mpf_get_si(rop) = OP);
  mpf_clear(rop);
end;

procedure TTestGmpBinding.mpf_set_test;
const N = -1000000;
var rop, op: mpf_t;
begin
  mpf_init(rop);
  mpf_init_set_si(op, N);
  mpf_set(rop, op);
  assert(mpf_get_si(rop) = N);
  mpf_clear(rop);
  mpf_clear(op);
end;

procedure TTestGmpBinding.mpf_set_str_test;
const N = -123;
var rop: mpf_t;
begin
  mpf_init(rop);
  assert(mpf_set_str(rop, pchar(inttostr(N)), BASE10) = 0);
  assert(mpf_get_si(rop) = N);
  mpf_clear(rop);
end;

procedure TTestGmpBinding.mpf_swap_test;
const
  ROP_1 = -13;
  ROP_2 = -23;
var rop1, rop2: mpf_t;
begin
  mpf_init_set_si(rop1, ROP_1);
  mpf_init_set_si(rop2, ROP_2);
  mpf_swap(rop1, rop2);
  assert(mpf_get_si(rop1) =  ROP_2);
  assert(mpf_get_si(rop2) = ROP_1);
  mpf_clear(rop1);
  mpf_clear(rop2);
end;

procedure TTestGmpBinding.mpf_get_d_test;
const N = -1.5;
var rop: mpf_t;
begin
  mpf_init_set_d(rop, N);
  assert(mpf_get_d(rop) = N);
  mpf_clear(rop);
end;

procedure TTestGmpBinding.mpf_set_d_test;
const N = -1.5;
var rop: mpf_t;
begin
  mpf_init(rop);
  mpf_set_d(rop, N);
  assert(mpf_get_d(rop) = N);
  mpf_clear(rop);
end;

procedure TTestGmpBinding.mpf_setmpz_test;
const
  OP_1 = -13;
var
  rop: mpf_t;
  op: mpz_t;
begin
  mpf_init(rop);
  mpz_init_set_si(op, OP_1);
  mpf_set_z(rop, op);
  assert(mpf_get_si(rop) = OP_1);
  mpf_clear(rop);
  mpz_clear(op);
end;

procedure TTestGmpBinding.mpf_get_d_2exp_test;
const
  M = 0.5;
  E = 4;
  N = (1 shl E) div 2;
var
  rop: mpf_t;
  exp: valsint;
begin
  mpf_init_set_d(rop, N);
  exp := -1;
  assert(mpf_get_d_2exp(exp, rop) = M);
  assert(exp = E);
  mpf_clear(rop);
end;

procedure TTestGmpBinding.mpf_get_str_test;
const
  N = 3.1416;
  S = '31416';
  E = 1;
var
  op: mpf_t;
  p: pchar;
  exp: mp_exp_t;
begin
  mpf_init_set_d(op, N);
  p := mpf_get_str(nil, exp, BASE10, length(S), op);
  assert(p = S);
  assert(exp = E);
  freemem(p);
  mpf_clear(op);
end;

procedure TTestGmpBinding.mpf_add_test;
const
  OP1_ = 1;
  OP2_ = 2;
var rop, op1, op2: mpf_t;
begin
  mpf_init(rop);
  mpf_init_set_d(op1, OP1_);
  mpf_init_set_d(op2, OP2_);
  mpf_add(rop, op1, op2);
  assert(mpf_get_d(rop) = OP1_ + OP2_);
  mpf_clear(rop);
  mpf_clear(op1);
  mpf_clear(op2);
end;

procedure TTestGmpBinding.mpf_add_ui_test;
const
  OP1_ = 1;
  OP2_ = 2;
var rop, op1: mpf_t;
begin
  mpf_init(rop);
  mpf_init_set_d(op1, OP1_);
  mpf_add_ui(rop, op1, OP2_);
  assert(mpf_get_d(rop) = OP1_ + OP2_);
  mpf_clear(rop);
  mpf_clear(op1);
end;

procedure TTestGmpBinding.mpf_sub_test;
const
  OP1_ = 3;
  OP2_ = 1;
var rop, op1, op2: mpf_t;
begin
  mpf_init(rop);
  mpf_init_set_d(op1, OP1_);
  mpf_init_set_d(op2, OP2_);
  mpf_sub(rop, op1, op2);
  assert(mpf_get_d(rop) = OP1_ - OP2_);
  mpf_clear(rop);
  mpf_clear(op1);
  mpf_clear(op2);
end;

procedure TTestGmpBinding.mpf_sub_ui_test;
const
  OP1_ = 3;
  OP2_ = 1;
var rop, op1: mpf_t;
begin
  mpf_init(rop);
  mpf_init_set_d(op1, OP1_);
  mpf_sub_ui(rop, op1, OP2_);
  assert(mpf_get_d(rop) = OP1_ - OP2_);
  mpf_clear(rop);
  mpf_clear(op1);
end;

procedure TTestGmpBinding.mpf_ui_sub_test;
const
  OP1_ = 3;
  OP2_ = 1;
var rop, op2: mpf_t;
begin
  mpf_init(rop);
  mpf_init_set_d(op2, OP2_);
  mpf_ui_sub(rop, OP1_, op2);
  assert(mpf_get_d(rop) = OP1_ - OP2_);
  mpf_clear(rop);
  mpf_clear(op2);
end;

procedure TTestGmpBinding.mpf_mul_test;
const
  OP1_ = 2;
  OP2_ = 3;
var rop, op1, op2: mpf_t;
begin
  mpf_init(rop);
  mpf_init_set_d(op1, OP1_);
  mpf_init_set_d(op2, OP2_);
  mpf_mul(rop, op1, op2);
  assert(mpf_get_d(rop) = OP1_ * OP2_);
  mpf_clear(rop);
  mpf_clear(op1);
  mpf_clear(op2);
end;

procedure TTestGmpBinding.mpf_mul_ui_test;
const
  OP1_ = 2;
  OP2_ = 3;
var rop, op1: mpf_t;
begin
  mpf_init(rop);
  mpf_init_set_d(op1, OP1_);
  mpf_mul_ui(rop, op1, OP2_);
  assert(mpf_get_d(rop) = OP1_ * OP2_);
  mpf_clear(rop);
  mpf_clear(op1);
end;

procedure TTestGmpBinding.mpf_mul_2exp_test;
const
  OP1_ = 3;
  OP2_ = 4;
var rop, op1: mpf_t;
begin
  mpf_init(rop);
  mpf_init_set_d(op1, OP1_);
  mpf_mul_2exp(rop, op1, OP2_);
  assert(mpf_get_d(rop) = OP1_ * (1 shl OP2_));
  mpf_clear(rop);
  mpf_clear(op1);
end;

procedure TTestGmpBinding.mpf_div_test;
const
  OP1_ = 6;
  OP2_ = 2;
var rop, op1, op2: mpf_t;
begin
  mpf_init(rop);
  mpf_init_set_d(op1, OP1_);
  mpf_init_set_d(op2, OP2_);
  mpf_div(rop, op1, op2);
  assert(mpf_get_d(rop) = OP1_ / OP2_);
  mpf_clear(rop);
  mpf_clear(op1);
  mpf_clear(op2);
end;

procedure TTestGmpBinding.mpf_div_ui_test;
const
  OP1_ = 6;
  OP2_ = 2;
var rop, op1: mpf_t;
begin
  mpf_init(rop);
  mpf_init_set_d(op1, OP1_);
  mpf_div_ui(rop, op1, OP2_);
  assert(mpf_get_d(rop) = OP1_ / OP2_);
  mpf_clear(rop);
  mpf_clear(op1);
end;

procedure TTestGmpBinding.mpf_ui_div_test;
const
  OP1_ = 6;
  OP2_ = 2;
var rop, op2: mpf_t;
begin
  mpf_init(rop);
  mpf_init_set_si(op2, OP2_);
  mpf_ui_div(rop, OP1_, op2);
  assert(mpf_get_d(rop) = OP1_ / OP2_);
  mpf_clear(rop);
  mpf_clear(op2);
end;

procedure TTestGmpBinding.mpf_div_2exp_test;
const
  OP1_ = 16;
  OP2_ = 2;
var rop, op1: mpf_t;
begin
  mpf_init(rop);
  mpf_init_set_d(op1, OP1_);
  mpf_div_2exp(rop, op1, OP2_);
  assert(mpf_get_d(rop) = OP1_ / (1 shl OP2_));
  mpf_clear(rop);
  mpf_clear(op1);
end;

procedure TTestGmpBinding.mpf_sqrt_test;
const
  OP_ = 4;
var rop, op: mpf_t;
begin
  mpf_init(rop);
  mpf_init_set_d(op, OP_);
  mpf_sqrt(rop, op);
  assert(mpf_get_d(rop) = sqrt(OP_));
  mpf_clear(rop);
  mpf_clear(op);
end;

procedure TTestGmpBinding.mpf_sqrt_ui_test;
const
  OP_ = 4;
var rop: mpf_t;
begin
  mpf_init(rop);
  mpf_sqrt_ui(rop, OP_);
  assert(mpf_get_d(rop) = sqrt(OP_));
  mpf_clear(rop);
end;

procedure TTestGmpBinding.mpf_pow_ui_test;
const
  OP1_ = 3;
  OP2_ = 2;
var rop, op1: mpf_t;
begin
  mpf_init(rop);
  mpf_init_set_d(op1, OP1_);
  mpf_pow_ui(rop, op1, OP2_);
  assert(mpf_get_d(rop) = OP1_ ** OP2_);
  mpf_clear(rop);
  mpf_clear(op1);
end;

procedure TTestGmpBinding.mpf_neg_test;
const
  OP_ = 4;
var rop, op: mpf_t;
begin
  mpf_init(rop);
  mpf_init_set_d(op, OP_);
  mpf_neg(rop, op);
  assert(mpf_get_d(rop) = -OP_);
  mpf_clear(rop);
  mpf_clear(op);
end;

procedure TTestGmpBinding.mpf_abs_test;
const OP_ = -4;
var rop, op: mpf_t;
begin
  mpf_init(rop);
  mpf_init_set_d(op, OP_);
  mpf_abs(rop, op);
  assert(mpf_get_d(rop) = -OP_);
  mpf_clear(rop);
  mpf_clear(op);
end;

procedure TTestGmpBinding.mpf_cmp_test;
const OP_1 = -10;
var op1, op2: mpf_t;
begin
  mpf_init_set_si(op1, OP_1);
  mpf_init_set_si(op2, OP_1);
  assert(mpf_cmp(op1, op2) = 0);
  mpf_set_si(op2, OP_1 + 1);
  assert(mpf_cmp(op1, op2) < 0);
  mpf_set_si(op2, OP_1 - 1);
  assert(mpf_cmp(op1, op2) > 0);
  mpf_clear(op1);
  mpf_clear(op2);
end;

procedure TTestGmpBinding.mpf_cmp_d_test;
const OP_ = -10;
var op: mpf_t;
begin
  mpf_init_set_si(op, OP_);
  assert(mpf_cmp_d(op, OP_) = 0);
  assert(mpf_cmp_d(op, OP_ + 1) < 0);
  assert(mpf_cmp_d(op, OP_ - 1) > 0);
  mpf_clear(op);
end;

procedure TTestGmpBinding.mpf_cmp_si_test;
const OP_ = -10;
var op: mpf_t;
begin
  mpf_init_set_si(op, OP_);
  assert(mpf_cmp_si(op, OP_) = 0);
  assert(mpf_cmp_si(op, OP_ + 1) < 0);
  assert(mpf_cmp_si(op, OP_ - 1) > 0);
  mpf_clear(op);
end;

procedure TTestGmpBinding.mpf_cmp_ui_test;
const OP_ = 10;
var op: mpf_t;
begin
  mpf_init_set_si(op, OP_);
  assert(mpf_cmp_ui(op, OP_) = 0);
  assert(mpf_cmp_ui(op, OP_ + 1) < 0);
  assert(mpf_cmp_ui(op, OP_ - 1) > 0);
  mpf_clear(op);
end;

procedure TTestGmpBinding.mpf_eq_test;
const
  OP_1 = 10;
  OP_3 = 8;
var op1, op2: mpf_t;
begin
  mpf_init_set_si(op1, OP_1);
  mpf_init_set_si(op2, OP_1);
  assert(mpf_eq(op1, op2, OP_3) <> 0);
  mpf_clear(op1);
  mpf_clear(op2);
end;

procedure TTestGmpBinding.mpf_reldiff_test;
const
  OP1_ = 4;
  OP2_ = 2;
var rop, op1, op2: mpf_t;
begin
  mpf_init(rop);
  mpf_init_set_d(op1, OP1_);
  mpf_init_set_d(op2, OP2_);
  mpf_reldiff(rop, op1, op2);
  assert(mpf_get_d(rop) = abs(OP1_ - OP2_) / OP1_);
  mpf_clear(rop);
  mpf_clear(op1);
  mpf_clear(op2);
end;

procedure TTestGmpBinding.mpf_ceil_test;
const N = 3.1;
var rop, op: mpf_t;
begin
  mpf_init(rop);
  mpf_init_set_d(op, N);
  mpf_ceil(rop, op);
  assert(mpf_get_d(rop) = ceil(N));
  mpf_clear(rop);
  mpf_clear(op);
end;

procedure TTestGmpBinding.mpf_floor_test;
const N = 3.9;
var rop, op: mpf_t;
begin
  mpf_init(rop);
  mpf_init_set_d(op, N);
  mpf_floor(rop, op);
  assert(mpf_get_d(rop) = floor(N));
  mpf_clear(rop);
  mpf_clear(op);
end;

procedure TTestGmpBinding.mpf_trunc_test;
const N = -3.9;
var rop, op: mpf_t;
begin
  mpf_init(rop);
  mpf_init_set_d(op, N);
  mpf_trunc(rop, op);
  assert(mpf_get_d(rop) = trunc(N));
  mpf_clear(rop);
  mpf_clear(op);
end;

procedure TTestGmpBinding.mpf_integer_p_test;
const
  N1 = 10;
  N2 = 10.1;
var op: mpf_t;
begin
  mpf_init_set_si(op, N1);
  assert(longbool(mpf_integer_p(op)));
  mpf_set_d(op, N2);
  assert(not longbool(mpf_integer_p(op)));
  mpf_clear(op);
end;

procedure TTestGmpBinding.mpf_fits_ushort_p_test;
var op: mpf_t;
begin
  mpf_init_set_ui(op, high(word));
  assert(longbool(mpf_fits_ushort_p(op)));
  mpf_add_ui(op, op, 1);
  assert(not longbool(mpf_fits_ushort_p(op)));
  mpf_clear(op);
end;

procedure TTestGmpBinding.mpf_fits_sshort_p_test;
var op: mpf_t;
begin
  mpf_init_set_ui(op, high(smallint));
  assert(longbool(mpf_fits_sshort_p(op)));
  mpf_add_ui(op, op, 1);
  assert(not longbool(mpf_fits_sshort_p(op)));
  mpf_clear(op);
end;

procedure TTestGmpBinding.mpf_fits_uint_p_test;
var op: mpf_t;
begin
  mpf_init_set_ui(op, high(cardinal));
  assert(longbool(mpf_fits_uint_p(op)));
  mpf_add_ui(op, op, 1);
  assert(not longbool(mpf_fits_uint_p(op)));
  mpf_clear(op);
end;

procedure TTestGmpBinding.mpf_fits_sint_p_test;
var op: mpf_t;
begin
  mpf_init_set_ui(op, high(integer));
  assert(longbool(mpf_fits_sint_p(op)));
  mpf_add_ui(op, op, 1);
  assert(not longbool(mpf_fits_sint_p(op)));
  mpf_clear(op);
end;

procedure TTestGmpBinding.mpf_fits_ulong_p_test;
var op: mpf_t;
begin
  mpf_init_set_ui(op, high(valuint));
  assert(longbool(mpf_fits_ulong_p(op)));
  mpf_add_ui(op, op, 1);
  assert(not longbool(mpf_fits_ulong_p(op)));
  mpf_clear(op);
end;

procedure TTestGmpBinding.mpf_fits_slong_p_test;
var op: mpf_t;
begin
  mpf_init_set_ui(op, high(valsint));
  assert(longbool(mpf_fits_slong_p(op)));
  mpf_add_ui(op, op, 1);
  assert(not longbool(mpf_fits_slong_p(op)));
  mpf_clear(op);
end;

procedure TTestGmpBinding.mpf_urandomb_test;
const NBITS = 100;
var
  rop: mpf_t;
  state: randstate_t;
  cmp: longint;
begin
  mp_randinit_default(state);
  mpf_init(rop);
  mpf_urandomb(rop, state, NBITS);
  cmp := mpf_cmp_ui(rop, 0);
  assert(cmp >= 0);
  assert(mpf_cmp_ui(rop, 1) < 0);
  mpf_clear(rop);
  mp_randclear(state);
end;

procedure TTestGmpBinding.mpf_random2_test;
var
  rop: mpf_t;
begin
  mpf_init(rop);
  mpf_random2(rop, 1, 1);
  mpf_clear(rop);
end;

procedure TTestGmpBinding.mpf_init_set_test;
const N = -1000000;
var rop, op: mpf_t;
begin
  mpf_init_set_si(op, N);
  mpf_init_set(rop, op);
  assert(mpf_get_si(rop) = N);
  mpf_clear(rop);
  mpf_clear(op);
end;

procedure TTestGmpBinding.mpf_init_set_d_test;
const N = -1.5;
var rop: mpf_t;
begin
  mpf_init_set_d(rop, N);
  assert(mpf_get_d(rop) = N);
  mpf_clear(rop);
end;

procedure TTestGmpBinding.mpf_init_set_si_test;
const N = -5;
var rop: mpf_t;
begin
  mpf_init_set_si(rop, N);
  assert(mpf_get_si(rop) = N);
  mpf_clear(rop);
end;

procedure TTestGmpBinding.mpf_init_set_str_test;
const N = -123;
var rop: mpf_t;
begin
  mpf_init_set_str(rop, pchar(inttostr(N)), BASE10);
  assert(mpf_get_si(rop) = N);
  mpf_clear(rop);
end;

procedure TTestGmpBinding.mpf_init_set_ui_test;
const N = 5;
var rop: mpf_t;
begin
  mpf_init_set_ui(rop, N);
  assert(mpf_get_ui(rop) = N);
  mpf_clear(rop);
end;

procedure TTestGmpBinding.mpn_add_n_test;
var
  rop, s1, s2: mp_limb_t;
begin
  s1 := high(mp_limb_t);
  s2 := s1;
  rop := 2;
  assert(mpn_add_n(@rop, @s1, @s2, 1) = 1);
  assert(rop = high(mp_limb_t) - 1);
end;

procedure TTestGmpBinding.mpn_add_1_test;
var
  rop, s1: mp_limb_t;
begin
  s1 := high(mp_limb_t);
  rop := 2;
  assert(mpn_add_1(@rop, @s1, 1, high(mp_limb_t)) = 1);
  assert(rop = high(mp_limb_t) - 1);
end;

procedure TTestGmpBinding.mpn_add_test;
var
  rop, s1, s2: mp_limb_t;
begin
  s1 := high(mp_limb_t);
  s2 := s1;
  rop := 2;
  assert(mpn_add(@rop, @s1, 1, @s2, 1) = 1);
  assert(rop = high(mp_limb_t) - 1);
end;

procedure TTestGmpBinding.mpn_sub_n_test;
var
  rop, s1, s2: mp_limb_t;
begin
  s1 := 0;
  s2 := high(mp_limb_t);
  rop := 2;
  assert(mpn_sub_n(@rop, @s1, @s2, 1) = 1);
  assert(rop = 1);
end;

procedure TTestGmpBinding.mpn_sub_1_test;
var
  rop, s1: mp_limb_t;
begin
  s1 := 0;
  rop := 2;
  assert(mpn_sub_1(@rop, @s1, 1, high(mp_limb_t)) = 1);
  assert(rop = 1);
end;

procedure TTestGmpBinding.mpn_sub_test;
var
  rop, s1, s2: mp_limb_t;
begin
  s1 := 0;
  s2 := high(mp_limb_t);
  rop := 2;
  assert(mpn_sub(@rop, @s1, 1, @s2, 1) = 1);
  assert(rop = 1);
end;

procedure TTestGmpBinding.mpn_mul_n_test;
var
  rop: array[0..1] of mp_limb_t;
  s1, s2: mp_limb_t;
begin
  s1 := high(mp_limb_t);
  s2 := s1;
  mpn_mul_n(@rop, @s1, @s2, 1);
  assert(rop[0] = 1);
  assert(rop[1] = high(mp_limb_t) - 1);
end;

procedure TTestGmpBinding.mpn_mul_1_test;
var
  rop: array[0..1] of mp_limb_t;
  s1: mp_limb_t;
begin
  s1 := high(mp_limb_t);
  assert(mpn_mul_1(@rop, @s1, 1, high(mp_limb_t)) = high(mp_limb_t) - 1);
  assert(rop[0] = 1);
end;

procedure TTestGmpBinding.mpn_mul_test;
var
  rop: array[0..1] of mp_limb_t;
  s1, s2: mp_limb_t;
begin
  s1 := high(mp_limb_t);
  s2 := s1;
  assert(mpn_mul(@rop, @s1, 1, @s2, 1) = high(mp_limb_t) - 1);
  assert(rop[0] = 1);
  assert(rop[1] = high(mp_limb_t) - 1);
end;

procedure TTestGmpBinding.mpn_addmul_1_test;
var
  rop: array[0..1] of mp_limb_t;
  s1: mp_limb_t;
begin
  rop[0] := 1;
  rop[1] := 0;
  s1 := high(mp_limb_t);
  assert(mpn_addmul_1(@rop, @s1, 1, high(mp_limb_t)) = high(mp_limb_t) - 1);
  assert(rop[0] = 2);
end;

procedure TTestGmpBinding.mpn_submul_1_test;
var
  rop: array[0..1] of mp_limb_t;
  s1: mp_limb_t;
begin
  rop[0] := 1;
  rop[1] := 0;
  s1 := high(mp_limb_t);
  assert(mpn_submul_1(@rop, @s1, 1, high(mp_limb_t)) = high(mp_limb_t) - 1);
  assert(rop[0] = 0);
end;

procedure TTestGmpBinding.mpn_tdiv_qr_test;
const
  N_ = 19;
  D_ = 4;
var
  q, r: array[0..1] of mp_limb_t;
  n, d: mp_limb_t;
begin
  n := N_;
  d := D_;
  q[0] := 0;
  q[1] := 0;
  r[0] := 0;
  r[1] := 0;
  mpn_tdiv_qr(@q, @r, 0, @n, 1, @d, 1);
  assert(q[0] = N_ div D_);
  assert(r[0] = N_ mod D_);
end;

procedure TTestGmpBinding.mpn_divrem_1_test;
const
  N_ = 19;
  D_ = 4;
var r1, s2: mp_limb_t;
begin
  r1 := 0;
  s2 := N_;
  assert(mpn_divrem_1(@r1, 0, @s2, 1, D_) = N_ mod D_);
  assert(r1 = N_ div D_);
end;

procedure TTestGmpBinding.mpn_divexact_by3c_test;
const
  K = 3;
  N_ = 17;
var r, s: mp_limb_t;
begin
  r := 0;
  s := K * N_;
  assert(mpn_divexact_by3c(@r, @s, 1, 0) = 0);
  assert(r = N_);
  s := K * N_ + 1;
  assert(mpn_divexact_by3c(@r, @s, 1, 0) <> 0);
end;

procedure TTestGmpBinding.mpn_mod_1_test;
const
  N_ = 19;
  D_ = 4;
var s1: mp_limb_t;
begin
  s1 := N_;
  assert(mpn_mod_1(@s1, 1, D_) = N_ mod D_);
end;

procedure TTestGmpBinding.mpn_lshift_test;
var r, s: mp_limb_t;
begin
  r := 0;
  s := high(mp_limb_t);
  assert(mpn_lshift(@r, @s, 1, 1) = 1);
  assert(r = high(mp_limb_t) - 1);
end;

procedure TTestGmpBinding.mpn_rshift_test;
var r, s: mp_limb_t;
begin
  r := 0;
  s := high(mp_limb_t);
  assert(mpn_rshift(@r, @s, 1, 1) = valuint(1) shl (bits_per_limb - 1));
  assert(r = high(mp_limb_t) shr 1);
end;

procedure TTestGmpBinding.mpn_cmp_test;
const S1_ = 10;
var s1, s2: mp_limb_t;
begin
  s1 := S1_;
  S2 := S1_;
  assert(mpn_cmp(@s1, @s2, 1) = 0);
  S2 := S1_ - 1;
  assert(mpn_cmp(@s1, @s2, 1) > 0);
  S2 := S1_ + 1;
  assert(mpn_cmp(@s1, @s2, 1) < 0);
end;

procedure TTestGmpBinding.mpn_gcd_test;
const
  S1_ = 30;
  S2_ = 105;
  RP_ = 15;
var r, s1, s2: mp_limb_t;
begin
  s1 := S1_;
  s2 := S2_;
  r := 0;
  assert(mpn_gcd(@r, @s1, 1, @s2, 1) = 1);
  assert(r = RP_);
end;

procedure TTestGmpBinding.mpn_gcd_1_test;
const
  S1_ = 30;
  S2_ = 105;
  R_ = 15;
var s1: mp_limb_t;
begin
  s1 := S1_;
  assert(mpn_gcd_1(@s1, 1, S2_) = R_);
end;

procedure TTestGmpBinding.mpn_gcdext_test;
const
  S1_ = 3 * 5;
  S2_ = 2 * 3;
  R1_ = 3;
var
  r1, r2, s1, s2: array[0..1] of mp_limb_t;
  r2n: mp_size_t;
  k: valsint;
begin
  s1[0] := S1_;
  s1[1] := 0;
  s2[0] := S2_;
  s2[1] := 0;
  assert(mpn_gcdext(@r1, @r2, r2n, @s1, 1, @s2, 1) = 1);
  assert(r2n = 1);
  assert(r1[0] = R1_);
  k := (valsint(r1[0]) - valsint(r2[0]) * valsint(s1[0])) div valsint(s2[0]);
  assert(valsint(r1[0]) = valsint(r2[0]) * valsint(s1[0]) + k * valsint(s2[0]));
end;

procedure TTestGmpBinding.mpn_sqrtrem_test;
const
  ROOT = 3;
var r1, r2, s: mp_limb_t;
begin
  s := ROOT ** 2 + ROOT - 1;
  assert(mpn_sqrtrem(@r1, @r2, @s, 1) = 1);
  assert(r1 = ROOT);
  assert(r2 = ROOT - 1);
end;

procedure TTestGmpBinding.mpn_get_str_test;
const N = uint64($FEDCBA9876543210);
var
  str: array[0..2 * sizeof(mp_limb_t)] of byte;
  s1: mp_limb_t;
  i: integer;
begin
  s1 := N and (high(mp_limb_t) - 1);
  assert(mpn_get_str(@str, BASE16, @s1, 1) = high(str));
  for i := 0 to high(str) - 1 do
    assert(str[i] = high(str) - i - 1);
end;

procedure TTestGmpBinding.mpn_set_str_test;
const N = uint64($FEDCBA9876543210);
var
  r: mp_limb_t;
  str: array[0..2 * sizeof(mp_limb_t)] of byte;
  i: integer;
begin
  for i := 0 to high(str) - 1 do
    str[i] := high(str) - i - 1;
  assert(mpn_set_str(@r, @str, high(str), BASE16) = 1);
  assert(r = N and (high(mp_limb_t) - 1));
end;

procedure TTestGmpBinding.mpn_scan0_test;
const
  S1_ = $F75;
  STARTING_BIT = 4;
  N = 7;
var s1: mp_limb_t;
begin
  s1 := S1_;
  assert(mpn_scan0(@s1, STARTING_BIT) = N);
end;

procedure TTestGmpBinding.mpn_scan1_test;
const
  S1_ = $85;
  STARTING_BIT = 4;
  N = 7;
var s1: mp_limb_t;
begin
  s1 := S1_;
  assert(mpn_scan1(@s1, STARTING_BIT) = N);
end;

procedure TTestGmpBinding.mpn_popcount_test;
const
  S1_ = $55AA;
  N = 8;
var s1: mp_limb_t;
begin
  s1 := S1_;
  assert(mpn_popcount(@s1, 1) = N);
end;

procedure TTestGmpBinding.mpn_hamdist_test;
const
  S1_ = $55;
  S2_ = $7A;
  N = 5;
var s1, s2: mp_limb_t;
begin
  s1 := S1_;
  s2 := S2_;
  assert(mpn_hamdist(@s1, @s2, 1) = N);
end;

procedure TTestGmpBinding.mpn_perfect_square_p_test;
const ROOT = 3;
var s1: mp_limb_t;
begin
  s1 := ROOT ** 2;
  assert(mpn_perfect_square_p(@s1, 1) <> 0);
  s1 := s1 or 2;
  assert(mpn_perfect_square_p(@s1, 1) = 0);
end;

procedure TTestGmpBinding.mpn_random_test;
var r1: array[0..2] of mp_limb_t;
begin
  mpn_random(@r1, high(r1) + 1);
  assert((r1[2] <> 0) and ((r1[0] <> r1[1]) or (r1[0] <> r1[2]) or (r1[1] <> r1[2])));
end;

procedure TTestGmpBinding.mpn_random2_test;
var r1: array[0..2] of mp_limb_t;
begin
  mpn_random2(@r1, high(r1) + 1);
  assert((r1[2] <> 0) and ((r1[0] <> r1[1]) or (r1[0] <> r1[2]) or (r1[1] <> r1[2])));
end;

procedure TTestGmpBinding.bits_per_limb_test;
begin
  assert(bits_per_limb = 8 * sizeof(mp_limb_t));
end;

procedure TTestGmpBinding.version_test;

  function isvernum(s: string; first, last: integer): boolean;
  var i: integer;
  begin
    i := strtointdef(copy(s, first, last - first + 1), -1);
    result := i >= 0;
  end;

const DOT = '.';
var
  v: string;
  dot1, dot2: integer;
begin
  v := version;
  dot1 := pos(DOT, v);
  assert(dot1 <> 0);
  dot2 := posex(DOT, v, dot1 + 1);
  assert(dot2 <> 0);
  assert(isvernum(v, 1, dot1 - 1));
  assert(isvernum(v, dot1 + 1, dot2 - 1));
  assert(isvernum(v, dot2 + 1, length(v)));
end;

{ TTestGmpExtensions }

procedure TTestGmpExtensions.randinit_default_test;
var state: MPRandState;
begin
  randinit_default(state);
  assert(rnd_test(state.Ptr^));
end;

procedure TTestGmpExtensions.randinit_mt_test;
var state: MPRandState;
begin
  randinit_mt(state);
  assert(rnd_test(state.Ptr^));
end;

procedure TTestGmpExtensions.randinit_lc_2exp_test;
const
  A_ =  3;
  C = 5;
  M2EXP = 8;
var
  state: MPRandState;
  a: MPInteger;
begin
  z_init_set_ui(a, A_);
  randinit_lc_2exp(state, a, C, M2EXP);
  assert(rnd_test(state.Ptr^));
end;

procedure TTestGmpExtensions.randinit_lc_2exp_size_test;
var state: MPRandState;
begin
  assert(randinit_lc_2exp_size(state, 0));
  assert(rnd_test(state.Ptr^));
end;

procedure TTestGmpExtensions.randinit_set_test;
var rop, op: MPRandState;
begin
  randinit_default(op);
  randinit_set(rop, op);
  assert(rnd_test(rop.Ptr^));
end;

procedure TTestGmpExtensions.randclear_test;
var state: MPRandState;
begin
  randinit_default(state);
  randclear(state);
end;

procedure TTestGmpExtensions.randseed_test;
var
  state: MPRandState;
  seed: MPInteger;
begin
  randinit_default(state);
  z_init_set_ui(seed, 0);
  randseed(state, seed);
end;

procedure TTestGmpExtensions.randseed_ui_test;
var state: MPRandState;
begin
  randinit_default(state);
  randseed_ui(state, 0);
end;

procedure TTestGmpExtensions.urandomb_ui_test;
const
  B = 8 * (sizeof(valuint) - 1);
  N = 1 shl B;
var
  state: MPRandState;
  r1, r2, r3: valuint;
begin
  randinit_default(state);
  r1 := urandomb_ui(state, B);
  r2 := urandomb_ui(state, B);
  r3 := urandomb_ui(state, B);
  assert((r1 < N) and (r2 < N) and (r3 < N) and ((r1 <> r2) or (r1 <> r3) or (r2 <> r3)));
end;

procedure TTestGmpExtensions.urandomm_ui_test;
const  N = high(valuint);
var
  state: MPRandState;
  r1, r2, r3: valuint;
begin
  randinit_default(state);
  r1 := urandomm_ui(state, N);
  r2 := urandomm_ui(state, N);
  r3 := urandomm_ui(state, N);
  assert((r1 < N) and (r2 < N) and (r3 < N) and ((r1 <> r2) or (r1 <> r3) or (r2 <> r3)));
end;

//procedure TTestGmpExtensions.asprintf_test;
//const
//  N = 123456;
//  S = '123456';
//var
//  z: MPInteger;
//  p: pchar;
//begin
//  z_init_set_ui(z, N);
//  assert(asprintf(p, Z_FMT, [@z]) = length(S));
//  assert(p = S);
//  freemem(p);
//  z_clear(z);
//end;
//
//procedure TTestGmpExtensions.asprintf_test2;
//const
//  N = 123456;
//  S = '123456';
//var
//  z: MPInteger;
//  p: pchar;
//begin
//  z_init_set_ui(z, N);
//  assert(asprintf(p, Z_FMT, @z) = length(S));
//  assert(p = S);
//  freemem(p);
//  z_clear(z);
//end;
//
//procedure TTestGmpExtensions.snprintf_test;
//const
//  N = 123456;
//  S = '123456';
//var
//  z: MPInteger;
//  buf: pchar;
//begin
//  z_init_set_ui(z, N);
//  getmem(buf, length(S) + 1);
//  assert(snprintf(buf, length(S) + 1, Z_FMT, [@z]) = length(S));
//  assert(buf = S);
//  freemem(buf);
//  z_clear(z);
//end;
//
//procedure TTestGmpExtensions.snprintf_test2;
//const
//  N = 123456;
//  S = '123456';
//var
//  z: MPInteger;
//  buf: pchar;
//begin
//  z_init_set_ui(z, N);
//  getmem(buf, length(S) + 1);
//  assert(snprintf(buf, length(S) + 1, Z_FMT, @z) = length(S));
//  assert(buf = S);
//  freemem(buf);
//  z_clear(z);
//end;
//
//procedure TTestGmpExtensions.sprintf_test;
//const
//  N = 123456;
//  S = '123456';
//var
//  z: MPInteger;
//  buf: pchar;
//begin
//  z_init_set_ui(z, N);
//  getmem(buf, length(S) + 1);
//  assert(sprintf(buf, Z_FMT, [@z]) = length(S));
//  assert(buf = S);
//  freemem(buf);
//  z_clear(z);
//end;
//
//procedure TTestGmpExtensions.sprintf_test2;
//const
//  N = 123456;
//  S = '123456';
//var
//  z: MPInteger;
//  buf: pchar;
//begin
//  z_init_set_ui(z, N);
//  getmem(buf, length(S) + 1);
//  assert(sprintf(buf, Z_FMT, @z) = length(S));
//  assert(buf = S);
//  freemem(buf);
//  z_clear(z);
//end;
//
//procedure TTestGmpExtensions.sscanf_test;
//const
//  N = 3;
//  D = 2;
//var q: mpq_t;
//begin
//  q_init(q);
//  assert(sscanf(pchar(inttostr(N) + '/' + inttostr(D)), Q_FMT, [@q]) = 1);
//  assert(q_cmp_ui(q, N, D) = 0);
//  q_clear(q);
//end;
//
//procedure TTestGmpExtensions.sscanf_test2;
//const
//  N = 3;
//  D = 2;
//var q: mpq_t;
//begin
//  q_init(q);
//  assert(sscanf(pchar(inttostr(N) + '/' + inttostr(D)), Q_FMT, @q) = 1);
//  assert(q_cmp_ui(q, N, D) = 0);
//  q_clear(q);
//end;

procedure TTestGmpExtensions.z_init_test;
var integer_: MPInteger;
begin
  z_init(integer_);
  assert(z_get_si(integer_) = 0);
end;

procedure TTestGmpExtensions.z_clear_test;
const N = 1000000;
var integer_: MPInteger;
begin
  z_init2(integer_, N);
  z_clear(integer_);
  assert(z_get_si(integer_) = 0);
end;

procedure TTestGmpExtensions.z_init2_test;
const N = 1000000;
var integer_: MPInteger;
begin
  z_init2(integer_, N);
  assert(z_get_si(integer_) = 0);
end;

procedure TTestGmpExtensions.z_init_set_si_test;
const N = -1000000;
var rop: MPInteger;
begin
  z_init_set_si(rop, N);
  assert(z_get_si(rop) = N);
end;

procedure TTestGmpExtensions.z_init_set_ui_test;
const N = 1000000;
var rop: MPInteger;
begin
  z_init_set_ui(rop, N);
  assert(z_get_ui(rop) = N);
end;

procedure TTestGmpExtensions.z_init_set_d_test;
const N = -1000000;
var rop: MPInteger;
begin
  z_init_set_d(rop, N);
  assert(z_get_si(rop) = N);
end;

procedure TTestGmpExtensions.z_init_set_test;
const N = -1000000;
var rop, op: MPInteger;
begin
  z_init_set_si(op, N);
  z_init_set(rop, op);
  assert(z_get_si(rop) = N);
end;

procedure TTestGmpExtensions.z_init_set_str_test;
const N = 1000000;
var rop: MPInteger;
begin
  assert(z_init_set_str(rop, IntToStr(N), BASE10));
  assert(z_get_si(rop) = N);
end;

procedure TTestGmpExtensions.z_realloc_test;
const N = 1000;
var integer_: MPInteger;
begin
  z_init(integer_);
  z_realloc(integer_, N);
end;

procedure TTestGmpExtensions.z_realloc2_test;
const N = 1000;
var integer_: MPInteger;
begin
  z_init(integer_);
  z_realloc2(integer_, N);
end;

procedure TTestGmpExtensions.z_getlimbn_test;
const N = 1234;
var op: MPInteger;
begin
  z_init_set_ui(op, N);
  assert(z_getlimbn(op, 0) = N);
end;

procedure TTestGmpExtensions.z_export_test;
type t = word;
const
  N = 1000000;
  BUF_HIGH = sizeof(N) div sizeof(t);
var
  export_op, import_op: MPInteger;
  buf: array[0..BUF_HIGH] of t;
  count: sizeuint;
begin
  z_init_set_si(export_op, N);
  z_init(import_op);
  z_export(buf, count, -1, sizeof(t), 0, 0, export_op);
  z_import(import_op, count, -1, sizeof(t), 0, 0, buf);
  assert(z_get_si(export_op) = z_get_si(import_op));
end;

procedure TTestGmpExtensions.z_import_test;
type t = word;
const
  N = 1000000;
  BUF_HIGH = sizeof(N) div sizeof(t);
var
  export_op, import_op: MPInteger;
  buf: array[0..BUF_HIGH] of t;
  count: sizeuint;
begin
  z_init_set_si(export_op, N);
  z_init(import_op);
  z_export(buf, count, -1, sizeof(t), 0, 0, export_op);
  z_import(import_op, count, -1, sizeof(t), 0, 0, buf);
  assert(z_get_si(export_op) = z_get_si(import_op));
end;

procedure TTestGmpExtensions.z_swap_test;
const
  ROP_1 = -1000;
  ROP_2 = 1000000;
var rop1, rop2: MPInteger;
begin
  z_init_set_si(rop1, ROP_1);
  z_init_set_si(rop2, ROP_2);
  z_swap(rop1, rop2);
  assert(z_get_si(rop1) = ROP_2);
  assert(z_get_si(rop2) = ROP_1);
end;

procedure TTestGmpExtensions.z_set_test;
const OP_ = 1000000;
var rop, op: MPInteger;
begin
  z_init(rop);
  z_init_set_si(op, OP_);
  z_set(rop, op);
  assert(z_get_si(rop) = OP_);
end;

procedure TTestGmpExtensions.z_set_d_test;
const OP_ = 1000000;
var rop: MPInteger;
begin
  z_init(rop);
  z_set_d(rop, OP_);
  assert(z_get_si(rop) = OP_);
end;

procedure TTestGmpExtensions.z_set_f_test;
const OP_ = -10;
var
  op: MPFloat;
  rop: MPInteger;
begin
  f_init_set_si(op, OP_);
  z_init(rop);
  z_set_f(rop, op);
  assert(z_get_si(rop) = OP_);
end;

procedure TTestGmpExtensions.z_set_q_test;
const OP_ = -10;
var
  op: MPRational;
  rop: MPInteger;
begin
  q_init(op);
  z_init(rop);
  q_set_si(op, OP_, 1);
  z_set_q(rop, op);
  assert(z_get_si(rop) = OP_);
end;

procedure TTestGmpExtensions.z_set_si_test;
const OP_ = -1000000;
var rop: MPInteger;
begin
  z_init(rop);
  z_set_si(rop, OP_);
  assert(z_get_si(rop) = OP_);
end;

procedure TTestGmpExtensions.z_set_str_test;
const OP_ = -1000000;
var rop: MPInteger;
begin
  z_init(rop);
  assert(z_set_str(rop, IntToStr(OP_), BASE10));
  assert(z_get_si(rop) = OP_);
end;

procedure TTestGmpExtensions.z_set_ui_test;
const OP_ = 1000000;
var rop: MPInteger;
begin
  z_init(rop);
  z_set_ui(rop, OP_);
  assert(z_get_si(rop) = OP_);
end;

procedure TTestGmpExtensions.z_get_d_test;
const N = -1000;
var op: MPInteger;
begin
  z_init_set_si(op, N);
  assert(z_get_d(op) = N);
end;

procedure TTestGmpExtensions.z_get_d_2exp_test;
const
  N_LG2 = 4;
  N = 1 shl N_LG2;
var
  op: MPInteger;
  exp: mp_exp_t;
begin
  z_init_set_si(op, N);
  assert(z_get_d_2exp(exp, op) = 1 / 2);
  assert(exp = N_LG2 + 1);
end;

procedure TTestGmpExtensions.z_get_si_test;
const N = -1000000;
var op: MPInteger;
begin
  z_init_set_si(op, N);
  assert(z_get_si(op) = N);
end;

procedure TTestGmpExtensions.z_get_str_test;
const N = -1000000;
var
  op: MPInteger;
  p: pchar;
  s, s0, s1: String;
begin
  z_init_set_si(op, N);
  s0 := inttostr(N);
  s := z_get_str(BASE10, op);
  assert(s = s0);
  p := z_get_str(nil, BASE10, op);
  assert(p = s0);
  freemem(p);
  setlength(s1, length(s0));
  assert(pointer(z_get_str(pchar(s1), BASE10, op)) = pointer(s1));
  assert(s1 = s0);
end;

procedure TTestGmpExtensions.z_get_ui_test;
const N = 1000000;
var op: MPInteger;
begin
  z_init_set_ui(op, N);
  assert(z_get_ui(op) = N);
end;

procedure TTestGmpExtensions.z_add_test;
const
  OP_1 = -1000;
  OP_2 = 1000000;
var rop, op1, op2, sum: MPInteger;
begin
  z_init(rop);
  z_init_set_si(op1, OP_1);
  z_init_set_si(op2, OP_2);
  z_add(rop, op1, op2);
  assert(z_get_si(rop) = OP_1 + OP_2);
  sum := z_add(op1, op2);
  assert(z_get_si(sum) = OP_1 + OP_2);
end;

procedure TTestGmpExtensions.z_add_ui_test;
const
  OP_1 = -1000;
  OP_2 = 1000000;
var rop, op1, sum: MPInteger;
begin
  z_init(rop);
  z_init_set_si(op1, OP_1);
  z_add_ui(rop, op1, OP_2);
  assert(z_get_si(rop) = OP_1 + OP_2);
  sum := z_add_ui(op1, OP_2);
  assert(z_get_si(sum) = OP_1 + OP_2);
end;

procedure TTestGmpExtensions.z_sub_test;
const
  OP_1 = -1000;
  OP_2 = 1000000;
var rop, op1, op2, diff: MPInteger;
begin
  z_init(rop);
  z_init_set_si(op1, OP_1);
  z_init_set_si(op2, OP_2);
  z_sub(rop, op1, op2);
  assert(z_get_si(rop) = OP_1 - OP_2);
  diff := z_sub(op1, op2);
  assert(z_get_si(diff) = OP_1 - OP_2);
end;

procedure TTestGmpExtensions.z_sub_ui_test;
const
  OP_1 = -1000;
  OP_2 = 1000000;
var rop, op1, diff: MPInteger;
begin
  z_init(rop);
  z_init_set_si(op1, OP_1);
  z_sub_ui(rop, op1, OP_2);
  assert(z_get_si(rop) = OP_1 - OP_2);
  diff := z_sub_ui(op1, OP_2);
  assert(z_get_si(diff) = OP_1 - OP_2);
end;

procedure TTestGmpExtensions.z_ui_sub_test;
const
  OP_1 = 1000;
  OP_2 = 1000000;
var rop, op2, diff: MPInteger;
begin
  z_init(rop);
  z_init_set_si(op2, OP_2);
  z_ui_sub(rop, OP_1, op2);
  assert(z_get_si(rop) = OP_1 - OP_2);
  diff := z_ui_sub(OP_1, op2);
  assert(z_get_si(diff) = OP_1 - OP_2);
end;

procedure TTestGmpExtensions.z_mul_test;
const
  OP_1 = -10;
  OP_2 = 1000;
var rop, op1, op2, prod: MPInteger;
begin
  z_init(rop);
  z_init_set_si(op1, OP_1);
  z_init_set_si(op2, OP_2);
  z_mul(rop, op1, op2);
  assert(z_get_si(rop) = OP_1 * OP_2);
  prod := z_mul(op1, op2);
  assert(z_get_si(prod) = OP_1 * OP_2);
end;

procedure TTestGmpExtensions.z_mul_si_test;
const
  OP_1 = 10;
  OP_2 = -1000;
var rop, op1, prod: MPInteger;
begin
  z_init(rop);
  z_init_set_si(op1, OP_1);
  z_mul_si(rop, op1, OP_2);
  assert(z_get_si(rop) = OP_1 * OP_2);
  prod := z_mul_si(op1, OP_2);
  assert(z_get_si(prod) = OP_1 * OP_2);
end;

procedure TTestGmpExtensions.z_mul_ui_test;
const
  OP_1 = -10;
  OP_2 = 1000;
var rop, op1, prod: MPInteger;
begin
  z_init(rop);
  z_init_set_si(op1, OP_1);
  z_mul_ui(rop, op1, OP_2);
  assert(z_get_si(rop) = OP_1 * OP_2);
  prod := z_mul_ui(op1, OP_2);
  assert(z_get_si(prod) = OP_1 * OP_2);
end;

procedure TTestGmpExtensions.z_addmul_test;
const
  ROP_ = 10;
  OP_1 = -100;
  OP_2 = 1000;
var rop, op1, op2: MPInteger;
begin
  z_init_set_si(rop, ROP_);
  z_init_set_si(op1, OP_1);
  z_init_set_si(op2, OP_2);
  z_addmul(rop, op1, op2);
  assert(z_get_si(rop) = ROP_ + OP_1 * OP_2);
end;

procedure TTestGmpExtensions.z_addmul_ui_test;
const
  ROP_ = 10;
  OP_1 = -100;
  OP_2 = 1000;
var rop, op1: MPInteger;
begin
  z_init_set_si(rop, ROP_);
  z_init_set_si(op1, OP_1);
  z_addmul_ui(rop, op1, OP_2);
  assert(z_get_si(rop) = ROP_ + OP_1 * OP_2);
end;

procedure TTestGmpExtensions.z_submul_test;
const
  ROP_ = 10;
  OP_1 = -100;
  OP_2 = 1000;
var rop, op1, op2: MPInteger;
begin
  z_init_set_si(rop, ROP_);
  z_init_set_si(op1, OP_1);
  z_init_set_si(op2, OP_2);
  z_submul(rop, op1, op2);
  assert(z_get_si(rop) = ROP_ - OP_1 * OP_2);
end;

procedure TTestGmpExtensions.z_submul_ui_test;
const
  ROP_ = 10;
  OP_1 = -100;
  OP_2 = 1000;
var rop, op1: MPInteger;
begin
  z_init_set_si(rop, ROP_);
  z_init_set_si(op1, OP_1);
  z_submul_ui(rop, op1, OP_2);
  assert(z_get_si(rop) = ROP_ - OP_1 * OP_2);
end;

procedure TTestGmpExtensions.z_mul_2exp_test;
const
  OP_1 = 10;
  OP_2 = 10;
var rop, op1, x: MPInteger;
begin
  z_init(rop);
  z_init_set_si(op1, OP_1);
  z_mul_2exp(rop, op1, OP_2);
  assert(z_get_si(rop) = OP_1 * (1 shl OP_2));
  x := z_mul_2exp(op1, OP_2);
  assert(z_get_si(x) = OP_1 * (1 shl OP_2));
end;

procedure TTestGmpExtensions.z_neg_test;
const OP_ = 1000;
var rop, op, x: MPInteger;
begin
  z_init(rop);
  z_init_set_si(op, OP_);
  z_neg(rop, op);
  assert(z_get_si(rop) = -OP_);
  x := z_neg(op);
  assert(z_get_si(x) = -OP_);
end;

procedure TTestGmpExtensions.z_abs_test;
const OP_ = -1000;
var rop, op, x: MPInteger;
begin
  z_init(rop);
  z_init_set_si(op, OP_);
  z_abs(rop, op);
  assert(z_get_si(rop) = abs(OP_));
  x := z_abs(op);
  assert(z_get_si(x) = abs(OP_));
end;

procedure TTestGmpExtensions.z_cdiv_q_test;
const
  N_ = -17;
  D_ = 4;
var q, n, d, q2: MPInteger;
begin
  z_init(q);
  z_init_set_si(n, N_);
  z_init_set_si(d, D_);
  z_cdiv_q(q, n, d);
  assert(z_get_si(q) = ceil(N_ / D_));
  q2 := z_cdiv_q(n, d);
  assert(z_get_si(q2) = ceil(N_ / D_));
end;

procedure TTestGmpExtensions.z_fdiv_q_test;
const
  N_ = -17;
  D_ = 4;
var q, n, d, q2: MPInteger;
begin
  z_init(q);
  z_init_set_si(n, N_);
  z_init_set_si(d, D_);
  z_fdiv_q(q, n, d);
  assert(z_get_si(q) = floor(N_ / D_));
  q2 := z_fdiv_q(n, d);
  assert(z_get_si(q2) = floor(N_ / D_));
end;

procedure TTestGmpExtensions.z_tdiv_q_test;
const
  N_ = -17;
  D_ = 4;
var q, n, d, q2: MPInteger;
begin
  z_init(q);
  z_init_set_si(n, N_);
  z_init_set_si(d, D_);
  z_tdiv_q(q, n, d);
  assert(z_get_si(q) = trunc(N_ / D_));
  q2 := z_tdiv_q(n, d);
  assert(z_get_si(q2) = trunc(N_ / D_));
end;

procedure TTestGmpExtensions.z_cdiv_q_2exp_test;
const
  N_ = -17;
  B_ = 2;
  D_ = 1 shl B_;
var q, n, q2: MPInteger;
begin
  z_init(q);
  z_init_set_si(n, N_);
  z_cdiv_q_2exp(q, n, B_);
  assert(z_get_si(q) = ceil(N_ / D_));
  q2 := z_cdiv_q_2exp(n, B_);
  assert(z_get_si(q2) = ceil(N_ / D_));
end;

procedure TTestGmpExtensions.z_fdiv_q_2exp_test;
const
  N_ = -17;
  B_ = 2;
  D_ = 1 shl B_;
var q, n, q2: MPInteger;
begin
  z_init(q);
  z_init_set_si(n, N_);
  z_fdiv_q_2exp(q, n, B_);
  assert(z_get_si(q) = floor(N_ / D_));
  q2 := z_fdiv_q_2exp(n, B_);
  assert(z_get_si(q2) = floor(N_ / D_));
end;

procedure TTestGmpExtensions.z_tdiv_q_2exp_test;
const
  N_ = -17;
  B_ = 2;
  D_ = 1 shl B_;
var q, n, q2: MPInteger;
begin
  z_init(q);
  z_init_set_si(n, N_);
  z_tdiv_q_2exp(q, n, B_);
  assert(z_get_si(q) = trunc(N_ / D_));
  q2 := z_tdiv_q_2exp(n, B_);
  assert(z_get_si(q2) = trunc(N_ / D_));
end;

procedure TTestGmpExtensions.z_cdiv_q_ui_test;
const
  N_ = -17;
  D_ = 4;
var
  q, n: MPInteger;
  ur: valuint;
begin
  z_init(q);
  z_init_set_si(n, N_);
  ur := z_cdiv_q_ui(q, n, D_);
  assert(z_get_si(q) = ceil(N_ / D_));
  assert(ur - abs(N_ - z_get_si(q) * D_) = 0);
end;

procedure TTestGmpExtensions.z_fdiv_q_ui_test;
const
  N_ = -17;
  D_ = 4;
var
  q, n: MPInteger;
  ur: valuint;
begin
  z_init(q);
  z_init_set_si(n, N_);
  ur := z_fdiv_q_ui(q, n, D_);
  assert(z_get_si(q) = floor(N_ / D_));
  assert(ur - abs(N_ - z_get_si(q) * D_) = 0);
end;

procedure TTestGmpExtensions.z_tdiv_q_ui_test;
const
  N_ = -17;
  D_ = 4;
var
  q, n: MPInteger;
  ur: valuint;
begin
  z_init(q);
  z_init_set_si(n, N_);
  ur := z_tdiv_q_ui(q, n, D_);
  assert(z_get_si(q) = trunc(N_ / D_));
  assert(ur - abs(N_ - z_get_si(q) * D_) = 0);
end;

procedure TTestGmpExtensions.z_cdiv_qr_test;
const
  N_ = -17;
  D_ = 4;
var q, r, n, d: MPInteger;
begin
  z_init(q);
  z_init(r);
  z_init_set_si(n, N_);
  z_init_set_si(d, D_);
  z_cdiv_qr(q, r, n, d);
  assert(z_get_si(q) = ceil(N_ / D_));
  assert(z_get_si(q) * D_ + z_get_si(r) = N_);
end;

procedure TTestGmpExtensions.z_fdiv_qr_test;
const
  N_ = -17;
  D_ = 4;
var q, r, n, d: MPInteger;
begin
  z_init(q);
  z_init(r);
  z_init_set_si(n, N_);
  z_init_set_si(d, D_);
  z_fdiv_qr(q, r, n, d);
  assert(z_get_si(q) = floor(N_ / D_));
  assert(z_get_si(q) * D_ + z_get_si(r) = N_);
end;

procedure TTestGmpExtensions.z_tdiv_qr_test;
const
  N_ = -17;
  D_ = 4;
var q, r, n, d: MPInteger;
begin
  z_init(q);
  z_init(r);
  z_init_set_si(n, N_);
  z_init_set_si(d, D_);
  z_tdiv_qr(q, r, n, d);
  assert(z_get_si(q) = trunc(N_ / D_));
  assert(z_get_si(q) * D_ + z_get_si(r) = N_);
end;

procedure TTestGmpExtensions.z_cdiv_qr_ui_test;
const
  N_ = -17;
  D_ = 4;
var
  q, r, n: MPInteger;
  ur: valuint;
begin
  z_init(q);
  z_init(r);
  z_init_set_si(n, N_);
  ur := z_cdiv_qr_ui(q, r, n, D_);
  assert(z_get_si(q) = ceil(N_ / D_));
  assert(z_get_si(q) * D_ + z_get_si(r) = N_);
  assert(ur - abs(z_get_si(r)) = 0);
end;

procedure TTestGmpExtensions.z_fdiv_qr_ui_test;
const
  N_ = -17;
  D_ = 4;
var
  q, r, n: MPInteger;
  ur: valuint;
begin
  z_init(q);
  z_init(r);
  z_init_set_si(n, N_);
  ur := z_fdiv_qr_ui(q, r, n, D_);
  assert(z_get_si(q) = floor(N_ / D_));
  assert(z_get_si(q) * D_ + z_get_si(r) = N_);
  assert(ur - abs(z_get_si(r)) = 0);
end;

procedure TTestGmpExtensions.z_tdiv_qr_ui_test;
const
  N_ = -17;
  D_ = 4;
var
  q, r, n: MPInteger;
  ur: valuint;
begin
  z_init(q);
  z_init(r);
  z_init_set_si(n, N_);
  ur := z_tdiv_qr_ui(q, r, n, D_);
  assert(z_get_si(q) = trunc(N_ / D_));
  assert(z_get_si(q) * D_ + z_get_si(r) = N_);
  assert(ur - abs(z_get_si(r)) = 0);
end;

procedure TTestGmpExtensions.z_cdiv_r_test;
const
  N_ = -17;
  D_ = 4;
var r, n, d, r2: MPInteger;
begin
  z_init(r);
  z_init_set_si(n, N_);
  z_init_set_si(d, D_);
  z_cdiv_r(r, n, d);
  assert(ceil(N_ / D_) * D_ + z_get_si(r) = N_);
  r2 := z_cdiv_r(n, d);
  assert(ceil(N_ / D_) * D_ + z_get_si(r2) = N_);
end;

procedure TTestGmpExtensions.z_fdiv_r_test;
const
  N_ = -17;
  D_ = 4;
var r, n, d, r2: MPInteger;
begin
  z_init(r);
  z_init_set_si(n, N_);
  z_init_set_si(d, D_);
  z_fdiv_r(r, n, d);
  assert(floor(N_ / D_) * D_ + z_get_si(r) = N_);
  r2 := z_fdiv_r(n, d);
  assert(floor(N_ / D_) * D_ + z_get_si(r2) = N_);
end;

procedure TTestGmpExtensions.z_tdiv_r_test;
const
  N_ = -17;
  D_ = 4;
var r, n, d, r2: MPInteger;
begin
  z_init(r);
  z_init_set_si(n, N_);
  z_init_set_si(d, D_);
  z_tdiv_r(r, n, d);
  assert(trunc(N_ / D_) * D_ + z_get_si(r) = N_);
  r2 := z_tdiv_r(n, d);
  assert(trunc(N_ / D_) * D_ + z_get_si(r2) = N_);
end;

procedure TTestGmpExtensions.z_cdiv_r_2exp_test;
const
  N_ = -17;
  B_ = 2;
  D_ = 1 shl B_;
var r, n, r2: MPInteger;
begin
  z_init(r);
  z_init_set_si(n, N_);
  z_cdiv_r_2exp(r, n, B_);
  assert(ceil(N_ / D_) * D_ + z_get_si(r) = N_);
  r2 := z_cdiv_r_2exp(n, B_);
  assert(ceil(N_ / D_) * D_ + z_get_si(r2) = N_);
end;

procedure TTestGmpExtensions.z_fdiv_r_2exp_test;
const
  N_ = -17;
  B_ = 2;
  D_ = 1 shl B_;
var r, n, r2: MPInteger;
begin
  z_init(r);
  z_init_set_si(n, N_);
  z_fdiv_r_2exp(r, n, B_);
  assert(floor(N_ / D_) * D_ + z_get_si(r) = N_);
  r2 := z_fdiv_r_2exp(n, B_);
  assert(floor(N_ / D_) * D_ + z_get_si(r2) = N_);
end;

procedure TTestGmpExtensions.z_tdiv_r_2exp_test;
const
  N_ = -17;
  B_ = 2;
  D_ = 1 shl B_;
var r, n, r2: MPInteger;
begin
  z_init(r);
  z_init_set_si(n, N_);
  z_tdiv_r_2exp(r, n, B_);
  assert(trunc(N_ / D_) * D_ + z_get_si(r) = N_);
  r2 := z_tdiv_r_2exp(n, B_);
  assert(trunc(N_ / D_) * D_ + z_get_si(r2) = N_);
end;

procedure TTestGmpExtensions.z_cdiv_r_ui_test;
const
  N_ = -17;
  D_ = 4;
var
  r, n: MPInteger;
  ur: valuint;
begin
  z_init(r);
  z_init_set_si(n, N_);
  ur := z_cdiv_r_ui(r, n, D_);
  assert(ceil(N_ / D_) * D_ + z_get_si(r) = N_);
  assert(ur - abs(z_get_si(r)) = 0);
end;

procedure TTestGmpExtensions.z_fdiv_r_ui_test;
const
  N_ = -17;
  D_ = 4;
var
  r, n: MPInteger;
  ur: valuint;
begin
  z_init(r);
  z_init_set_si(n, N_);
  ur := z_fdiv_r_ui(r, n, D_);
  assert(floor(N_ / D_) * D_ + z_get_si(r) = N_);
  assert(ur - abs(z_get_si(r)) = 0);
end;

procedure TTestGmpExtensions.z_tdiv_r_ui_test;
const
  N_ = -17;
  D_ = 4;
var
  r, n: MPInteger;
  ur: valuint;
begin
  z_init(r);
  z_init_set_si(n, N_);
  ur := z_tdiv_r_ui(r, n, D_);
  assert(trunc(N_ / D_) * D_ + z_get_si(r) = N_);
  assert(ur - abs(z_get_si(r)) = 0);
end;

procedure TTestGmpExtensions.z_cdiv_ui_test;
const
  N_ = -17;
  D_ = 4;
var n: MPInteger;
begin
  z_init_set_si(n, N_);
  assert(z_cdiv_ui(n, D_) - abs(N_ - ceil(N_ / D_) * D_) = 0);
end;

procedure TTestGmpExtensions.z_fdiv_ui_test;
const
  N_ = -17;
  D_ = 4;
var n: MPInteger;
begin
  z_init_set_si(n, N_);
  assert(z_fdiv_ui(n, D_) - abs(N_ - floor(N_ / D_) * D_) = 0);
end;

procedure TTestGmpExtensions.z_tdiv_ui_test;
const
  N_ = -17;
  D_ = 4;
var n: MPInteger;
begin
  z_init_set_si(n, N_);
  assert(z_tdiv_ui(n, D_) = abs(N_ - trunc(N_ / D_) * D_));
end;

procedure TTestGmpExtensions.z_mod_test;
const
  N_ = 17;
  D_ = -4;
var r, n, d, r2: MPInteger;
begin
  z_init(r);
  z_init_set_si(n, N_);
  z_init_set_si(d, D_);
  z_mod(r, n, d);
  assert(z_get_si(r) = N_ mod abs(D_));
  r2 := z_mod(n, d);
  assert(z_get_si(r2) = N_ mod abs(D_));
end;

procedure TTestGmpExtensions.z_divexact_test;
const
  N_ = -16;
  D_ = 4;
var q, n, d, q2: MPInteger;
begin
  z_init(q);
  z_init_set_si(n, N_);
  z_init_set_si(d, D_);
  z_divexact(q, n, d);
  assert(z_get_si(q) * D_ = N_);
  q2 := z_divexact(n, d);
  assert(z_get_si(q2) * D_ = N_);
end;

procedure TTestGmpExtensions.z_divexact_ui_test;
const
  N_ = -16;
  D_ = 4;
var q, n, q2: MPInteger;
begin
  z_init(q);
  z_init_set_si(n, N_);
  z_divexact_ui(q, n, D_);
  assert(z_get_si(q) * D_ = N_);
  q2 := z_divexact_ui(n, D_);
  assert(z_get_si(q2) * D_ = N_);
end;

procedure TTestGmpExtensions.z_divisible_p_test;
const
  N_ = -16;
  D_ = 4;
var n, d: MPInteger;
begin
  z_init_set_si(n, N_);
  z_init_set_si(d, D_);
  assert(z_divisible_p(n, d));
  z_set_si(n, z_get_si(n) + 1);
  assert(not z_divisible_p(n, d));
end;

procedure TTestGmpExtensions.z_divisible_ui_p_test;
const
  N_ = -16;
  D_ = 4;
var n: MPInteger;
begin
  z_init_set_si(n, N_);
  assert(z_divisible_ui_p(n, D_));
  z_set_si(n, z_get_si(n) + 1);
  assert(not z_divisible_ui_p(n, D_));
end;

procedure TTestGmpExtensions.z_divisible_2exp_p_test;
const
  N_ = -16;
  B_ = 2;
var n: MPInteger;
begin
  z_init_set_si(n, N_);
  assert(z_divisible_2exp_p(n, B_));
  z_set_si(n, z_get_si(n) + 1);
  assert(not z_divisible_ui_p(n, B_));
end;

procedure TTestGmpExtensions.z_congruent_p_test;
const
  N_ = 23;
  C_ = 6;
  D_ = 17;
var n, c, d: MPInteger;
begin
  z_init_set_si(n, N_);
  z_init_set_si(c, C_);
  z_init_set_si(d, D_);
  assert(z_congruent_p(n, c, d));
  z_set_si(n, z_get_si(n) + 1);
  assert(not z_congruent_p(n, c, d));
end;

procedure TTestGmpExtensions.z_congruent_2exp_p_test;
const
  N_ = 23;
  C_ = 7;
  B_ = 4;
var n, c: MPInteger;
begin
  z_init_set_si(n, N_);
  z_init_set_si(c, C_);
  assert(z_congruent_2exp_p(n, c, B_));
  z_set_si(n, z_get_si(n) + 1);
  assert(not z_congruent_2exp_p(n, c, B_));
end;

procedure TTestGmpExtensions.z_congruent_ui_p_test;
const
  N_ = 23;
  C_ = 6;
  D_ = 17;
var n: MPInteger;
begin
  z_init_set_si(n, N_);
  assert(z_congruent_ui_p(n, C_, D_));
  z_set_si(n, z_get_si(n) + 1);
  assert(not z_congruent_ui_p(n, C_, D_));
end;

procedure TTestGmpExtensions.z_powm_test;
const
  N_EXP = 3;
  N_MOD = 16;
  ROP_ = 8;
var rop, base, exp, mod_, r2: MPInteger;
begin
  z_init(rop);
  z_init_set_si(base, BASE10);
  z_init_set_si(exp, N_EXP);
  z_init_set_si(mod_, N_MOD);
  z_powm(rop, base, exp, mod_);
  assert(z_get_si(rop) = ROP_);
  r2 := z_powm(base, exp, mod_);
  assert(z_get_si(r2) = ROP_);
end;

procedure TTestGmpExtensions.z_powm_ui_test;
const
  N_EXP = 3;
  N_MOD = 16;
  ROP_ = 8;
var rop, base, mod_, r2: MPInteger;
begin
  z_init(rop);
  z_init_set_si(base, BASE10);
  z_init_set_si(mod_, N_MOD);
  z_powm_ui(rop, base, N_EXP, mod_);
  assert(z_get_si(rop) = ROP_);
  r2 := z_powm_ui(base, N_EXP, mod_);
  assert(z_get_si(r2) = ROP_);
end;

procedure TTestGmpExtensions.z_pow_ui_test;
const
  BASE_ = 10;
  EXP = 3;
var rop, base, r2: MPInteger;
begin
  z_init(rop);
  z_init_set_si(base, BASE_);
  z_pow_ui(rop, base, EXP);
  assert(z_get_si(rop) = BASE_ ** EXP);
  r2 := z_pow_ui(base, EXP);
  assert(z_get_si(r2) = BASE_ ** EXP);
end;

procedure TTestGmpExtensions.z_ui_pow_ui_test;
const
  BASE_ = 10;
  EXP = 3;
var rop, r2: MPInteger;
begin
  z_init(rop);
  z_ui_pow_ui(rop, BASE_, EXP);
  assert(z_get_si(rop) = BASE_ ** EXP);
  r2 := z_ui_pow_ui(BASE_, EXP);
  assert(z_get_si(r2) = BASE_ ** EXP);
end;

procedure TTestGmpExtensions.z_root_test;
const
  ROOT = 5;
  N_ = 3;
var rop, op: MPInteger;
begin
  z_init(rop);
  z_init_set_si(op, ROOT ** N_);
  assert(z_root(rop, op, N_));
  assert(z_get_si(rop) = ROOT);
  z_set_si(op, ROOT ** N_ + 1);
  assert(not z_root(rop, op, N_));
  assert(z_get_si(rop) = ROOT);
end;

procedure TTestGmpExtensions.z_rootrem_test;
const
  ROOT_ = 5;
  N_ = 3;
  REM_ = 1;
var root, rem, u: MPInteger;
begin
  assert(REM_ < ROOT_);
  z_init(root);
  z_init(rem);
  z_init_set_si(u, ROOT_ ** N_);
  z_rootrem(root, rem, u, N_);
  assert(z_get_si(root) = ROOT_);
  assert(z_get_si(rem) = 0);
  z_set_si(u, ROOT_ ** N_ + REM_);
  z_rootrem(root, rem, u, N_);
  assert(z_get_si(root) = ROOT_);
  assert(z_get_si(rem) = REM_);
end;

procedure TTestGmpExtensions.z_sqrt_test;
const ROOT = 5;
var rop, op, r2: MPInteger;
begin
  z_init(rop);
  z_init_set_si(op, ROOT ** 2);
  z_sqrt(rop, op);
  assert(z_get_si(rop) = ROOT);
  r2 := z_sqrt(op);
  assert(z_get_si(r2) = ROOT);
end;

procedure TTestGmpExtensions.z_sqrtrem_test;
const
  ROOT = 5;
  REM = 1;
var rop1, rop2, op: MPInteger;
begin
  z_init(rop1);
  z_init(rop2);
  z_init_set_si(op, ROOT ** 2 + REM);
  z_sqrtrem(rop1, rop2, op);
  assert(z_get_si(rop1) = ROOT);
  assert(z_get_si(rop2) = REM);
end;

procedure TTestGmpExtensions.z_perfect_power_p_test;
const
  ROOT = 3;
  EXP = 3;
var op: MPInteger;
begin
  z_init_set_si(op, ROOT ** EXP);
  assert(z_perfect_power_p(op));
  z_set_si(op, ROOT ** EXP + 1);
  assert(not z_perfect_power_p(op));
end;

procedure TTestGmpExtensions.z_perfect_square_p_test;
const ROOT = 3;
var op: MPInteger;
begin
  z_init_set_si(op, ROOT ** 2);
  assert(z_perfect_square_p(op));
  z_set_si(op, ROOT ** 2 or 2);
  assert(not z_perfect_square_p(op));
end;

procedure TTestGmpExtensions.z_probab_prime_p_test;
const
  N_ = 127;
  REPS = 5;
var n: MPInteger;
begin
  z_init_set_si(n, N_);
  assert(z_probab_prime_p(n, REPS) = 2);
  z_set_si(n, N_ + 1);
  assert(z_probab_prime_p(n, REPS) = 0);
end;

procedure TTestGmpExtensions.z_nextprime_test;
const
  PRIME3 = 5;
  PRIME4 = 7;
var rop, op, r2: MPInteger;
begin
  z_init(rop);
  z_init_set_si(op, PRIME3);
  z_nextprime(rop, op);
  assert(z_get_si(rop) = PRIME4);
  r2 := z_nextprime(op);
  assert(z_get_si(r2) = PRIME4);
end;

procedure TTestGmpExtensions.z_gcd_test;
const
  OP_1 = 42;
  OP_2 = 56;
  ROP_ = 14;
var rop, op1, op2, r2: MPInteger;
begin
  z_init(rop);
  z_init_set_si(op1, OP_1);
  z_init_set_si(op2, OP_2);
  z_gcd(rop, op1, op2);
  assert(z_get_si(rop) = ROP_);
  r2 := z_gcd(op1, op2);
  assert(z_get_si(r2) = ROP_);
end;

procedure TTestGmpExtensions.z_gcd_ui_test;
const
  OP_1 = 42;
  OP_2 = 56;
  ROP_ = 14;
var rop, op1: MPInteger;
begin
  z_init(rop);
  z_init_set_si(op1, OP_1);
  assert(z_gcd_ui(rop, op1, OP_2) = ROP_);
  assert(z_get_si(rop) = ROP_);
end;

procedure TTestGmpExtensions.z_gcdext_test;
const
  A_ = 42;
  B_ = 56;
  G_ = 14;
var g, s, t, a, b: MPInteger;
begin
  z_init(g);
  z_init(s);
  z_init(t);
  z_init_set_si(a, A_);
  z_init_set_si(b, B_);
  z_gcdext(g, s, t, a, b);
  assert(z_get_si(g) = G_);
  assert(A_ * z_get_si(s) + B_ * z_get_si(t) = G_);
end;

procedure TTestGmpExtensions.z_lcm_test;
const
  OP_1 = 21;
  OP_2 = 6;
  ROP_ = 42;
var rop, op1, op2, r2: MPInteger;
begin
  z_init(rop);
  z_init_set_si(op1, OP_1);
  z_init_set_si(op2, OP_2);
  z_lcm(rop, op1, op2);
  assert(z_get_si(rop) = ROP_);
  r2 := z_lcm(op1, op2);
  assert(z_get_si(r2) = ROP_);
end;

procedure TTestGmpExtensions.z_lcm_ui_test;
const
  OP_1 = 21;
  OP_2 = 6;
  ROP_ = 42;
var rop, op1, r2: MPInteger;
begin
  z_init(rop);
  z_init_set_si(op1, OP_1);
  z_lcm_ui(rop, op1, OP_2);
  assert(z_get_si(rop) = ROP_);
  r2 := z_lcm_ui(op1, OP_2);
  assert(z_get_si(r2) = ROP_);
end;

procedure TTestGmpExtensions.z_invert_test;
const
  OP_1 = 256;
  OP_2 = 337;
  ROP_ = 104;
var rop, op1, op2: MPInteger;
begin
  z_init(rop);
  z_init_set_si(op1, OP_1);
  z_init_set_si(op2, OP_2);
  assert(z_invert(rop, op1, op2) <> 0);
  assert(z_get_si(rop) = ROP_);
end;

procedure TTestGmpExtensions.z_jacobi_test;
const
  B0 = 11;
  A0 = 13 * B0;
  AM1 = 1001;
  BM1 = 9907;
  A1 = 4;
  B1 = 7;
var a, b: MPInteger;
begin
  z_init_set_si(a, A0);
  z_init_set_si(b, B0);
  assert(z_jacobi(a, b) = 0);
  z_set_si(a, AM1);
  z_set_si(b, BM1);
  assert(z_jacobi(a, b) = -1);
  z_set_si(a, A1);
  z_set_si(b, B1);
  assert(z_jacobi(a, b) = 1);
end;

procedure TTestGmpExtensions.z_kronecker_si_test;
const
  A_ = 8;
  B0 = 6;
  BM1 = 5;
  B1 = 7;
var a: MPInteger;
begin
  z_init_set_si(a, A_);
  assert(z_kronecker_si(a, B1) = 1);
  assert(z_kronecker_si(a, B0) = 0);
  assert(z_kronecker_si(a, BM1) = -1);
end;

procedure TTestGmpExtensions.z_kronecker_ui_test;
const
  A_ = 8;
  B0 = 6;
  BM1 = 5;
  B1 = 7;
var a: MPInteger;
begin
  z_init_set_si(a, A_);
  assert(z_kronecker_ui(a, B1) = 1);
  assert(z_kronecker_ui(a, B0) = 0);
  assert(z_kronecker_ui(a, BM1) = -1);
end;

procedure TTestGmpExtensions.z_si_kronecker_test;
const
  A_ = 8;
  B0 = 6;
  BM1 = 5;
  B1 = 7;
var b: MPInteger;
begin
  z_init_set_si(b, B1);
  assert(z_si_kronecker(A_, b) = 1);
  z_set_si(b, B0);
  assert(z_si_kronecker(A_, b) = 0);
  z_set_si(b, BM1);
  assert(z_si_kronecker(A_, b) = -1);
end;

procedure TTestGmpExtensions.z_ui_kronecker_test;
const
  A_ = 8;
  B0 = 6;
  BM1 = 5;
  B1 = 7;
var b: MPInteger;
begin
  z_init_set_si(b, B1);
  assert(z_ui_kronecker(A_, b) = 1);
  z_set_si(b, B0);
  assert(z_ui_kronecker(A_, b) = 0);
  z_set_si(b, BM1);
  assert(z_ui_kronecker(A_, b) = -1);
end;

procedure TTestGmpExtensions.z_remove_test;
const
  F_ = 5;
  OP_ = 3 * F_ * 7;
  ROP_ = OP_ div F_;
var rop, op, f: MPInteger;
begin
  z_init(rop);
  z_init_set_si(op, OP_);
  z_init_set_si(f, F_);
  assert(z_remove(rop, op, f) = 1);
  assert(z_get_si(rop) = ROP_);
end;

procedure TTestGmpExtensions.z_fac_ui_test;
const
  OP = 4;
  ROP_ = 2 * 3 * 4;
var rop, r2: MPInteger;
begin
  z_init(rop);
  z_fac_ui(rop, OP);
  assert(z_get_si(rop) = ROP_);
  r2 := z_fac_ui(OP);
  assert(z_get_si(r2) = ROP_);
end;

procedure TTestGmpExtensions.z_bin_ui_test;
const
  N_ = 7;
  K = 3;
  ROP_ = 35;
var rop, n, r2: MPInteger;
begin
  z_init(rop);
  z_init_set_si(n, N_);
  z_bin_ui(rop, n, K);
  assert(z_get_si(rop) = ROP_);
  r2 := z_bin_ui(n, K);
  assert(z_get_si(r2) = ROP_);
end;

procedure TTestGmpExtensions.z_bin_uiui_test;
const
  N = 7;
  K = 3;
  ROP_ = 35;
var rop, r2: MPInteger;
begin
  z_init(rop);
  z_bin_uiui(rop, N, K);
  assert(z_get_si(rop) = ROP_);
  r2 := z_bin_uiui(N, K);
  assert(z_get_si(r2) = ROP_);
end;

procedure TTestGmpExtensions.z_fib_ui_test;
const
  N = 10;
  FN_ = 55;
var fn, ff: MPInteger;
begin
  z_init(fn);
  z_fib_ui(fn, N);
  assert(z_get_si(fn) = FN_);
  ff := z_fib_ui(N);
  assert(z_get_si(ff) = FN_);
end;

procedure TTestGmpExtensions.z_fib2_ui_test;
const
  N = 10;
  FN_ = 55;
  FNSUB1_ = 34;
var fn, fnsub1, ff, ff1: MPInteger;
begin
  z_init(fn);
  z_init(fnsub1);
  z_fib2_ui(fn, fnsub1, N);
  assert(z_get_si(fn) = FN_);
  assert(z_get_si(fnsub1) = FNSUB1_);
  z_init(ff1);
  ff := z_fib2_ui(ff1, N);
  assert(z_get_si(ff) = FN_);
  assert(z_get_si(ff1) = FNSUB1_);
end;

procedure TTestGmpExtensions.z_lucnum_ui_test;
const
  N = 10;
  LN_ = 123;
var ln, l2: MPInteger;
begin
  z_init(ln);
  z_lucnum_ui(ln, N);
  assert(z_get_si(ln) = LN_);
  l2 := z_lucnum_ui(N);
  assert(z_get_si(l2) = LN_);
end;

procedure TTestGmpExtensions.z_lucnum2_ui_test;
const
  N = 10;
  LN_ = 123;
  LNSUB1_ = 76;
var ln, lnsub1, l2, l2s1: MPInteger;
begin
  z_init(ln);
  z_init(lnsub1);
  z_lucnum2_ui(ln, lnsub1, N);
  assert(z_get_si(ln) = LN_);
  assert(z_get_si(lnsub1) = LNSUB1_);
  z_init(l2s1);
  l2 := z_lucnum2_ui(l2s1, N);
  assert(z_get_si(l2) = LN_);
  assert(z_get_si(l2s1) = LNSUB1_);
end;

procedure TTestGmpExtensions.z_cmp_test;
const
  OP_1 = -10;
  OP_2 = OP_1 - 1;
var op1, op2: MPInteger;
begin
  z_init_set_si(op1, OP_1);
  z_init_set_si(op2, OP_2);
  assert(z_cmp(op1, op2) > 0);
  z_set_si(op2, OP_1);
  assert(z_cmp(op1, op2) = 0);
  z_set_si(op2, OP_1 + 1);
  assert(z_cmp(op1, op2) < 0);
end;

procedure TTestGmpExtensions.z_cmp_d_test;
const
  OP_1 = -10;
var op1: MPInteger;
begin
  z_init_set_si(op1, OP_1);
  assert(z_cmp_d(op1, OP_1 - 1) > 0);
  assert(z_cmp_d(op1, OP_1) = 0);
  assert(z_cmp_d(op1, OP_1 + 1) < 0);
end;

procedure TTestGmpExtensions.z_cmp_si_test;
const
  OP_1 = -10;
var op1: MPInteger;
begin
  z_init_set_si(op1, OP_1);
  assert(z_cmp_si(op1, OP_1 - 1) > 0);
  assert(z_cmp_si(op1, OP_1) = 0);
  assert(z_cmp_si(op1, OP_1 + 1) < 0);
end;

procedure TTestGmpExtensions.z_cmp_ui_test;
const
  OP_1 = 10;
var op1: MPInteger;
begin
  z_init_set_si(op1, OP_1);
  assert(z_cmp_ui(op1, OP_1 - 1) > 0);
  assert(z_cmp_ui(op1, OP_1) = 0);
  assert(z_cmp_ui(op1, OP_1 + 1) < 0);
end;

procedure TTestGmpExtensions.z_cmpabs_test;
const
  OP_1 = -10;
  OP_2 = -OP_1 - 1;
var op1, op2: MPInteger;
begin
  z_init_set_si(op1, OP_1);
  z_init_set_si(op2, -OP_2);
  assert(z_cmpabs(op1, op2) > 0);
  z_set_si(op2, -OP_1);
  assert(z_cmpabs(op1, op2) = 0);
  z_set_si(op2, -OP_1 + 1);
  assert(z_cmpabs(op1, op2) < 0);
end;

procedure TTestGmpExtensions.z_cmpabs_d_test;
const OP_1 = -10;
var op1: MPInteger;
begin
  z_init_set_si(op1, OP_1);
  assert(z_cmpabs_d(op1, -OP_1 - 1) > 0);
  assert(z_cmpabs_d(op1, -OP_1) = 0);
  assert(z_cmpabs_d(op1, -OP_1 + 1) < 0);
end;

procedure TTestGmpExtensions.z_cmpabs_ui_test;
const OP_1 = -10;
var op1: MPInteger;
begin
  z_init_set_si(op1, OP_1);
  assert(z_cmpabs_ui(op1, -OP_1 - 1) > 0);
  assert(z_cmpabs_ui(op1, -OP_1) = 0);
  assert(z_cmpabs_ui(op1, -OP_1 + 1) < 0);
end;

procedure TTestGmpExtensions.z_and_test;
const
  OP_1 = $c;
  OP_2 = $a;
var rop, op1, op2, r2: MPInteger;
begin
  z_init(rop);
  z_init_set_si(op1, OP_1);
  z_init_set_si(op2, OP_2);
  z_and(rop, op1, op2);
  assert(z_get_si(rop) = OP_1 and OP_2);
  r2 := z_and(op1, op2);
  assert(z_get_si(r2) = OP_1 and OP_2);
end;

procedure TTestGmpExtensions.z_ior_test;
const
  OP_1 = $c;
  OP_2 = $a;
var rop, op1, op2, r2: MPInteger;
begin
  z_init(rop);
  z_init_set_si(op1, OP_1);
  z_init_set_si(op2, OP_2);
  z_ior(rop, op1, op2);
  assert(z_get_si(rop) = OP_1 or OP_2);
  r2 := z_ior(op1, op2);
  assert(z_get_si(r2) = OP_1 or OP_2);
end;

procedure TTestGmpExtensions.z_xor_test;
const
  OP_1 = $c;
  OP_2 = $a;
var rop, op1, op2, r2: MPInteger;
begin
  z_init(rop);
  z_init_set_si(op1, OP_1);
  z_init_set_si(op2, OP_2);
  z_xor(rop, op1, op2);
  assert(z_get_si(rop) = OP_1 xor OP_2);
  r2 := z_xor(op1, op2);
  assert(z_get_si(r2) = OP_1 xor OP_2);
end;

procedure TTestGmpExtensions.z_com_test;
const
  OP_1 = 2;
var rop, op1, r2: MPInteger;
begin
  z_init(rop);
  z_init_set_si(op1, OP_1);
  z_com(rop, op1);
  assert(z_get_si(rop) = not OP_1 );
  r2 := z_com(op1);
  assert(z_get_si(r2) = not OP_1 );
end;

procedure TTestGmpExtensions.z_popcount_test;
const
  OP_ = $55AA;
  N = 8;
var op: MPInteger;
begin
  z_init_set_si(op, OP_);
  assert(z_popcount(op) = N);
end;

procedure TTestGmpExtensions.z_hamdist_test;
const
  OP_1 = $55;
  OP_2 = $7A;
  N = 5;
var op1, op2: MPInteger;
begin
  z_init_set_si(op1, OP_1);
  z_init_set_si(op2, OP_2);
  assert(z_hamdist(op1, op2) = N);
end;

procedure TTestGmpExtensions.z_scan0_test;
const
  OP_ = $F75;
  STARTING_BIT = 4;
  N = 7;
var op: MPInteger;
begin
  z_init_set_si(op, OP_);
  assert(z_scan0(op, STARTING_BIT) = N);
end;

procedure TTestGmpExtensions.z_scan1_test;
const
  OP_ = $85;
  STARTING_BIT = 4;
  N = 7;
var op: MPInteger;
begin
  z_init_set_si(op, OP_);
  assert(z_scan1(op, STARTING_BIT) = N);
end;

procedure TTestGmpExtensions.z_setbit_test;
const
  ROP_ = $F75;
  BIT_INDEX = 7;
var rop: MPInteger;
begin
  z_init_set_ui(rop, ROP_);
  z_setbit(rop, BIT_INDEX);
  assert(z_get_ui(rop) = ROP_ or (1 shl BIT_INDEX));
end;

procedure TTestGmpExtensions.z_clrbit_test;
const
  ROP_ = $F75;
  BIT_INDEX = 9;
var rop: MPInteger;
begin
  z_init_set_ui(rop, ROP_);
  z_clrbit(rop, BIT_INDEX);
  assert(z_get_ui(rop) = ROP_ and not (1 shl BIT_INDEX));
end;

procedure TTestGmpExtensions.z_combit_test;
const
  ROP_ = $F75;
  BIT_INDEX = 7;
var rop: MPInteger;
begin
  z_init_set_ui(rop, ROP_);
  z_combit(rop, BIT_INDEX);
  assert(z_get_ui(rop) = ROP_ xor (1 shl BIT_INDEX));
end;

procedure TTestGmpExtensions.z_tstbit_test;
const
  ROP_ = $F75;
  BIT_INDEX1 = 7;
  BIT_INDEX2 = 8;
var rop: MPInteger;
begin
  z_init_set_ui(rop, ROP_);
  assert(z_tstbit(rop, BIT_INDEX1) = longbool(ROP_ and (1 shl BIT_INDEX1)));
  assert(z_tstbit(rop, BIT_INDEX2) = longbool(ROP_ and (1 shl BIT_INDEX2)));
end;

procedure TTestGmpExtensions.z_urandomb_test;
const
  B = 8 * (sizeof(valuint) - 1);
  N = 1 shl B;
var
  rop, r2: MPInteger;
  state: MPRandState;
begin
  randinit_default(state);
  z_init(rop);
  z_urandomb(rop, state, B);
  assert(z_cmp_ui(rop, N) < 0);
  r2 := z_urandomb(state, B);
  assert(z_cmp_ui(r2, N) < 0);
end;

procedure TTestGmpExtensions.z_urandomm_test;
const
  N_ = 1000000;
var
  rop, n, r2: MPInteger;
  state: MPRandState;
begin
  randinit_default(state);
  z_init(rop);
  z_init_set_ui(n, N_);
  z_urandomm(rop, state, n);
  assert(z_cmp_ui(rop, N_) < 0);
  r2 := z_urandomm(state, n);
  assert(z_cmp_ui(r2, N_) < 0);
end;

procedure TTestGmpExtensions.z_rrandomb_test;
const
  B = 8 * sizeof(valuint) - 2;
  N = 1 shl B;
var
  rop, r2: MPInteger;
  state: MPRandState;
begin
  randinit_default(state);
  z_init(rop);
  z_rrandomb(rop, state, B);
  assert(z_cmp_ui(rop, N) < 0);
  r2 := z_rrandomb(state, B);
  assert(z_cmp_ui(r2, N) < 0);
end;

procedure TTestGmpExtensions.z_fits_ushort_p_test;
var op: MPInteger;
begin
  z_init_set_ui(op, high(word));
  assert(z_fits_ushort_p(op));
  z_add_ui(op, op, 1);
  assert(not z_fits_ushort_p(op));
end;

procedure TTestGmpExtensions.z_fits_sshort_p_test;
var op: MPInteger;
begin
  z_init_set_si(op, high(smallint));
  assert(z_fits_sshort_p(op));
  z_add_ui(op, op, 1);
  assert(not z_fits_sshort_p(op));
end;

procedure TTestGmpExtensions.z_fits_uint_p_test;
var op: MPInteger;
begin
  z_init_set_ui(op, high(cardinal));
  assert(z_fits_uint_p(op));
  z_add_ui(op, op, 1);
  assert(not z_fits_uint_p(op));
end;

procedure TTestGmpExtensions.z_fits_sint_p_test;
var op: MPInteger;
begin
  z_init_set_si(op, high(integer));
  assert(z_fits_sint_p(op));
  z_add_ui(op, op, 1);
  assert(not z_fits_sint_p(op));
end;

procedure TTestGmpExtensions.z_fits_ulong_p_test;
var op: MPInteger;
begin
  z_init_set_ui(op, high(valuint));
  assert(z_fits_ulong_p(op));
  z_add_ui(op, op, 1);
  assert(not z_fits_ulong_p(op));
end;

procedure TTestGmpExtensions.z_fits_slong_p_test;
var op: MPInteger;
begin
  z_init_set_si(op, high(valsint));
  assert(z_fits_slong_p(op));
  z_add_ui(op, op, 1);
  assert(not z_fits_slong_p(op));
end;

procedure TTestGmpExtensions.z_sizeinbase_test;
const
  OP_ = 1000000;
var rop: MPInteger;
begin
  z_init_set_ui(rop, OP_);
  assert(z_sizeinbase(rop, BASE10) - length(inttostr(OP_)) = 0);
end;

procedure TTestGmpExtensions.z_size_test;
var rop: MPInteger;
begin
  z_init(rop);
  assert(z_size(rop) = 0);
  z_add_ui(rop, rop, 1);
  assert(z_size(rop) = 1);
end;

procedure TTestGmpExtensions.q_init_test;
var rational: MPRational;
begin
  q_init(rational);
  assert(q_cmp_ui(rational, 0, 1) = 0);
end;

procedure TTestGmpExtensions.q_clear_test;
var rational: MPRational;
begin
  q_init(rational);
  q_clear(rational);
end;

procedure TTestGmpExtensions.q_set_ui_test;
const
  OP_1 = 13;
  OP_2 = 17;
var rational: MPRational;
begin
  q_init(rational);
  q_set_ui(rational, OP_1, OP_2);
  assert(q_cmp_ui(rational, OP_1, OP_2) = 0);
end;

procedure TTestGmpExtensions.q_set_si_test;
const
  OP_1 = -13;
  OP_2 = 17;
var rational: MPRational;
begin
  q_init(rational);
  q_set_si(rational, OP_1, OP_2);
  assert(q_cmp_si(rational, OP_1, OP_2) = 0);
end;

procedure TTestGmpExtensions.q_canonicalize_test;
const
  OP_1 = -13;
  OP_2 = 17;
  CF = 11;
var rational: MPRational;
begin
  q_init(rational);
  q_set_si(rational, CF * OP_1, CF * OP_2);
  q_canonicalize(rational);
  assert(q_cmp_si(rational, OP_1, OP_2) = 0);
end;

procedure TTestGmpExtensions.q_set_test;
const
  OP_1 = -13;
  OP_2 = 17;
var rational1, rational2: MPRational;
begin
  q_init(rational1);
  q_init(rational2);
  q_set_si(rational2, OP_1, OP_2);
  q_set(rational1, rational2);
  assert(q_cmp_si(rational1, OP_1, OP_2) = 0);
end;

procedure TTestGmpExtensions.q_set_z_test;
const
  OP_1 = -13;
var
  rational: MPRational;
  op: MPInteger;
begin
  q_init(rational);
  z_init_set_si(op, OP_1);
  q_set_z(rational, op);
  assert(q_cmp_si(rational, OP_1, 1) = 0);
end;

procedure TTestGmpExtensions.q_set_str_test;
const
  OP_1 = -13;
  OP_2 = 17;
var rational: MPRational;
begin
  q_init(rational);
  assert(q_set_str(rational, pchar(inttostr(OP_1) + '/' + inttostr(OP_2)), BASE10));
  assert(q_cmp_si(rational, OP_1, OP_2) = 0);
  assert(not q_set_str(rational, pchar(inttostr(OP_1) + '*' + inttostr(OP_2)), BASE10));
end;

procedure TTestGmpExtensions.q_swap_test;
const
  ROP_1N = -13;
  ROP_1D = 17;
  ROP_2N = -23;
  ROP_2D = 31;
var rop1, rop2: MPRational;
begin
  q_init(rop1);
  q_init(rop2);
  q_set_si(rop1, ROP_1N, ROP_1D);
  q_set_si(rop2, ROP_2N, ROP_2D);
  q_swap(rop1, rop2);
  assert(q_cmp_si(rop1, ROP_2N, ROP_2D) = 0);
  assert(q_cmp_si(rop2, ROP_1N, ROP_1D) = 0);
end;

procedure TTestGmpExtensions.q_get_d_test;
const
  OP_1 = -1;
  OP_2 = 2;
var op: MPRational;
begin
  q_init(op);
  q_set_si(op, OP_1, OP_2);
  assert(q_get_d(op) = OP_1 / OP_2);
end;

procedure TTestGmpExtensions.q_set_d_test;
const
  OP_1 = -1;
  OP_2 = 2;
var rop: MPRational;
begin
  q_init(rop);
  q_set_d(rop, OP_1 / OP_2);
  assert(q_cmp_si(rop, OP_1, OP_2) = 0);
end;

procedure TTestGmpExtensions.q_set_f_test;
const OP_ = -10;
var
  op: MPFloat;
  rop: MPRational;
begin
  f_init_set_si(op, OP_);
  q_init(rop);
  q_set_f(rop, op);
  assert(q_get_d(rop) = OP_);
end;

procedure TTestGmpExtensions.q_get_str_test;
const
  OP_1 = -1;
  OP_2 = 2;
var
  op: MPRational;
  p: pchar;
  s, s2: string;
begin
  q_init(op);
  q_set_si(op, OP_1, OP_2);
  s := q_get_str(BASE10, op);
  assert(s = inttostr(OP_1) + '/' + inttostr(OP_2));
  p := q_get_str(nil, BASE10, op);
  assert(p = inttostr(OP_1) + '/' + inttostr(OP_2));
  freemem(p);
  setlength(s2, length(inttostr(OP_1) + '/' + inttostr(OP_2)));
  assert(pointer(q_get_str(pchar(s2), BASE10, op)) = pointer(s2));
  assert(s2 = inttostr(OP_1) + '/' + inttostr(OP_2));
end;

procedure TTestGmpExtensions.q_add_test;
const
  N1 = 5;
  D1 = 2;
  N2 = -7;
  D2 = 3;
var sum, addend1, addend2, s2: MPRational;
begin
  q_init(sum);
  q_init(addend1);
  q_init(addend2);
  q_set_si(addend1, N1, D1);
  q_set_si(addend2, N2, D2);
  q_add(sum, addend1, addend2);
  assert(q_cmp_si(sum, N1 * D2 + N2 * D1, D1 * D2) = 0);
  s2 := q_add(addend1, addend2);
  assert(q_cmp_si(s2, N1 * D2 + N2 * D1, D1 * D2) = 0);
end;

procedure TTestGmpExtensions.q_sub_test;
const
  N1 = 5;
  D1 = 2;
  N2 = -7;
  D2 = 3;
var difference, minuend, subtrahend, diff2: MPRational;
begin
  q_init(difference);
  q_init(minuend);
  q_init(subtrahend);
  q_set_si(minuend, N1, D1);
  q_set_si(subtrahend, N2, D2);
  q_sub(difference, minuend, subtrahend);
  assert(q_cmp_si(difference, N1 * D2 - N2 * D1, D1 * D2) = 0);
  diff2 := q_sub(minuend, subtrahend);
  assert(q_cmp_si(diff2, N1 * D2 - N2 * D1, D1 * D2) = 0);
end;

procedure TTestGmpExtensions.q_mul_test;
const
  N1 = 5;
  D1 = 2;
  N2 = -7;
  D2 = 3;
var product, multiplier, multiplicant, p2: MPRational;
begin
  q_init(product);
  q_init(multiplier);
  q_init(multiplicant);
  q_set_si(multiplier, N1, D1);
  q_set_si(multiplicant, N2, D2);
  q_mul(product, multiplier, multiplicant);
  assert(q_cmp_si(product, N1 * N2, D1 * D2) = 0);
  p2 := q_mul(multiplier, multiplicant);
  assert(q_cmp_si(p2, N1 * N2, D1 * D2) = 0);
end;

procedure TTestGmpExtensions.q_mul_2exp_test;
const
  N1 = 5;
  D1 = 3;
  OP_2 = 2;
var rop, op1, r2: MPRational;
begin
  q_init(rop);
  q_init(op1);
  q_set_si(op1, N1, D1);
  q_mul_2exp(rop, op1, OP_2);
  assert(q_cmp_si(rop, N1 * (1 shl OP_2), D1) = 0);
  r2 := q_mul_2exp(op1, OP_2);
  assert(q_cmp_si(r2, N1 * (1 shl OP_2), D1) = 0);
end;

procedure TTestGmpExtensions.q_div_test;
const
  N1 = 5;
  D1 = 2;
  N2 = -7;
  D2 = 3;
var quotient, dividend, divisor, q2: MPRational;
begin
  q_init(quotient);
  q_init(dividend);
  q_init(divisor);
  q_set_si(dividend, N1, D1);
  q_set_si(divisor, N2, D2);
  q_div(quotient, dividend, divisor);
  assert(q_cmp_si(quotient, -N1 * D2, -D1 * N2) = 0);
  q2 := q_div(dividend, divisor);
  assert(q_cmp_si(q2, -N1 * D2, -D1 * N2) = 0);
end;

procedure TTestGmpExtensions.q_div_2exp_test;
const
  N1 = 5;
  D1 = 3;
  OP_2 = 2;
var rop, op1, r2: MPRational;
begin
  q_init(rop);
  q_init(op1);
  q_set_si(op1, N1, D1);
  q_div_2exp(rop, op1, OP_2);
  assert(q_cmp_si(rop, N1, D1 * (1 shl OP_2)) = 0);
  r2 := q_div_2exp(op1, OP_2);
  assert(q_cmp_si(r2, N1, D1 * (1 shl OP_2)) = 0);
end;

procedure TTestGmpExtensions.q_neg_test;
const
  N1 = -5;
  D1 = 3;
var negated_operand, operand, n2: MPRational;
begin
  q_init(negated_operand);
  q_init(operand);
  q_set_si(operand, N1, D1);
  q_neg(negated_operand, operand);
  assert(q_cmp_si(negated_operand, -N1, D1) = 0);
  n2 := q_neg(operand);
  assert(q_cmp_si(n2, -N1, D1) = 0);
end;

procedure TTestGmpExtensions.q_abs_test;
const
  N1 = 5;
  D1 = 3;
var rop, op, r2: MPRational;
begin
  q_init(rop);
  q_init(op);
  q_set_si(op, -N1, D1);
  q_abs(rop, op);
  assert(q_cmp_si(rop, N1, D1) = 0);
  r2 := q_abs(op);
  assert(q_cmp_si(r2, N1, D1) = 0);
end;

procedure TTestGmpExtensions.q_inv_test;
const
  N1 = -5;
  D1 = 3;
var inverted_number, number, i2: MPRational;
begin
  q_init(inverted_number);
  q_init(number);
  q_set_si(number, N1, D1);
  q_inv(inverted_number, number);
  assert(q_cmp_si(inverted_number, -D1, -N1) = 0);
  i2 := q_inv(number);
  assert(q_cmp_si(i2, -D1, -N1) = 0);
end;

procedure TTestGmpExtensions.q_cmp_test;
const
  N1 = -7;
  D1 = 5;
var op1, op2: MPRational;
begin
  q_init(op1);
  q_init(op2);
  q_set_si(op1, N1, D1);
  q_set_si(op2, N1, D1);
  assert(q_cmp(op1, op2) = 0);
  q_set_si(op1, N1 + 1, D1);
  assert(q_cmp(op1, op2) > 0);
  q_set_si(op1, N1 - 1, D1);
  assert(q_cmp(op1, op2) < 0);
end;

procedure TTestGmpExtensions.q_cmp_si_test;
const
  N1 = -7;
  D1 = 5;
var op1: MPRational;
begin
  q_init(op1);
  q_set_si(op1, N1, D1);
  assert(q_cmp_si(op1, N1, D1) = 0);
  assert(q_cmp_si(op1, N1 - 1, D1) > 0);
  assert(q_cmp_si(op1, N1 + 1, D1) < 0);
end;

procedure TTestGmpExtensions.q_cmp_ui_test;
const
  N1 = 7;
  D1 = 5;
var op1: MPRational;
begin
  q_init(op1);
  q_set_si(op1, N1, D1);
  assert(q_cmp_ui(op1, N1, D1) = 0);
  assert(q_cmp_ui(op1, N1 - 1, D1) > 0);
  assert(q_cmp_ui(op1, N1 + 1, D1) < 0);
end;

procedure TTestGmpExtensions.q_equal_test;
const
  N1 = -7;
  D1 = 5;
var op1, op2: MPRational;
begin
  q_init(op1);
  q_init(op2);
  q_set_si(op1, N1, D1);
  q_set_si(op2, N1, D1);
  assert(q_equal(op1, op2));
  q_set_si(op1, N1 + 1, D1);
  assert(not q_equal(op1, op2));
  q_set_si(op1, N1 - 1, D1);
  assert(not q_equal(op1, op2));
end;

procedure TTestGmpExtensions.q_get_num_test;
const
  N1 = -7;
  D1 = 5;
var
  rational: MPRational;
  numerator, n2: MPInteger;
begin
  q_init(rational);
  z_init(numerator);
  q_set_si(rational, N1, D1);
  q_get_num(numerator, rational);
  assert(z_get_si(numerator) = N1);
  n2 := q_get_num(rational);
  assert(z_get_si(n2) = N1);
end;

procedure TTestGmpExtensions.q_get_den_test;
const
  N1 = -7;
  D1 = 5;
var
  rational: MPRational;
  denominator, d2: MPInteger;
begin
  q_init(rational);
  z_init(denominator);
  q_set_si(rational, N1, D1);
  q_get_den(denominator, rational);
  assert(z_get_si(denominator) = D1);
  d2 := q_get_den(rational);
  assert(z_get_si(d2) = D1);
end;

procedure TTestGmpExtensions.q_set_num_test;
const
  N1 = -7;
  D1 = 5;
  N2 = 3;
var
  rational: MPRational;
  numerator: MPInteger;
begin
  q_init(rational);
  z_init_set_si(numerator, N2);
  q_set_si(rational, N1, D1);
  q_set_num(rational, numerator);
  assert(q_cmp_si(rational, N2, D1) = 0);
end;

procedure TTestGmpExtensions.q_set_den_test;
const
  N1 = -7;
  D1 = 5;
  D2 = 3;
var
  rational: MPRational;
  denominator: MPInteger;
begin
  q_init(rational);
  z_init_set_si(denominator, D2);
  q_set_si(rational, N1, D1);
  q_set_den(rational, denominator);
  assert(q_cmp_si(rational, N1, D2) = 0);
end;

procedure TTestGmpExtensions.f_get_default_prec_test;
begin
  assert(f_get_default_prec > 0);
end;

procedure TTestGmpExtensions.f_set_default_prec_test;
var prec: valuint;
begin
  prec := f_get_default_prec;
  f_set_default_prec(2 * prec);
  assert(f_get_default_prec  = 2 * prec);
  f_set_default_prec(prec);
end;

procedure TTestGmpExtensions.f_init_test;
var x: MPFloat;
begin
  f_init(x);
  assert(f_get_prec(x) = f_get_default_prec);
end;

procedure TTestGmpExtensions.f_init2_test;
var x: MPFloat;
begin
  f_init2(x, 2 * f_get_default_prec);
  assert(f_get_prec(x) = 2 * f_get_default_prec);
end;

procedure TTestGmpExtensions.f_clear_test;
var x: MPFloat;
begin
  f_init(x);
  f_clear(x);
end;

procedure TTestGmpExtensions.f_get_prec_test;
var x: MPFloat;
begin
  f_init(x);
  f_set_prec(x, 2 * f_get_default_prec);
  assert(f_get_prec(x) = 2 * f_get_default_prec);
end;

procedure TTestGmpExtensions.f_set_prec_test;
var x: MPFloat;
begin
  f_init(x);
  f_set_prec(x, 2 * f_get_default_prec);
  assert(f_get_prec(x) = 2 * f_get_default_prec);
end;

procedure TTestGmpExtensions.f_set_prec_raw_test;
const N = 10;
var x: MPFloat;
begin
  f_init2(x, N * f_get_default_prec);
  f_set_prec_raw(x, f_get_default_prec);
  f_set_prec_raw(x, N * f_get_default_prec);
end;

procedure TTestGmpExtensions.f_set_q_test;
const OP_ = -10;
var
  op: MPRational;
  rop: MPFloat;
begin
  q_init(op);
  f_init(rop);
  q_set_si(op, OP_, 1);
  f_set_q(rop, op);
  assert(f_get_si(rop) = OP_);
end;

procedure TTestGmpExtensions.f_set_ui_test;
const OP = 1000000;
var rop: MPFloat;
begin
  f_init(rop);
  f_set_ui(rop, OP);
  assert(f_get_ui(rop) = OP);
end;

procedure TTestGmpExtensions.f_get_ui_test;
const OP = 1000000;
var rop: MPFloat;
begin
  f_init(rop);
  f_set_ui(rop, OP);
  assert(f_get_ui(rop) = OP);
end;

procedure TTestGmpExtensions.f_set_si_test;
const OP = -1000000;
var rop: MPFloat;
begin
  f_init(rop);
  f_set_si(rop, OP);
  assert(f_get_si(rop) = OP);
end;

procedure TTestGmpExtensions.f_get_si_test;
const OP = -1000000;
var rop: MPFloat;
begin
  f_init(rop);
  f_set_si(rop, OP);
  assert(f_get_si(rop) = OP);
end;

procedure TTestGmpExtensions.f_set_test;
const N = -1000000;
var rop, op: MPFloat;
begin
  f_init(rop);
  f_init_set_si(op, N);
  f_set(rop, op);
  assert(f_get_si(rop) = N);
end;

procedure TTestGmpExtensions.f_set_str_test;
const N = -123;
var rop: MPFloat;
begin
  f_init(rop);
  assert(f_set_str(rop, inttostr(N), BASE10));
  assert(f_get_si(rop) = N);
end;

procedure TTestGmpExtensions.f_swap_test;
const
  ROP_1 = -13;
  ROP_2 = -23;
var rop1, rop2: MPFloat;
begin
  f_init_set_si(rop1, ROP_1);
  f_init_set_si(rop2, ROP_2);
  f_swap(rop1, rop2);
  assert(f_get_si(rop1) =  ROP_2);
  assert(f_get_si(rop2) = ROP_1);
end;

procedure TTestGmpExtensions.f_get_d_test;
const N = -1.5;
var rop: MPFloat;
begin
  f_init_set_d(rop, N);
  assert(f_get_d(rop) = N);
end;

procedure TTestGmpExtensions.f_set_d_test;
const N = -1.5;
var rop: MPFloat;
begin
  f_init(rop);
  f_set_d(rop, N);
  assert(f_get_d(rop) = N);
end;

procedure TTestGmpExtensions.f_set_z_test;
const
  OP_1 = -13;
var
  rop: MPFloat;
  op: MPInteger;
begin
  f_init(rop);
  z_init_set_si(op, OP_1);
  f_set_z(rop, op);
  assert(f_get_si(rop) = OP_1);
end;

procedure TTestGmpExtensions.f_get_d_2exp_test;
const
  M = 0.5;
  E = 4;
  N = (1 shl E) div 2;
var
  rop: MPFloat;
  exp: valsint;
begin
  f_init_set_d(rop, N);
  exp := -1;
  assert(f_get_d_2exp(exp, rop) = M);
  assert(exp = E);
end;

procedure TTestGmpExtensions.f_get_str_test;
const
  N = 3.1416;
  S = '31416';
  E = 1;
var
  op: MPFloat;
  p: pchar;
  exp: mp_exp_t;
  s1: string;
begin
  f_init_set_d(op, N);
  p := f_get_str(nil, exp, BASE10, length(S), op);
  assert(p = S);
  assert(exp = E);
  freemem(p);
  setlength(s1, length(S));
  assert(pointer(f_get_str(pchar(s1), exp, BASE10, length(s), op)) = pointer(s1));
  assert(s1 = S);
  s1 := f_get_str(exp, BASE10, length(S), op);
  assert(s1 = S);
end;

procedure TTestGmpExtensions.f_add_test;
const
  OP1_ = 1;
  OP2_ = 2;
var rop, op1, op2, r2: MPFloat;
begin
  f_init(rop);
  f_init_set_d(op1, OP1_);
  f_init_set_d(op2, OP2_);
  f_add(rop, op1, op2);
  assert(f_get_d(rop) = OP1_ + OP2_);
  r2 := f_add(op1, op2);
  assert(f_get_d(r2) = OP1_ + OP2_);
end;

procedure TTestGmpExtensions.f_add_ui_test;
const
  OP1_ = 1;
  OP2_ = 2;
var rop, op1, r2: MPFloat;
begin
  f_init(rop);
  f_init_set_d(op1, OP1_);
  f_add_ui(rop, op1, OP2_);
  assert(f_get_d(rop) = OP1_ + OP2_);
  r2 := f_add_ui(op1, OP2_);
  assert(f_get_d(r2) = OP1_ + OP2_);
end;

procedure TTestGmpExtensions.f_sub_test;
const
  OP1_ = 3;
  OP2_ = 1;
var rop, op1, op2, r2: MPFloat;
begin
  f_init(rop);
  f_init_set_d(op1, OP1_);
  f_init_set_d(op2, OP2_);
  f_sub(rop, op1, op2);
  assert(f_get_d(rop) = OP1_ - OP2_);
  r2 := f_sub(op1, op2);
  assert(f_get_d(r2) = OP1_ - OP2_);
end;

procedure TTestGmpExtensions.f_sub_ui_test;
const
  OP1_ = 3;
  OP2_ = 1;
var rop, op1, r2: MPFloat;
begin
  f_init(rop);
  f_init_set_d(op1, OP1_);
  f_sub_ui(rop, op1, OP2_);
  assert(f_get_d(rop) = OP1_ - OP2_);
  r2 := f_sub_ui(op1, OP2_);
  assert(f_get_d(r2) = OP1_ - OP2_);
end;

procedure TTestGmpExtensions.f_ui_sub_test;
const
  OP1_ = 3;
  OP2_ = 1;
var rop, op2, r2: MPFloat;
begin
  f_init(rop);
  f_init_set_d(op2, OP2_);
  f_ui_sub(rop, OP1_, op2);
  assert(f_get_d(rop) = OP1_ - OP2_);
  r2 := f_ui_sub(OP1_, op2);
  assert(f_get_d(r2) = OP1_ - OP2_);
end;

procedure TTestGmpExtensions.f_mul_test;
const
  OP1_ = 2;
  OP2_ = 3;
var rop, op1, op2, r2: MPFloat;
begin
  f_init(rop);
  f_init_set_d(op1, OP1_);
  f_init_set_d(op2, OP2_);
  f_mul(rop, op1, op2);
  assert(f_get_d(rop) = OP1_ * OP2_);
  r2 := f_mul(op1, op2);
  assert(f_get_d(r2) = OP1_ * OP2_);
end;

procedure TTestGmpExtensions.f_mul_ui_test;
const
  OP1_ = 2;
  OP2_ = 3;
var rop, op1, r2: MPFloat;
begin
  f_init(rop);
  f_init_set_d(op1, OP1_);
  f_mul_ui(rop, op1, OP2_);
  assert(f_get_d(rop) = OP1_ * OP2_);
  r2 := f_mul_ui(op1, OP2_);
  assert(f_get_d(r2) = OP1_ * OP2_);
end;

procedure TTestGmpExtensions.f_mul_2exp_test;
const
  OP1_ = 3;
  OP2_ = 4;
var rop, op1, r2: MPFloat;
begin
  f_init(rop);
  f_init_set_d(op1, OP1_);
  f_mul_2exp(rop, op1, OP2_);
  assert(f_get_d(rop) = OP1_ * (1 shl OP2_));
  r2 := f_mul_2exp(op1, OP2_);
  assert(f_get_d(r2) = OP1_ * (1 shl OP2_));
end;

procedure TTestGmpExtensions.f_div_test;
const
  OP1_ = 6;
  OP2_ = 2;
var rop, op1, op2, r2: MPFloat;
begin
  f_init(rop);
  f_init_set_d(op1, OP1_);
  f_init_set_d(op2, OP2_);
  f_div(rop, op1, op2);
  assert(f_get_d(rop) = OP1_ / OP2_);
  r2 := f_div(op1, op2);
  assert(f_get_d(r2) = OP1_ / OP2_);
end;

procedure TTestGmpExtensions.f_div_ui_test;
const
  OP1_ = 6;
  OP2_ = 2;
var rop, op1, r2: MPFloat;
begin
  f_init(rop);
  f_init_set_d(op1, OP1_);
  f_div_ui(rop, op1, OP2_);
  assert(f_get_d(rop) = OP1_ / OP2_);
  r2 := f_div_ui(op1, OP2_);
  assert(f_get_d(r2) = OP1_ / OP2_);
end;

procedure TTestGmpExtensions.f_ui_div_test;
const
  OP1_ = 6;
  OP2_ = 2;
var rop, op2, r2: MPFloat;
begin
  f_init(rop);
  f_init_set_si(op2, OP2_);
  f_ui_div(rop, OP1_, op2);
  assert(f_get_d(rop) = OP1_ / OP2_);
  r2 := f_ui_div(OP1_, op2);
  assert(f_get_d(r2) = OP1_ / OP2_);
end;

procedure TTestGmpExtensions.f_div_2exp_test;
const
  OP1_ = 16;
  OP2_ = 2;
var rop, op1, r2: MPFloat;
begin
  f_init(rop);
  f_init_set_d(op1, OP1_);
  f_div_2exp(rop, op1, OP2_);
  assert(f_get_d(rop) = OP1_ / (1 shl OP2_));
  r2 := f_div_2exp(op1, OP2_);
  assert(f_get_d(r2) = OP1_ / (1 shl OP2_));
end;

procedure TTestGmpExtensions.f_sqrt_test;
const
  OP_ = 4;
var rop, op, r2: MPFloat;
begin
  f_init(rop);
  f_init_set_d(op, OP_);
  f_sqrt(rop, op);
  assert(f_get_d(rop) = sqrt(OP_));
  r2 := f_sqrt(op);
  assert(f_get_d(r2) = sqrt(OP_));
end;

procedure TTestGmpExtensions.f_sqrt_ui_test;
const
  OP_ = 4;
var rop, r2: MPFloat;
begin
  f_init(rop);
  f_sqrt_ui(rop, OP_);
  assert(f_get_d(rop) = sqrt(OP_));
  r2 := f_sqrt_ui(OP_);
  assert(f_get_d(r2) = sqrt(OP_));
end;

procedure TTestGmpExtensions.f_pow_ui_test;
const
  OP1_ = 3;
  OP2_ = 2;
var rop, op1, r2: MPFloat;
begin
  f_init(rop);
  f_init_set_d(op1, OP1_);
  f_pow_ui(rop, op1, OP2_);
  assert(f_get_d(rop) = OP1_ ** OP2_);
  r2 := f_pow_ui(op1, OP2_);
  assert(f_get_d(r2) = OP1_ ** OP2_);
end;

procedure TTestGmpExtensions.f_neg_test;
const
  OP_ = 4;
var rop, op, r2: MPFloat;
begin
  f_init(rop);
  f_init_set_d(op, OP_);
  f_neg(rop, op);
  assert(f_get_d(rop) = -OP_);
  r2 := f_neg(op);
  assert(f_get_d(r2) = -OP_);
end;

procedure TTestGmpExtensions.f_abs_test;
const OP_ = -4;
var rop, op, r2: MPFloat;
begin
  f_init(rop);
  f_init_set_d(op, OP_);
  f_abs(rop, op);
  assert(f_get_d(rop) = -OP_);
  r2 := f_abs(op);
  assert(f_get_d(r2) = -OP_);
end;

procedure TTestGmpExtensions.f_cmp_test;
const OP_1 = -10;
var op1, op2: MPFloat;
begin
  f_init_set_si(op1, OP_1);
  f_init_set_si(op2, OP_1);
  assert(f_cmp(op1, op2) = 0);
  f_set_si(op2, OP_1 + 1);
  assert(f_cmp(op1, op2) < 0);
  f_set_si(op2, OP_1 - 1);
  assert(f_cmp(op1, op2) > 0);
end;

procedure TTestGmpExtensions.f_cmp_d_test;
const OP_ = -10;
var op: MPFloat;
begin
  f_init_set_si(op, OP_);
  assert(f_cmp_d(op, OP_) = 0);
  assert(f_cmp_d(op, OP_ + 1) < 0);
  assert(f_cmp_d(op, OP_ - 1) > 0);
end;

procedure TTestGmpExtensions.f_cmp_si_test;
const OP_ = -10;
var op: MPFloat;
begin
  f_init_set_si(op, OP_);
  assert(f_cmp_si(op, OP_) = 0);
  assert(f_cmp_si(op, OP_ + 1) < 0);
  assert(f_cmp_si(op, OP_ - 1) > 0);
end;

procedure TTestGmpExtensions.f_cmp_ui_test;
const OP_ = 10;
var op: MPFloat;
begin
  f_init_set_si(op, OP_);
  assert(f_cmp_ui(op, OP_) = 0);
  assert(f_cmp_ui(op, OP_ + 1) < 0);
  assert(f_cmp_ui(op, OP_ - 1) > 0);
end;

procedure TTestGmpExtensions.f_eq_test;
const
  OP_1 = 10;
  OP_3 = 8;
var op1, op2: MPFloat;
begin
  f_init_set_si(op1, OP_1);
  f_init_set_si(op2, OP_1);
  assert(f_eq(op1, op2, OP_3));
end;

procedure TTestGmpExtensions.f_reldiff_test;
const
  OP1_ = 4;
  OP2_ = 2;
var rop, op1, op2, r2: MPFloat;
begin
  f_init(rop);
  f_init_set_d(op1, OP1_);
  f_init_set_d(op2, OP2_);
  f_reldiff(rop, op1, op2);
  assert(f_get_d(rop) = abs(OP1_ - OP2_) / OP1_);
  r2 := f_reldiff(op1, op2);
  assert(f_get_d(r2) = abs(OP1_ - OP2_) / OP1_);
end;

procedure TTestGmpExtensions.f_ceil_test;
const N = 3.1;
var rop, op, r2: MPFloat;
begin
  f_init(rop);
  f_init_set_d(op, N);
  f_ceil(rop, op);
  assert(f_get_d(rop) = ceil(N));
  r2 := f_ceil(op);
  assert(f_get_d(r2) = ceil(N));
end;

procedure TTestGmpExtensions.f_floor_test;
const N = 3.9;
var rop, op, r2: MPFloat;
begin
  f_init(rop);
  f_init_set_d(op, N);
  f_floor(rop, op);
  assert(f_get_d(rop) = floor(N));
  r2 := f_floor(op);
  assert(f_get_d(r2) = floor(N));
end;

procedure TTestGmpExtensions.f_trunc_test;
const N = -3.9;
var rop, op, r2: MPFloat;
begin
  f_init(rop);
  f_init_set_d(op, N);
  f_trunc(rop, op);
  assert(f_get_d(rop) = trunc(N));
  r2 := f_trunc(op);
  assert(f_get_d(r2) = trunc(N));
end;

procedure TTestGmpExtensions.f_integer_p_test;
const
  N1 = 10;
  N2 = 10.1;
var op: MPFloat;
begin
  f_init_set_si(op, N1);
  assert(f_integer_p(op));
  f_set_d(op, N2);
  assert(not f_integer_p(op));
end;

procedure TTestGmpExtensions.f_fits_ushort_p_test;
var op: MPFloat;
begin
  f_init_set_ui(op, high(word));
  assert(f_fits_ushort_p(op));
  f_add_ui(op, op, 1);
  assert(not f_fits_ushort_p(op));
end;

procedure TTestGmpExtensions.f_fits_sshort_p_test;
var op: MPFloat;
begin
  f_init_set_ui(op, high(smallint));
  assert(f_fits_sshort_p(op));
  f_add_ui(op, op, 1);
  assert(not f_fits_sshort_p(op));
  f_clear(op);
end;

procedure TTestGmpExtensions.f_fits_uint_p_test;
var op: MPFloat;
begin
  f_init_set_ui(op, high(cardinal));
  assert(f_fits_uint_p(op));
  f_add_ui(op, op, 1);
  assert(not f_fits_uint_p(op));
  f_clear(op);
end;

procedure TTestGmpExtensions.f_fits_sint_p_test;
var op: MPFloat;
begin
  f_init_set_ui(op, high(integer));
  assert(f_fits_sint_p(op));
  f_add_ui(op, op, 1);
  assert(not f_fits_sint_p(op));
  f_clear(op);
end;

procedure TTestGmpExtensions.f_fits_ulong_p_test;
var op: MPFloat;
begin
  f_init_set_ui(op, high(valuint));
  assert(f_fits_ulong_p(op));
  f_add_ui(op, op, 1);
  assert(not f_fits_ulong_p(op));
  f_clear(op);
end;

procedure TTestGmpExtensions.f_fits_slong_p_test;
var op: MPFloat;
begin
  f_init_set_ui(op, high(valsint));
  assert(f_fits_slong_p(op));
  f_add_ui(op, op, 1);
  assert(not f_fits_slong_p(op));
  f_clear(op);
end;

procedure TTestGmpExtensions.f_urandomb_test;
const NBITS = 100;
var
  rop, r2: MPFloat;
  state: MPRandState;
  cmp: longint;
begin
  randinit_default(state);
  f_init(rop);
  f_urandomb(rop, state, NBITS);
  cmp := f_cmp_ui(rop, 0);
  assert(cmp >= 0);
  assert(f_cmp_ui(rop, 1) < 0);
  r2 := f_urandomb(state, NBITS);
  cmp := f_cmp_ui(r2, 0);
  assert(cmp >= 0);
  assert(f_cmp_ui(r2, 1) < 0);
end;

procedure TTestGmpExtensions.f_random2_test;
var
  rop, r2: MPFloat;
begin
  f_init(rop);
  f_random2(rop, 1, 1);
  r2 := f_random2(1, 1);
  assert(assigned(r2))
end;

procedure TTestGmpExtensions.f_init_set_test;
const N = -1000000;
var rop, op: MPFloat;
begin
  f_init_set_si(op, N);
  f_init_set(rop, op);
  assert(f_get_si(rop) = N);
end;

procedure TTestGmpExtensions.f_init_set_d_test;
const N = -1.5;
var rop: MPFloat;
begin
  f_init_set_d(rop, N);
  assert(f_get_d(rop) = N);
end;

procedure TTestGmpExtensions.f_init_set_si_test;
const N = -5;
var rop: MPFloat;
begin
  f_init_set_si(rop, N);
  assert(f_get_si(rop) = N);
end;

procedure TTestGmpExtensions.f_init_set_str_test;
const N = -123;
var rop: MPFloat;
begin
  f_init_set_str(rop, inttostr(N), BASE10);
  assert(f_get_si(rop) = N);
end;

procedure TTestGmpExtensions.f_init_set_ui_test;
const N = 5;
var rop: MPFloat;
begin
  f_init_set_ui(rop, N);
  assert(f_get_ui(rop) = N);
end;

{ TTestGmpOperators }

// operator * (op1: MPFloat; op2: MPFloat): MPFloat;
procedure TTestGmpOperators.star__MPFloat__MPFloat__MPFloat_;
const
  OP1_ = 2;
  OP2_ = 3;
var rop, op1, op2: MPFloat;
begin
  f_init_set_d(op1, OP1_);
  f_init_set_d(op2, OP2_);
  rop := op1 * op2;
  assert(f_get_d(rop) = OP1_ * OP2_);
end;

// operator * (op1: MPInteger; op2: MPInteger): MPInteger;
procedure TTestGmpOperators.star__MPInteger__MPInteger__MPInteger_;
const
  OP_1 = -10;
  OP_2 = 1000;
var rop, op1, op2: MPInteger;
begin
  z_init_set_si(op1, OP_1);
  z_init_set_si(op2, OP_2);
  rop := op1 * op2;
  assert(z_get_si(rop) = OP_1 * OP_2);
end;

// operator * (op1: MPRational; op2: MPRational): MPRational;
procedure TTestGmpOperators.star__MPRational__MPRational__MPRational_;
const
  N1 = 5;
  D1 = 2;
  N2 = -7;
  D2 = 3;
var product, multiplier, multiplicant: MPRational;
begin
  q_init(multiplier);
  q_init(multiplicant);
  q_set_si(multiplier, N1, D1);
  q_set_si(multiplicant, N2, D2);
  product := multiplier * multiplicant;
  assert(q_cmp_si(product, N1 * N2, D1 * D2) = 0);
end;

// operator ** (op1: MPFloat; op2: valuint): MPFloat;
procedure TTestGmpOperators.pow__MPFloat_valuint_MPFloat_;
const
  OP1_ = 3;
  OP2_ = 2;
var rop, op1: MPFloat;
begin
  f_init_set_d(op1, OP1_);
  rop := op1 ** OP2_;
  assert(f_get_d(rop) = OP1_ ** OP2_);
end;

// operator ** (op1: MPInteger; op2: valuint): MPInteger;
procedure TTestGmpOperators.pow__MPInteger_valuint_MPInteger_;
const
  BASE_ = 10;
  EXP = 3;
var rop, base: MPInteger;
begin
  z_init_set_si(base, BASE_);
  rop := base ** EXP;
  assert(z_get_si(rop) = BASE_ ** EXP);
end;

// operator + (op1: MPFloat; op2: MPFloat): MPFloat;
procedure TTestGmpOperators.plus__MPFloat__MPFloat__MPFloat_;
const
  OP1_ = 1;
  OP2_ = 2;
var rop, op1, op2: MPFloat;
begin
  f_init_set_d(op1, OP1_);
  f_init_set_d(op2, OP2_);
  rop := op1 + op2;
  assert(f_get_d(rop) = OP1_ + OP2_);
end;

// operator + (op1: MPInteger; op2: MPInteger): MPInteger;
procedure TTestGmpOperators.plus__MPInteger__MPInteger__MPInteger_;
const
  OP_1 = -1000;
  OP_2 = 1000000;
var rop, op1, op2: MPInteger;
begin
  z_init_set_si(op1, OP_1);
  z_init_set_si(op2, OP_2);
  rop := op1 + op2;
  assert(z_get_si(rop) = OP_1 + OP_2);
end;

// operator + (op1: MPRational; op2: MPRational): MPRational;
procedure TTestGmpOperators.plus__MPRational__MPRational__MPRational_;
const
  N1 = 5;
  D1 = 2;
  N2 = -7;
  D2 = 3;
var sum, addend1, addend2: MPRational;
begin
  q_init(addend1);
  q_init(addend2);
  q_set_si(addend1, N1, D1);
  q_set_si(addend2, N2, D2);
  sum := addend1 + addend2;
  assert(q_cmp_si(sum, N1 * D2 + N2 * D1, D1 * D2) = 0);
end;

// operator - (op: MPFloat): MPFloat;
procedure TTestGmpOperators.minus__MPFloat__MPFloat_;
const
  OP_ = 4;
var rop, op: MPFloat;
begin
  f_init_set_d(op, OP_);
  rop := -op;
  assert(f_get_d(rop) = -OP_);
end;

// operator - (op: MPInteger): MPInteger;
procedure TTestGmpOperators.minus__MPInteger__MPInteger_;
const OP_ = 1000;
var rop, op: MPInteger;
begin
  z_init_set_si(op, OP_);
  rop := -op;
  assert(z_get_si(rop) = -OP_);
end;

// operator - (op: MPRational): MPRational;
procedure TTestGmpOperators.minus__MPRational__MPRational_;
const
  N1 = -5;
  D1 = 3;
var negated_operand, operand: MPRational;
begin
  q_init(negated_operand);
  q_init(operand);
  q_set_si(operand, N1, D1);
  negated_operand := - operand;
  assert(q_cmp_si(negated_operand, -N1, D1) = 0);
end;

// operator - (op1: MPFloat; op2: MPFloat): MPFloat;
procedure TTestGmpOperators.minus__MPFloat__MPFloat__MPFloat_;
const
  OP1_ = 3;
  OP2_ = 1;
var rop, op1, op2: MPFloat;
begin
  f_init_set_d(op1, OP1_);
  f_init_set_d(op2, OP2_);
  rop := op1 - op2;
  assert(f_get_d(rop) = OP1_ - OP2_);
end;

// operator - (op1: MPInteger; op2: MPInteger): MPInteger;
procedure TTestGmpOperators.minus__MPInteger__MPInteger__MPInteger_;
const
  OP_1 = -1000;
  OP_2 = 1000000;
var rop, op1, op2: MPInteger;
begin
  z_init_set_si(op1, OP_1);
  z_init_set_si(op2, OP_2);
  rop := op1 - op2;
  assert(z_get_si(rop) = OP_1 - OP_2);
end;

// operator - (op1: MPRational; op2: MPRational): MPRational;
procedure TTestGmpOperators.minus__MPRational__MPRational__MPRational_;
const
  N1 = 5;
  D1 = 2;
  N2 = -7;
  D2 = 3;
var difference, minuend, subtrahend: MPRational;
begin
  q_init(minuend);
  q_init(subtrahend);
  q_set_si(minuend, N1, D1);
  q_set_si(subtrahend, N2, D2);
  difference := minuend - subtrahend;
  assert(q_cmp_si(difference, N1 * D2 - N2 * D1, D1 * D2) = 0);
end;

// operator / (op1: MPFloat; op2: MPFloat): MPFloat;
procedure TTestGmpOperators.slash__MPFloat__MPFloat__MPFloat_;
const
  OP1_ = 6;
  OP2_ = 2;
var rop, op1, op2: MPFloat;
begin
  f_init_set_d(op1, OP1_);
  f_init_set_d(op2, OP2_);
  rop := op1 / op2;
  assert(f_get_d(rop) = OP1_ / OP2_);
end;

// operator / (op1: MPInteger; op2: MPInteger): MPInteger;
procedure TTestGmpOperators.slash__MPInteger__MPInteger__MPInteger_;
const
  N_ = -17;
  D_ = 4;
var q, n, d: MPInteger;
begin
  z_init_set_si(n, N_);
  z_init_set_si(d, D_);
  q := n / d;
  assert(z_get_si(q) = trunc(N_ / D_));
end;

// operator / (op1: MPRational; op2: MPRational): MPRational;
procedure TTestGmpOperators.slash__MPRational__MPRational__MPRational_;
const
  N1 = 5;
  D1 = 2;
  N2 = -7;
  D2 = 3;
var quotient, dividend, divisor: MPRational;
begin
  q_init(dividend);
  q_init(divisor);
  q_set_si(dividend, N1, D1);
  q_set_si(divisor, N2, D2);
  quotient := dividend / divisor;
  assert(q_cmp_si(quotient, -N1 * D2, -D1 * N2) = 0);
end;

// operator := (op: double): MPFloat;
procedure TTestGmpOperators.assign_double_MPFloat_;
const N = -1.5;
var rop: MPFloat;
begin
  rop := N;
  assert(f_get_d(rop) = N);
end;

// operator := (op: double): MPInteger;
procedure TTestGmpOperators.assign_double_MPInteger_;
const OP_ = 1000000;
var rop: MPInteger;
begin
  rop := OP_;
  assert(z_get_si(rop) = OP_);
end;

// operator := (op: double): MPRational;
procedure TTestGmpOperators.assign_double_MPRational_;
const
  OP_1 = -1;
  OP_2 = 2;
var rop: MPRational;
begin
  rop := OP_1 / OP_2;
  assert(q_cmp_si(rop, OP_1, OP_2) = 0);
end;

// operator := (op: MPFloat): cardinal;
procedure TTestGmpOperators.assign__MPFloat_Cardinal;
const OP = 1000000;
var rop: MPFloat;
begin
  rop := OP;
  assert(f_get_ui(rop) = OP);
end;

// operator := (op: MPFloat): double;
procedure TTestGmpOperators.assign__MPFloat_double;
const N = -1.5;
var rop: MPFloat;
begin
  rop := N;
  assert(f_get_d(rop) = N);
end;

// operator := (op: MPFloat): integer;
procedure TTestGmpOperators.assign__MPFloat_integer;
const OP = -1000000;
var rop: MPFloat;
begin
  rop := OP;
  assert(f_get_si(rop) = OP);
end;

// operator := (op: MPFloat): mpf_t;
procedure TTestGmpOperators.assign__MPFloat_mpf_t;
const N = -1000000;
var
  rop: mpf_t;
  op: MPFloat;
begin
  f_init_set_si(op, N);
  rop := op;
  assert(mpf_get_si(rop) = N);
  mpf_clear(rop);
end;

// operator := (op: MPFloat): MPInteger;
procedure TTestGmpOperators.assign__MPFloat__MPInteger_;
const OP_ = -10;
var
  op: MPFloat;
  rop: MPInteger;
begin
  f_init_set_si(op, OP_);
  rop := op;
  assert(z_get_si(rop) = OP_);
end;

// operator := (op: MPFloat): MPRational;
procedure TTestGmpOperators.assign__MPFloat__MPRational_;
const OP_ = -10;
var
  op: MPFloat;
  rop: MPRational;
begin
  f_init_set_si(op, OP_);
  rop :=  op;
  assert(q_get_d(rop) = OP_);
end;

// operator := (op: MPFloat): string;
procedure TTestGmpOperators.assign__MPFloat_string;
const
  N = 123456;
  S = '123456';
var
  op: MPFloat;
  r: string;
begin
  f_init_set_d(op, N);
  r := op;
  assert(r = S);
end;

// operator := (op: MPFloat): valsint;
procedure TTestGmpOperators.assign__MPFloat_valsint;
const OP_ = -1000000;
var
  op: MPFloat;
  r: valsint;
begin
  f_init_set_si(op, OP_);
  r := op;
  assert(r = OP_);
end;

// operator := (op: MPFloat): valuint;
procedure TTestGmpOperators.assign__MPFloat_valuint;
const OP_ = 1000000;
var
  op: MPFloat;
  r: valuint;
begin
  f_init_set_si(op, OP_);
  r := op;
  assert(r = OP_);
end;

// operator := (var op: mpf_t): MPFloat;
procedure TTestGmpOperators.assign_mpf_t_MPFloat_;
const N = -1000000;
var
  op: mpf_t;
  rop: MPFloat;
begin
  mpf_init_set_si(op, N);
  rop := op;
  assert(f_get_si(rop) = N);
  mpf_clear(op);
end;

// operator := (op: MPInteger): cardinal;
procedure TTestGmpOperators.assign__MPInteger_cardinal;
const N = 1000000;
var
  op: MPInteger;
  r: cardinal;
begin
  z_init_set_ui(op, N);
  r := op;
  assert(r = N);
end;

// operator := (op: MPInteger): double;
procedure TTestGmpOperators.assign__MPInteger_double;
const N = -1000;
var
  op: MPInteger;
  r: double;
begin
  z_init_set_si(op, N);
  r := op;
  assert(r = N);
end;

// operator := (op: MPInteger): integer;
procedure TTestGmpOperators.assign__MPInteger_integer;
const N = -1000000;
var
  op: MPInteger;
  r: integer;
begin
  z_init_set_si(op, N);
  r := op;
  assert(r = N);
end;

// operator := (op: MPInteger): MPFloat;
procedure TTestGmpOperators.assign__MPInteger__MPFloat_;
const
  OP_1 = -13;
var
  rop: MPFloat;
  op: MPInteger;
begin
  z_init_set_si(op, OP_1);
  rop := op;
  assert(f_get_si(rop) = OP_1);
end;

// operator := (op: MPInteger): MPRational;
procedure TTestGmpOperators.assign__MPInteger__MPRational_;
const
  OP_1 = -13;
var
  rational: MPRational;
  op: MPInteger;
begin
  z_init_set_si(op, OP_1);
  rational := op;
  assert(q_cmp_si(rational, OP_1, 1) = 0);
end;

// operator := (op: MPInteger): mpz_t;
procedure TTestGmpOperators.assign__MPInteger_mpz_t;
const N = -1000000;
var
  rop: mpz_t;
  op: MPInteger;
begin
  z_init_set_si(op, N);
  rop := op;
  assert(mpz_get_si(rop) = N);
  mpz_clear(rop);
end;

// operator := (op: MPInteger): string;
procedure TTestGmpOperators.assign__MPInteger_string;
const
  N = 123456;
  S = '123456';
var
  op: MPInteger;
  r: string;
begin
  z_init_set_ui(op, N);
  r := op;
  assert(r = S);
end;

// operator := (op: MPInteger): valsint;
procedure TTestGmpOperators.assign__MPInteger_valsint;
const N = -1000000;
var
  op: MPInteger;
  r: valsint;
begin
  z_init_set_si(op, N);
  r := op;
  assert(r = N);
end;

// operator := (op: MPInteger): valuint;
procedure TTestGmpOperators.assign__MPInteger_valuint;
const N = 1000000;
var
  op: MPInteger;
  r: valuint;
begin
  z_init_set_ui(op, N);
  r := op;
  assert(r = N);
end;

// operator := (var op: mpq_t): MPRational;
procedure TTestGmpOperators.assign_mpq_t_MPRational_;
const
  N = -17;
  D = 3;
var
  op: mpq_t;
  rop: MPRational;
begin
  mpq_init(op);
  mpq_set_si(op, N, D);
  rop := op;
  assert(q_cmp_si(rop, N, D) = 0);
  mpq_clear(op);
end;

// operator := (op: MPRandState): randstate_t;
procedure TTestGmpOperators.assign__MPRandState_randstate_t;
var
  op: MPRandState;
  rop: randstate_t;
begin
  randinit_default(op);
  rop := op;
  assert(rnd_test(rop));
  mp_randclear(rop);
end;

// operator := (op: MPRational): double;
procedure TTestGmpOperators.assign__MPRational_double;
const
  OP_1 = -1;
  OP_2 = 2;
var
  op: MPRational;
  r: double;
begin
  q_init(op);
  q_set_si(op, OP_1, OP_2);
  r := op;
  assert(r = OP_1 / OP_2);
end;

// operator := (op: MPRational): MPFloat;
procedure TTestGmpOperators.assign__MPRational__MPFloat_;
const OP_ = -10;
var
  op: MPRational;
  rop: MPFloat;
begin
  q_init(op);
  q_set_si(op, OP_, 1);
  rop :=  op;
  assert(f_get_si(rop) = OP_);
end;

// operator := (op: MPRational): MPInteger;
procedure TTestGmpOperators.assign__MPRational__MPInteger_;
const OP_ = -10;
var
  op: MPRational;
  rop: MPInteger;
begin
  q_init(op);
  q_set_si(op, OP_, 1);
  rop := op;
  assert(z_get_si(rop) = OP_);
end;

// operator := (op: MPRational): mpq_t;
procedure TTestGmpOperators.assign__MPRational_mpq_t;
const
  OP_1 = -13;
  OP_2 = 17;
var
  rational: mpq_t;
  op: MPRational;
begin
  q_init(op);
  q_set_si(op, OP_1, OP_2);
  rational := op;
  assert(mpq_cmp_si(rational, OP_1, OP_2) = 0);
  mpq_clear(rational);
end;

// operator := (op: MPRational): string;
procedure TTestGmpOperators.assign__MPRational_string;
const
  N = 5;
  D = 3;
  S = '5/3';
var
  op: MPRational;
  r: string;
begin
  q_init(op);
  q_set_si(op, N, D);
  r := op;
  assert(r = S);
end;

// operator := (var op: mpz_t): MPInteger;
procedure TTestGmpOperators.assign_mpz_t_MPInteger_;
const N = -1000000;
var
  op: mpz_t;
  rop: MPInteger;
begin
  mpz_init_set_si(op, N);
  rop := op;
  assert(z_get_si(rop) = N);
  mpz_clear(op);
end;

// operator := (var op: randstate_t): MPRandState;
procedure TTestGmpOperators.assign_randstate_t_MPRandState_;
var
  op: randstate_t;
  rop: MPRandState;
begin
  mp_randinit_default(op);
  rop := op;
  assert(rnd_test(rop.ptr^));
  mp_randclear(op);
end;

// operator := (op: string): MPFloat;
procedure TTestGmpOperators.assign_string_MPFloat_;
const N = -123;
var rop: MPFloat;
begin
  rop := inttostr(N);
  assert(f_get_si(rop) = N);
end;

// operator := (op: string): MPInteger;
procedure TTestGmpOperators.assign_string_MPInteger_;
const N = -123;
var rop: MPInteger;
begin
  rop := inttostr(N);
  assert(z_get_si(rop) = N);
end;

// operator := (op: string): MPRational;
procedure TTestGmpOperators.assign_string_MPRational_;
const
  N = 5;
  D = 3;
  S = '5/3';
var rop: MPRational;
begin
  rop := S;
  assert(q_cmp_si(rop, N, D) = 0);
end;

// operator := (op: valsint): MPFloat;
procedure TTestGmpOperators.assign_valsint_MPFloat_;
const OP = -1000000;
var rop: MPFloat;
begin
  rop := OP;
  assert(f_get_si(rop) = OP);
end;

// operator := (op: valsint): MPInteger;
procedure TTestGmpOperators.assign_valsint_MPInteger_;
const OP = -1000000;
var rop: MPInteger;
begin
  rop := OP;
  assert(z_get_si(rop) = OP);
end;

// operator := (op: valsint): MPRational;
procedure TTestGmpOperators.assign_valsint_MPRational_;
const OP = -1000000;
var rop: MPRational;
begin
  rop := OP;
  assert(q_cmp_si(rop, OP, 1) = 0);
end;

// operator := (op: valuint): MPFloat;
procedure TTestGmpOperators.assign_valuint_MPFloat_;
const OP = 1000000;
var rop: MPFloat;
begin
  rop := OP;
  assert(f_get_ui(rop) = OP);
end;

// operator := (op: valuint): MPInteger;
procedure TTestGmpOperators.assign_valuint_MPInteger_;
const OP = 1000000;
var rop: MPInteger;
begin
  rop := OP;
  assert(z_get_ui(rop) = OP);
end;

// operator := (op: valuint): MPRational;
procedure TTestGmpOperators.assign_valuint_MPRational_;
const OP = 1000000;
var rop: MPRational;
begin
  rop := OP;
  assert(q_cmp_ui(rop, OP, 1) = 0);
end;

// operator < (op1: MPFloat; op2: MPFloat): boolean;
procedure TTestGmpOperators.lt__MPFloat__MPFloat_boolean;
const
  OP1_ = 1.2;
  OP2_ = OP1_ + 1;
var op1, op2: MPFloat;
begin
  f_init_set_d(op1, OP1_);
  f_init_set_d(op2, OP2_);
  assert(op1 < op2);
end;

// operator < (op1: MPInteger; op2: MPInteger): boolean;
procedure TTestGmpOperators.lt__MPInteger__MPInteger_boolean;
const
  OP1_ = 12;
  OP2_ = OP1_ + 1;
var op1, op2: MPInteger;
begin
  z_init_set_d(op1, OP1_);
  z_init_set_d(op2, OP2_);
  assert(op1 < op2);
end;

// operator < (op1: MPRational; op2: MPRational): boolean;
procedure TTestGmpOperators.lt__MPRational__MPRational_boolean;
const
  OP1_ = 12;
  OP2_ = OP1_ + 1;
var op1, op2: MPRational;
begin
  q_init(op1);
  q_init(op2);
  q_set_si(op1, OP1_, 1);
  q_set_si(op2, OP2_, 1);
  assert(op1 < op2);
end;

// operator <= (op1: MPFloat; op2: MPFloat): boolean;
procedure TTestGmpOperators.le__MPFloat__MPFloat_boolean;
const
  OP1_ = 1.2;
  OP2_ = OP1_ + 1;
var op1, op2: MPFloat;
begin
  f_init_set_d(op1, OP1_);
  f_init_set_d(op2, OP2_);
  assert(op1 <= op2);
  f_set_d(op2, OP1_);
  assert(op1 <= op2);
end;

// operator <= (op1: MPInteger; op2: MPInteger): boolean;
procedure TTestGmpOperators.le__MPInteger__MPInteger_boolean;
const
  OP1_ = 12;
  OP2_ = OP1_ + 1;
var op1, op2: MPInteger;
begin
  z_init_set_ui(op1, OP1_);
  z_init_set_ui(op2, OP2_);
  assert(op1 <= op2);
  z_set_ui(op2, OP1_);
  assert(op1 <= op2);
end;

// operator <= (op1: MPRational; op2: MPRational): boolean;
procedure TTestGmpOperators.le__MPRational__MPRational_boolean;
const
  OP1_ = 12;
  OP2_ = OP1_ + 1;
var op1, op2: MPRational;
begin
  q_init(op1);
  q_init(op2);
  q_set_si(op1, OP1_, 1);
  q_set_si(op2, OP2_, 1);
  assert(op1 <= op2);
  q_set_si(op2, OP1_, 1);
  assert(op1 <= op2);
end;

// operator > (op1: MPFloat; op2: MPFloat): boolean;
procedure TTestGmpOperators.gt__MPFloat__MPFloat_boolean;
const
  OP1_ = 1.2;
  OP2_ = OP1_ - 1;
var op1, op2: MPFloat;
begin
  f_init_set_d(op1, OP1_);
  f_init_set_d(op2, OP2_);
  assert(op1 > op2);
end;

// operator > (op1: MPInteger; op2: MPInteger): boolean;
procedure TTestGmpOperators.gt__MPInteger__MPInteger_boolean;
const
  OP1_ = 12;
  OP2_ = OP1_ - 1;
var op1, op2: MPInteger;
begin
  z_init_set_d(op1, OP1_);
  z_init_set_d(op2, OP2_);
  assert(op1 > op2);
end;

// operator > (op1: MPRational; op2: MPRational): boolean;
procedure TTestGmpOperators.gt__MPRational__MPRational_boolean;
const
  OP1_ = 12;
  OP2_ = OP1_ - 1;
var op1, op2: MPRational;
begin
  q_init(op1);
  q_init(op2);
  q_set_si(op1, OP1_, 1);
  q_set_si(op2, OP2_, 1);
  assert(op1 > op2);
end;

// operator >= (op1: MPFloat; op2: MPFloat): boolean;
procedure TTestGmpOperators.ge__MPFloat__MPFloat_boolean;
const
  OP1_ = 1.2;
  OP2_ = OP1_ - 1;
var op1, op2: MPFloat;
begin
  f_init_set_d(op1, OP1_);
  f_init_set_d(op2, OP2_);
  assert(op1 >= op2);
  f_set_d(op2, OP1_);
  assert(op1 >= op2);
end;

// operator >= (op1: MPInteger; op2: MPInteger): boolean;
procedure TTestGmpOperators.ge__MPInteger__MPInteger_boolean;
const
  OP1_ = 12;
  OP2_ = OP1_ - 1;
var op1, op2: MPInteger;
begin
  z_init_set_ui(op1, OP1_);
  z_init_set_ui(op2, OP2_);
  assert(op1 >= op2);
  z_set_ui(op2, OP1_);
  assert(op1 >= op2);
end;

// operator >= (op1: MPRational; op2: MPRational): boolean;
procedure TTestGmpOperators.ge__MPRational__MPRational_boolean;
const
  OP1_ = 12;
  OP2_ = OP1_ - 1;
var op1, op2: MPRational;
begin
  q_init(op1);
  q_init(op2);
  q_set_si(op1, OP1_, 1);
  q_set_si(op2, OP2_, 1);
  assert(op1 >= op2);
  q_set_si(op2, OP1_, 1);
  assert(op1 >= op2);
end;