jQuery Matchers

/**
 * Checks if element is visible (has width/height > 0 and not hidden)
 * Elements are visible if they consume space in the document
 */
expect(element).toBeVisible();

expect($('#modal')).toBeVisible();
expect($('.notification')).not.toBeVisible();

/**
 * Checks if element is hidden via CSS display:none, visibility:hidden, 
 * width/height of 0, or hidden form input type
 */
expect(element).toBeHidden();

/**
 * Checks if form element has checked attribute/property
 * Only applies to elements that can be checked
 */
expect(element).toBeChecked();

expect($('input[type="checkbox"]')).toBeChecked();
expect($('input[name="gender"][value="male"]')).not.toBeChecked();

/**
 * Checks if option element has selected attribute/property
 * Only applies to <option> elements
 */
expect(element).toBeSelected();

/**
 * Checks if element has disabled attribute/property
 */
expect(element).toBeDisabled();

/**
 * Checks if element is the currently active/focused element
 */
expect(element).toBeFocused();

$('#username').focus();
expect($('#username')).toBeFocused();

/**
 * Checks if element is empty (no child DOM elements or text)
 */
expect(element).toBeEmpty();

/**
 * Checks if element is present in the document DOM tree
 */
expect(element).toBeInDOM();

/**
 * Checks if jQuery selector matches any elements
 */
expect(element).toExist();

/**
 * Checks if element has the specified CSS class
 * @param className - CSS class name to check for
 */
expect(element).toHaveClass(className);

expect($('#alert')).toHaveClass('error');
expect($('.button')).toHaveClass('btn-primary');

/**
 * Checks if element has specified attribute with optional value
 * @param attributeName - HTML attribute name
 * @param attributeValue - Expected attribute value (optional)
 */
expect(element).toHaveAttr(attributeName, attributeValue);

// Check attribute exists
expect($('input')).toHaveAttr('required');

// Check attribute value  
expect($('img')).toHaveAttr('src', '/images/logo.png');
expect($('a')).toHaveAttr('href', 'https://example.com');

/**
 * Checks if element has specified property with optional value
 * @param propertyName - DOM property name
 * @param propertyValue - Expected property value (optional)  
 */
expect(element).toHaveProp(propertyName, propertyValue);

expect($('input[type="checkbox"]')).toHaveProp('checked', true);
expect($('select')).toHaveProp('selectedIndex', 2);

/**
 * Checks if element has specified ID
 * @param id - Expected ID value
 */
expect(element).toHaveId(id);

/**
 * Checks if element text matches expected value or regex pattern
 * @param text - Expected text string or RegExp pattern
 */
expect(element).toHaveText(text);

expect($('#message')).toHaveText('Welcome!');
expect($('.error')).toHaveText(/invalid/i);

/**
 * Checks if element innerHTML matches expected HTML
 * @param html - Expected HTML string
 */
expect(element).toHaveHtml(html);

/**
 * Checks if form element has specified value
 * @param value - Expected form value
 */
expect(element).toHaveValue(value);

expect($('input[name="email"]')).toHaveValue('user@example.com');
expect($('textarea')).toHaveValue('');

/**
 * Checks if element has specified data attribute with optional value
 * @param key - Data attribute key
 * @param value - Expected data value (optional)
 */
expect(element).toHaveData(key, value);

expect($('#user')).toHaveData('id', 123);
expect($('.widget')).toHaveData('config');

/**
 * Checks if element has specified CSS properties and values
 * @param cssProperties - Object with CSS property-value pairs
 */
expect(element).toHaveCss(cssProperties);

expect($('#modal')).toHaveCss({display: 'block'});
expect($('.button')).toHaveCss({
  'background-color': 'rgb(255, 0, 0)',
  'font-size': '14px'
});

/**
 * Checks if jQuery collection has specified number of elements
 * @param length - Expected number of elements
 */
expect(element).toHaveLength(length);

expect($('.menu-item')).toHaveLength(5);
expect($('ul li')).toHaveLength(3);

/**
 * Checks if element contains descendant matching selector
 * @param selector - CSS selector to find within element
 */
expect(element).toContainElement(selector);

expect($('#form')).toContainElement('input[type="submit"]');
expect($('.modal')).toContainElement('.close-button');

/**
 * Checks if element text content contains specified string or matches regex
 * @param text - Text string or RegExp pattern to find
 */
expect(element).toContainText(text);

/**
 * Checks if element HTML content contains specified HTML string
 * @param html - HTML string to find within element
 */
expect(element).toContainHtml(html);

/**
 * Checks if element matches the given CSS selector
 * @param selector - CSS selector to match against
 */
expect(element).toBeMatchedBy(selector);

expect($('.button.primary')).toBeMatchedBy('.button');
expect($('#nav ul li')).toBeMatchedBy('li');

/**
 * Checks if element has registered event handler for event type
 * @param eventName - Event name (can include namespaces like 'click.myapp')
 */
expect(element).toHandle(eventName);

expect($('#button')).toHandle('click');
expect($('#form')).toHandle('submit.validation');

/**
 * Checks if element has the exact event handler function registered
 * @param eventName - Event name
 * @param eventHandler - Specific handler function to check for
 */
expect(element).toHandleWith(eventName, eventHandler);

function myClickHandler() { /* ... */ }
$('#button').on('click', myClickHandler);
expect($('#button')).toHandleWith('click', myClickHandler);

/**
 * Normalizes HTML tag case for cross-browser comparison
 * Helps ensure consistent HTML comparisons across different browsers
 * @param html - HTML string to normalize
 * @returns Normalized HTML string
 */
function jasmine.jQuery.browserTagCaseIndependentHtml(html);

var normalizedHtml = jasmine.jQuery.browserTagCaseIndependentHtml('<DIV>content</DIV>');
// Returns: '<div>content</div>' (lowercase tags)

/**
 * Converts jQuery element(s) to string representation using outerHTML
 * Useful for debugging and custom matcher implementations  
 * @param element - jQuery element or collection
 * @returns String representation of element(s)
 */
function jasmine.jQuery.elementToString(element);

var elementString = jasmine.jQuery.elementToString($('<div class="test">Hello</div>'));
// Returns: '<div class="test">Hello</div>'

var multipleElements = jasmine.jQuery.elementToString($('<span>A</span><span>B</span>'));
// Returns: '<span>A</span>, <span>B</span>'

expect($('#hidden-element')).not.toBeVisible();
expect($('input')).not.toHaveClass('error');  
expect($('.empty-list')).not.toContainElement('li');