CPAN::Groonga

k(defined($y), '$y is defined');
    is(ref($y), 'Math::BigFloat', '$y has the right class');
    isnt(refaddr($y), refaddr($x), '$y is a different object than $x');

    # sign

    ok(defined($y->{s

,
       'mantissa of $y and $x use the same reference type');
    isnt(ref($y->{_m}), '', 'mantissa of $y is a reference');
    isnt(refaddr($y->{_m}), refaddr($x->{_m}),
      'mantissa of $y is not

onent mantissa of $y and $x use the same reference type');
    isnt(ref($y->{_e}), '', 'exponent mantissa of $y is a reference');
    isnt(refaddr($y->{_e}), refaddr($x->{_e}),
      'exponent mantiss

 ok(defined($y), '$y is defined');
    is(ref($y), 'Math::BigInt', '$y has the right class');
    isnt(refaddr($y), refaddr($x), '$y is a different object than $x');

    # sign

    ok(defined($y->{s

       'mantissa of $y and $x use the same reference type');
    isnt(ref($y->{value}), '', 'mantissa of $y is a reference');
    isnt(refaddr($y->{value}), refaddr($x->{value}),
      'mantissa of $

 ok(defined($y), '$y is defined');
    is(ref($y), 'Math::BigInt', '$y has the right class');
    isnt(refaddr($y), refaddr($x), '$y is a different object than $x');

    # sign

    ok(defined($y->{s

s(ref($y), 'Math::BigRat', '$y is a Math::BigRat');
    cmp_ok($y, "==", "Inf", '$y == Inf');
    isnt(refaddr($x), refaddr($y), '$x and $y are different objects');
};

$x = Math::BigRat -> new("-Inf"

ref($y), 'Math::BigRat', '$y is a Math::BigRat');
    cmp_ok($y, "==", "-Inf", '$y == -Inf');
    isnt(refaddr($x), refaddr($y), '$x and $y are different objects');
};

$x = Math::BigRat -> new("NaN")

t');
    is(ref($y), 'Math::BigRat', '$y is a Math::BigRat');
    is($y, "NaN", '$y is NaN');
    isnt(refaddr($x), refaddr($y), '$x and $y are different objects');
};

$x = Math::BigRat -> new("2"); 

    "The value of the denominator hasn't changed");

isnt(refaddr($n), refaddr($n_orig),
     "The addresses of the numerators have changed");
isnt(refaddr($d), refaddr($d_orig),
     "The addresses o

$class, "output arg is a $class");
        is($y, "0", 'output arg has the right value');
        isnt(refaddr($x), refaddr($y), "output is not the invocand");
    };
}

##############################

lass, "output arg is a $class");
        is($y, "NaN", 'output arg has the right value');
        isnt(refaddr($x), refaddr($y), "output is not the invocand");
    };
}

##############################

           ok($y->{_es} eq '+' || $y->{_es} eq '-', "exponent sign is valid");
        }

        isnt(refaddr($x), refaddr($y), "output is not the invocand");
    };
}

##############################

           ok($y->{_es} eq '+' || $y->{_es} eq '-', "exponent sign is valid");
        }

        isnt(refaddr($x), refaddr($y), "output is not the invocand");
    };
}

##############################

           ok($y->{_es} eq '+' || $y->{_es} eq '-', "exponent sign is valid");
        }

        isnt(refaddr($x), refaddr($y), "output is not the invocand");
    };
}

##############################

f($y), 'Math::BigFloat', '$y is a Math::BigFloat');
    cmp_ok($y, "==", "Inf", '$y == Inf');
    isnt(refaddr($x), refaddr($y), '$x and $y are different objects');
};

$x = Math::BigFloat -> new("-In

$y), 'Math::BigFloat', '$y is a Math::BigFloat');
    cmp_ok($y, "==", "-Inf", '$y == -Inf');
    isnt(refaddr($x), refaddr($y), '$x and $y are different objects');
};

$x = Math::BigFloat -> new("NaN

    is(ref($y), 'Math::BigFloat', '$y is a Math::BigFloat');
    is($y, "NaN", '$y is NaN');
    isnt(refaddr($x), refaddr($y), '$x and $y are different objects');
};

