File Coverage

blib/lib/Playwright/GenericAssertions.pm

Criterion	Covered	Total	%
statement	9	81	11.1
branch			n/a
condition			n/a
subroutine	3	39	7.6
pod	35	36	97.2
total	47	156	30.1

# ABSTRACT: Automatically generated class for Playwright::GenericAssertions
# PODNAME: Playwright::GenericAssertions

# These classes used to be generated at runtime, but are now generated when the module is built.
# Don't send patches against these modules, they will be ignored.
# See generate_perl_modules.pl in the repository for generating this.

use strict;
use warnings;

package Playwright::GenericAssertions;
$Playwright::GenericAssertions::VERSION = '1.551';
use parent 'Playwright::Base';

sub new {
    my ( $self, %options ) = @_;
    $options{type} = 'GenericAssertions';
    return $self->SUPER::new(%options);
}

sub spec {
    return $Playwright::spec->{'GenericAssertions'}{members};
}

sub toThrowError {
    my $self = shift;
    return $self->_api_request(
        args    => [@_],
        command => 'toThrowError',
        object  => $self->{guid},
        type    => $self->{type}
    );
}

sub objectContaining {
    my $self = shift;
    return $self->_api_request(
        args    => [@_],
        command => 'objectContaining',
        object  => $self->{guid},
        type    => $self->{type}
    );
}

sub toContain {
    my $self = shift;
    return $self->_api_request(
        args    => [@_],
        command => 'toContain',
        object  => $self->{guid},
        type    => $self->{type}
    );
}

sub closeTo {
    my $self = shift;
    return $self->_api_request(
        args    => [@_],
        command => 'closeTo',
        object  => $self->{guid},
        type    => $self->{type}
    );
}

sub toBeUndefined {
    my $self = shift;
    return $self->_api_request(
        args    => [@_],
        command => 'toBeUndefined',
        object  => $self->{guid},
        type    => $self->{type}
    );
}

sub toEqual {
    my $self = shift;
    return $self->_api_request(
        args    => [@_],
        command => 'toEqual',
        object  => $self->{guid},
        type    => $self->{type}
    );
}

sub toMatch {
    my $self = shift;
    return $self->_api_request(
        args    => [@_],
        command => 'toMatch',
        object  => $self->{guid},
        type    => $self->{type}
    );
}

sub toBe {
    my $self = shift;
    return $self->_api_request(
        args    => [@_],
        command => 'toBe',
        object  => $self->{guid},
        type    => $self->{type}
    );
}

sub toBeLessThan {
    my $self = shift;
    return $self->_api_request(
        args    => [@_],
        command => 'toBeLessThan',
        object  => $self->{guid},
        type    => $self->{type}
    );
}

sub toBeGreaterThan {
    my $self = shift;
    return $self->_api_request(
        args    => [@_],
        command => 'toBeGreaterThan',
        object  => $self->{guid},
        type    => $self->{type}
    );
}

sub not {
    my $self = shift;
    return $self->_api_request(
        args    => [@_],
        command => 'not',
        object  => $self->{guid},
        type    => $self->{type}
    );
}

sub any {
    my $self = shift;
    return $self->_api_request(
        args    => [@_],
        command => 'any',
        object  => $self->{guid},
        type    => $self->{type}
    );
}

sub toHaveProperty {
    my $self = shift;
    return $self->_api_request(
        args    => [@_],
        command => 'toHaveProperty',
        object  => $self->{guid},
        type    => $self->{type}
    );
}

sub toBeLessThanOrEqual {
    my $self = shift;
    return $self->_api_request(
        args    => [@_],
        command => 'toBeLessThanOrEqual',
        object  => $self->{guid},
        type    => $self->{type}
    );
}

sub toBeNull {
    my $self = shift;
    return $self->_api_request(
        args    => [@_],
        command => 'toBeNull',
        object  => $self->{guid},
        type    => $self->{type}
    );
}

