view release on metacpan or  search on metacpan

t/003-util-predicates-valid.t  view on Meta::CPAN

    ok(!is_string({}), 'is_string: hash');
    ok(!is_string(sub {}), 'is_string: code');
    ok(!is_string(\my $x), 'is_string: scalar ref');

    # Strings (defined non-refs)
    ok(is_string(''), 'is_string: empty string');
    ok(is_string('hello'), 'is_string: string');
    ok(is_string(0), 'is_string: 0');
    ok(is_string(42), 'is_string: integer');
    ok(is_string(3.14), 'is_string: float');
    ok(is_string('0'), 'is_string: string 0');
};

subtest 'is_string edge cases' => sub {
    # Stringified number
    my $num = 42;
    my $str = "$num";
    ok(is_string($str), 'is_string: stringified number');

    # Blessed reference is not a string
    my $obj = bless {}, 'Class';
    ok(!is_string($obj), 'is_string: blessed ref');

    # Large number
    ok(is_string(1e100), 'is_string: large number');

    # Negative
    ok(is_string(-42), 'is_string: negative');
};

# ============================================
# is_num
# ============================================

subtest 'is_num basic' => sub {
    # Not numbers
    ok(!is_num(undef), 'is_num: undef');
    ok(!is_num('hello'), 'is_num: non-numeric string');
    ok(!is_num(''), 'is_num: empty string');
    ok(!is_num([]), 'is_num: array');
    ok(!is_num({}), 'is_num: hash');

    # Numbers
    ok(is_num(0), 'is_num: 0');
    ok(is_num(42), 'is_num: positive int');
    ok(is_num(-42), 'is_num: negative int');
    ok(is_num(3.14), 'is_num: float');
    ok(is_num(-3.14), 'is_num: negative float');
    ok(is_num(1e10), 'is_num: scientific notation');
};

subtest 'is_num edge cases' => sub {
    # String that looks like number
    ok(is_num('42'), 'is_num: string 42');
    ok(is_num('3.14'), 'is_num: string 3.14');
    ok(is_num('-5'), 'is_num: string -5');
    ok(is_num('1e10'), 'is_num: string scientific');

    # Special values (Perl's looks_like_number considers these numeric)
    ok(is_num(0.0), 'is_num: 0.0');
    ok(is_num('NaN'), 'is_num: string NaN (Perl considers numeric)');
    ok(is_num('inf'), 'is_num: string inf (Perl considers numeric)');

    # Whitespace (Perl's looks_like_number accepts leading/trailing spaces)
    ok(is_num('  42  '), 'is_num: number with spaces (Perl accepts)');
    ok(!is_num('42abc'), 'is_num: number with trailing text');
};

# ============================================
# is_int
# ============================================

subtest 'is_int basic' => sub {
    # Not integers
    ok(!is_int(undef), 'is_int: undef');
    ok(!is_int('hello'), 'is_int: string');
    ok(!is_int(3.14), 'is_int: float');
    ok(!is_int(-3.14), 'is_int: negative float');
    ok(!is_int([]), 'is_int: array');

    # Integers
    ok(is_int(0), 'is_int: 0');
    ok(is_int(42), 'is_int: positive');
    ok(is_int(-42), 'is_int: negative');
    ok(is_int(1000000), 'is_int: large');
};

subtest 'is_int edge cases' => sub {
    # Whole number floats
    ok(is_int(5.0), 'is_int: 5.0');
    ok(is_int(-10.0), 'is_int: -10.0');

    # Very close to integer
    ok(!is_int(5.0001), 'is_int: 5.0001');
    ok(!is_int(4.9999), 'is_int: 4.9999');

    # String integers
    ok(is_int('42'), 'is_int: string 42');
    ok(is_int('-5'), 'is_int: string -5');
};

# ============================================
# is_blessed
# ============================================

subtest 'is_blessed basic' => sub {
    # Not blessed
    ok(!is_blessed(undef), 'is_blessed: undef');
    ok(!is_blessed(42), 'is_blessed: number');
    ok(!is_blessed('string'), 'is_blessed: string');
    ok(!is_blessed([]), 'is_blessed: unblessed array');
    ok(!is_blessed({}), 'is_blessed: unblessed hash');
    ok(!is_blessed(sub {}), 'is_blessed: unblessed code');

    # Blessed
    my $obj = bless {}, 'MyClass';
    ok(is_blessed($obj), 'is_blessed: blessed hash');

    my $arr = bless [], 'MyArray';
    ok(is_blessed($arr), 'is_blessed: blessed array');