$x = Math::BigFloat -> new("2")

ass, "output arg is a $class");
        is($y, $out0, 'output arg has the right value');

        isnt(refaddr($x), refaddr($y), "output is not the invocand");
    };
}

##############################

$class, "output arg is a $class");
        is($y, "0", 'output arg has the right value');
        isnt(refaddr($x), refaddr($y), "output is not the invocand");
    };
}

##############################

utput arg has the right value');
        is($y, "NaN", 'output arg has the right value');
        isnt(refaddr($x), refaddr($y), "output is not the invocand");
    };
}

##############################

s(ref($y), 'Math::BigRat', '$y is a Math::BigRat');
    cmp_ok($y, "==", "Inf", '$y == Inf');
    isnt(refaddr($x), refaddr($y), '$x and $y are different objects');
};

$x = Math::BigFloat -> new("-In

ref($y), 'Math::BigRat', '$y is a Math::BigRat');
    cmp_ok($y, "==", "-Inf", '$y == -Inf');
    isnt(refaddr($x), refaddr($y), '$x and $y are different objects');
};

$x = Math::BigFloat -> new("NaN

t');
    is(ref($y), 'Math::BigRat', '$y is a Math::BigRat');
    is($y, "NaN", '$y is NaN');
    isnt(refaddr($x), refaddr($y), '$x and $y are different objects');
};

$x = Math::BigFloat -> new("2")

    is(ref($y), 'Math::BigInt', '$y is a Math::BigInt');
    cmp_ok($y, "==", 2, '$y == 2');
    isnt(refaddr($x), refaddr($y), '$x and $y are different objects');
};

$x = Math::BigFloat -> new("2")

    is(ref($y), 'Math::BigInt', '$y is a Math::BigInt');
    cmp_ok($y, "==", 2, '$y == 2');
    isnt(refaddr($x), refaddr($y), '$x and $y are different objects');
};

$x = Math::BigFloat -> new("2.8

    is(ref($y), 'Math::BigInt', '$y is a Math::BigInt');
    cmp_ok($y, "==", 2, '$y == 2');
    isnt(refaddr($x), refaddr($y), '$x and $y are different objects');
};

$x = Math::BigRat -> new("2"); 

f($y), 'Math::BigFloat', '$y is a Math::BigFloat');
    cmp_ok($y, "==", "Inf", '$y == Inf');
    isnt(refaddr($x), refaddr($y), '$x and $y are different objects');
};

$x = Math::BigRat -> new("-Inf"

$y), 'Math::BigFloat', '$y is a Math::BigFloat');
    cmp_ok($y, "==", "-Inf", '$y == -Inf');
    isnt(refaddr($x), refaddr($y), '$x and $y are different objects');
};

$x = Math::BigRat -> new("NaN")

    is(ref($y), 'Math::BigFloat', '$y is a Math::BigFloat');
    is($y, "NaN", '$y is NaN');
    isnt(refaddr($x), refaddr($y), '$x and $y are different objects');
};

$x = Math::BigRat -> new("2"); 

BigInt" && $in1 =~ m|[./]|;
                isnt(refaddr($z), refaddr($x),
                     'output arg is not the first operand');
                isnt(refaddr($z), refaddr($y),
                 

BigInt" && $in1 =~ m|[./]|;
                isnt(refaddr($z), refaddr($x),
                     'output arg is not the first operand');
                isnt(refaddr($z), refaddr($y),
                 

s(ref($y), 'Math::BigRat', '$y is a Math::BigRat');
    cmp_ok($y, "==", "Inf", '$y == Inf');
    isnt(refaddr($x), refaddr($y), '$x and $y are different objects');
};

$x = Math::BigInt -> new("-Inf"

ref($y), 'Math::BigRat', '$y is a Math::BigRat');
    cmp_ok($y, "==", "-Inf", '$y == -Inf');
    isnt(refaddr($x), refaddr($y), '$x and $y are different objects');
};

$x = Math::BigInt -> new("NaN")