sub toBeCloseTo {
    my $self = shift;
    return $self->_api_request(
        args    => [@_],
        command => 'toBeCloseTo',
        object  => $self->{guid},
        type    => $self->{type}
    );
}

sub toBeGreaterThanOrEqual {
    my $self = shift;
    return $self->_api_request(
        args    => [@_],
        command => 'toBeGreaterThanOrEqual',
        object  => $self->{guid},
        type    => $self->{type}
    );
}

sub arrayContaining {
    my $self = shift;
    return $self->_api_request(
        args    => [@_],
        command => 'arrayContaining',
        object  => $self->{guid},
        type    => $self->{type}
    );
}

sub stringMatching {
    my $self = shift;
    return $self->_api_request(
        args    => [@_],
        command => 'stringMatching',
        object  => $self->{guid},
        type    => $self->{type}
    );
}

sub stringContaining {
    my $self = shift;
    return $self->_api_request(
        args    => [@_],
        command => 'stringContaining',
        object  => $self->{guid},
        type    => $self->{type}
    );
}

sub toMatchObject {
    my $self = shift;
    return $self->_api_request(
        args    => [@_],
        command => 'toMatchObject',
        object  => $self->{guid},
        type    => $self->{type}
    );
}

sub anything {
    my $self = shift;
    return $self->_api_request(
        args    => [@_],
        command => 'anything',
        object  => $self->{guid},
        type    => $self->{type}
    );
}

sub toBeFalsy {
    my $self = shift;
    return $self->_api_request(
        args    => [@_],
        command => 'toBeFalsy',
        object  => $self->{guid},
        type    => $self->{type}
    );
}

sub toContainEqual {
    my $self = shift;
    return $self->_api_request(
        args    => [@_],
        command => 'toContainEqual',
        object  => $self->{guid},
        type    => $self->{type}
    );
}

sub toHaveLength {
    my $self = shift;
    return $self->_api_request(
        args    => [@_],
        command => 'toHaveLength',
        object  => $self->{guid},
        type    => $self->{type}
    );
}

sub toStrictEqual {
    my $self = shift;
    return $self->_api_request(
        args    => [@_],
        command => 'toStrictEqual',
        object  => $self->{guid},
        type    => $self->{type}
    );
}

sub toThrow {
    my $self = shift;
    return $self->_api_request(
        args    => [@_],
        command => 'toThrow',
        object  => $self->{guid},
        type    => $self->{type}
    );
}

sub toBeInstanceOf {
    my $self = shift;
    return $self->_api_request(
        args    => [@_],
        command => 'toBeInstanceOf',
        object  => $self->{guid},
        type    => $self->{type}
    );
}

sub toBeNaN {
    my $self = shift;
    return $self->_api_request(
        args    => [@_],
        command => 'toBeNaN',
        object  => $self->{guid},
        type    => $self->{type}
    );
}

sub toBeTruthy {
    my $self = shift;
    return $self->_api_request(
        args    => [@_],
        command => 'toBeTruthy',
        object  => $self->{guid},
        type    => $self->{type}
    );
}

sub toBeDefined {
    my $self = shift;
    return $self->_api_request(
        args    => [@_],
        command => 'toBeDefined',
        object  => $self->{guid},
        type    => $self->{type}
    );
}

sub on {
    my $self = shift;
    return $self->_api_request(
        args    => [@_],
        command => 'on',
        object  => $self->{guid},
        type    => $self->{type}
    );
}

sub evaluate {
    my $self = shift;
    return $self->_api_request(
        args    => [@_],
        command => 'evaluate',
        object  => $self->{guid},
        type    => $self->{type}
    );
}

sub evaluateHandle {
    my $self = shift;
    return $self->_api_request(
        args    => [@_],
        command => 'evaluateHandle',
        object  => $self->{guid},
        type    => $self->{type}
    );
}

1;

__END__