t');
    is(ref($y), 'Math::BigRat', '$y is a Math::BigRat');
    is($y, "NaN", '$y is NaN');
    isnt(refaddr($x), refaddr($y), '$x and $y are different objects');
};

$x = Math::BigInt -> new("2"); 

 2 unless $scalar_util_ok;

            isnt(refaddr($got[0]), refaddr($y),
                 "'$test' output arg is not the second input arg");

            isnt(refaddr($got[0]), refaddr($m),
       

, 2 unless $scalar_util_ok;

            isnt(refaddr($got), refaddr($y),
                 "'$test' output arg is not the second input arg");

            isnt(refaddr($got), refaddr($m),
            

    SKIP: {
            skip "Scalar::Util not available", 1 unless $scalar_util_ok;

            isnt(refaddr($got[0]), refaddr($y),
                 "'$test' output arg is not the second input arg")

    SKIP: {
            skip "Scalar::Util not available", 1 unless $scalar_util_ok;

            isnt(refaddr($got), refaddr($y),
                 "'$test' output arg is not the second input arg");
 

    SKIP: {
            skip "Scalar::Util not available", 1 unless $scalar_util_ok;

            isnt(refaddr($got[0]), refaddr($x),
                 "'$test' output arg is not the first input arg");

f($y), 'Math::BigFloat', '$y is a Math::BigFloat');
    cmp_ok($y, "==", "Inf", '$y == Inf');
    isnt(refaddr($x), refaddr($y), '$x and $y are different objects');
};

$x = Math::BigInt -> new("-Inf"

$y), 'Math::BigFloat', '$y is a Math::BigFloat');
    cmp_ok($y, "==", "-Inf", '$y == -Inf');
    isnt(refaddr($x), refaddr($y), '$x and $y are different objects');
};

$x = Math::BigInt -> new("NaN")

    is(ref($y), 'Math::BigFloat', '$y is a Math::BigFloat');
    is($y, "NaN", '$y is NaN');
    isnt(refaddr($x), refaddr($y), '$x and $y are different objects');
};

$x = Math::BigInt -> new("2"); 

BigInt" && $in1 =~ m|[./]|;
                isnt(refaddr($z), refaddr($x),
                     'output arg is not the first operand');
                isnt(refaddr($z), refaddr($y),
                 

BigInt" && $in1 =~ m|[./]|;
                isnt(refaddr($z), refaddr($x),
                     'output arg is not the first operand');
                isnt(refaddr($z), refaddr($y),
                 

    SKIP: {
            skip "Scalar::Util not available", 1 unless $scalar_util_ok;

            isnt(refaddr($got[0]), refaddr($y),
                 "'$test' first output arg is not the second input

    SKIP: {
            skip "Scalar::Util not available", 1 unless $scalar_util_ok;

            isnt(refaddr($got[1]), refaddr($y),
                 "'$test' second output arg is not the second inpu

    SKIP: {
            skip "Scalar::Util not available", 1 unless $scalar_util_ok;

            isnt(refaddr($got), refaddr($y),
                 "'$test' output arg is not the second input arg");
 

r classes.

        for my $other (@classes) {
            next if $other eq $class;

            isnt($other -> config($key), $class -> config($key),
                 qq|$other -> config("$key") isn'

r classes.

        for my $other (@classes) {
            next if $other eq $class;

            isnt($other -> config($key), $class -> config($key),
                 qq|$other -> config("$key") isn'

    SKIP: {
            skip "Scalar::Util not available", 1 unless $scalar_util_ok;

            isnt(refaddr($got[0]), refaddr($y),
                 "'$test' output arg is not the second input arg")

    SKIP: {
            skip "Scalar::Util not available", 1 unless $scalar_util_ok;

            isnt(refaddr($got), refaddr($y),
                 "'$test' output arg is not the second input arg");
 

    SKIP: {
            skip "Scalar::Util not available", 1 unless $scalar_util_ok;

            isnt(refaddr($got[0]), refaddr($y),
                 "'$test' output arg is not the second input arg")

    SKIP: {
            skip "Scalar::Util not available", 1 unless $scalar_util_ok;

            isnt(refaddr($got), refaddr($y),
                 "'$test' output arg is not the second input arg");