Moodle PHP Documentation 4.2
Moodle 4.2.8 (Build: 20240610) (2d41ac46f45)
behat_theme_classic_behat_general Class Reference
Inheritance diagram for behat_theme_classic_behat_general:
behat_general behat_base behat_session_interface

Public Member Functions

 a_new_page_should_have_loaded_since_i_started_watching ()
 Verify that a new page has loaded (or the same page has reloaded) since the last "I start watching to see if a new page loads" step.
 
 a_new_page_should_not_have_loaded_since_i_started_watching ()
 Verify that a new page has not loaded (or the same page has reloaded) since the last "I start watching to see if a new page loads" step.
 
 accept_currently_displayed_alert_dialog ()
 Accepts the currently displayed alert dialog.
 
 assert_element_contains_text ($text, $element, $selectortype)
 Checks, that the specified element contains the specified text.
 
 assert_element_not_contains_text ($text, $element, $selectortype)
 Checks, that the specified element does not contain the specified text.
 
 assert_page_contains_text ($text)
 Checks, that page contains specified text.
 
 assert_page_not_contains_text ($text)
 Checks, that page doesn't contain specified text.
 
 click_link ($link)
 Clicks link with specified id|title|alt|text.
 
 database_family_used_is_one_of_the_following (TableNode $databasefamilies)
 Checks if database family used is using one of the specified, else skip.
 
 dismiss_currently_displayed_alert_dialog ()
 Dismisses the currently displayed alert dialog.
 
 download_file_from_link ($link)
 Given the text of a link, download the linked file and return the contents.
 
 edit_mode_should_be_available (bool $not=false)
 Ensure that edit mode is (not) available on the current page.
 
 following_should_download_between_and_bytes ($link, $minexpectedsize, $maxexpectedsize)
 Downloads the file from a link on the page and checks the size is in a given range.
 
 following_should_download_bytes ($link, $expectedsize)
 Downloads the file from a link on the page and checks the size.
 
 following_should_exist_in_the_table ($table, TableNode $data)
 Checks that the provided value exist in table.
 
 following_should_not_exist_in_the_table ($table, TableNode $data)
 Checks that the provided values do not exist in a table.
 
 getSession ($name=null)
 Returns the Mink session.
 
 i_am_on_course_index ()
 Opens course index page.
 
 i_am_on_homepage ()
 Opens Moodle homepage.
 
 i_am_on_site_homepage ()
 Opens Moodle site homepage.
 
 i_change_window_size_to ($windowviewport, $windowsize)
 Change browser window size.
 
 i_click_on ($element, $selectortype)
 Generic click action.
 
 i_click_on_confirming_the_dialogue ($element, $selectortype)
 Clicks the specified element and confirms the expected dialogue.
 
 i_click_on_dismissing_the_dialogue ($element, $selectortype)
 Clicks the specified element and dismissing the expected dialogue.
 
 i_click_on_in_the ($element, $selectortype, $nodeelement, $nodeselectortype)
 Click on the element of the specified type which is located inside the second element.
 
 i_click_on_skipping_visibility_check ($element, $selectortype)
 Trigger click on node via javascript instead of actually clicking on it via pointer.
 
 i_click_on_the_dynamic_tab (string $tabname)
 Click on a dynamic tab to load its content.
 
 i_close_all_opened_windows ()
 Closes all extra windows opened during the navigation.
 
 i_drag_and_i_drop_it_in ($source, $sourcetype, $target, $targettype)
 Drags and drops the specified element to the specified container.
 
 i_enable_plugin ($plugin, $plugintype)
 Enable an specific plugin.
 
 i_hover ($element, $selectortype)
 Generic mouse over action.
 
 i_hover_in_the (string $element, $selectortype, string $containerelement, $containerselectortype)
 Generic mouse over action.
 
 i_key_click_on_in_the ($modifier, $element, $selectortype, $nodeelement, $nodeselectortype)
 Click on the element with some modifier key pressed (alt, shift, meta or control).
 
 i_manually_press_enter ()
 Manually press enter key.
 
 i_manually_press_tab ($shift='')
 Manually press tab key.
 
 i_mark_this_test_as_long_running (int $factor=2)
 Increase the webdriver timeouts.
 
 i_pause_scenario_execution ()
 Wait unit user press Enter/Return key.
 
 i_post_tab_key_in_element ($element, $selectortype)
 Press tab key on a specific element.
 
 i_press_in_the_browser ($button)
 Presses a given button in the browser.
 
 i_press_key_in_element ($key, $element, $selectortype)
 Trigger a keydown event for a key on a specific element.
 
 i_press_named_key (string $modifiers, string $key)
 Press a named or character key with an optional set of modifiers.
 
 i_run_all_adhoc_tasks ()
 Runs all ad-hoc tasks in the queue.
 
 i_run_the_scheduled_task ($taskname)
 Runs a scheduled task immediately, given full class name.
 
 i_should_see_node_occurrences_of_type_in_element (int $elementscount, string $nodetype, string $element, string $selectortype)
 Checks, that the specified element contains the specified node type a certain amount of times.
 
 i_should_see_occurrences_of_in_element ($elementscount, $text, $element, $selectortype)
 Checks, that the specified element contains the specified text a certain amount of times.
 
 i_start_watching_to_see_if_a_new_page_loads ()
 Prepare to detect whether or not a new page has loaded (or the same page reloaded) some time in the future.
 
 i_take_focus_off_field ($element, $selectortype)
 Sets the focus and takes away the focus from an element, generating blur JS event.
 
 i_trigger_cron ()
 This step triggers cron like a user would do going to admin/cron.php.
 
 i_type (string $keys)
 Send key presses to the browser without first changing focusing, or applying the key presses to a specific element.
 
 i_visit ($localurl)
 Visit a local URL relative to the behat root.
 
 i_wait_seconds ($seconds)
 Waits X seconds.
 
 i_wait_to_be_redirected ()
 Follows the page redirection.
 
 in_the_should_be_visible ($element, $selectortype, $nodeelement, $nodeselectortype)
 Checks, that the specified element is visible inside the specified container.
 
 in_the_should_not_be_visible ($element, $selectortype, $nodeelement, $nodeselectortype)
 Checks, that the existing element is not visible inside the existing container.
 
 is_edit_mode_available ()
 Check whether edit mode is available on the current page.
 
 plugin_is_installed (string $plugin)
 Checks if given plugin is installed, and skips the current scenario if not.
 
 reload ()
 Reloads the current page.
 
 row_column_of_table_should_contain ($row, $column, $table, $value)
 Checks the provided value exists in specific row/column of table.
 
 row_column_of_table_should_not_contain ($row, $column, $table, $value)
 Checks the provided value should not exist in specific row/column of table.
 
 should_appear_after (string $postelement, string $postselectortype, string $preelement, string $preselectortype, ?string $containerelement=null, ?string $containerselectortype=null)
 Checks, that the first specified element appears after the second one.
 
 should_appear_before (string $preelement, string $preselectortype, string $postelement, string $postselectortype, ?string $containerelement=null, ?string $containerselectortype=null)
 Checks, that the first specified element appears before the second one.
 
 should_be_visible ($element, $selectortype)
 Checks, that the specified element is visible.
 
 should_exist ($element, $selectortype)
 Checks the provided element and selector type exists in the current page.
 
 should_exist_in_the ($element, $selectortype, $containerelement, $containerselectortype)
 Checks that an element and selector type exists in another element and selector type on the current page.
 
 should_not_be_visible ($element, $selectortype)
 Checks, that the existing element is not visible.
 
 should_not_exist ($element, $selectortype)
 Checks that the provided element and selector type not exists in the current page.
 
 should_not_exist_in_the ($element, $selectortype, $containerelement, $containerselectortype)
 Checks that an element and selector type does not exist in another element and selector type on the current page.
 
 switch_to_iframe ($name)
 Switches to the specified iframe.
 
 switch_to_second_window ()
 Switches to a second window.
 
 switch_to_the_main_frame ()
 Switches to the main Moodle frame.
 
 switch_to_the_main_window ()
 Switches to the main Moodle window.
 
 switch_to_window ($windowname)
 Switches to the specified window.
 
 the_attribute_of_should_be_set ($attribute, $element, $selectortype, $not=null)
 Checks whether there the specified attribute is set or not.
 
 the_attribute_of_should_contain ($attribute, $element, $selectortype, $text)
 Checks whether there is an attribute on the given element that contains the specified text.
 
 the_attribute_of_should_not_contain ($attribute, $element, $selectortype, $text)
 Checks that the attribute on the given element does not contain the specified text.
 
 the_default_editor_is_set_to (string $editor)
 Set the default text editor to the named text editor.
 
 the_element_should_be_disabled ($element, $selectortype)
 Checks, that element of specified type is disabled.
 
 the_element_should_be_enabled ($element, $selectortype)
 Checks, that element of specified type is enabled.
 
 the_element_should_be_readonly ($element, $selectortype)
 Checks the provided element and selector type are readonly on the current page.
 
 the_element_should_not_be_readonly ($element, $selectortype)
 Checks the provided element and selector type are not readonly on the current page.
 
 the_focused_element_is ($not, $nodeelement, $nodeselectortype)
 Checks focus is with the given element.
 
 the_focused_element_is_in_the ($not, $element, $selectortype, $nodeelement, $nodeselectortype)
 Checks focus is with the given element.
 
 the_image_at_should_be_identical_to ($element, $selectortype, $filepath)
 Checks that the image on the page is the same as one of the fixture files.
 
 the_page_title_should_contain (string $title)
 Check that the page title contains a given string.
 
 the_site_is_running_moodle_version_or_higher (string $minversion)
 Allow to check for minimal Moodle version.
 
 the_site_is_running_moodle_version_or_lower (string $maxversion)
 Allow to check for maximum Moodle version.
 
 wait_until_does_not_exists ($element, $selectortype)
 Waits until the provided element does not exist in the DOM.
 
 wait_until_exists ($element, $selectortype)
 Waits until the provided element selector exists in the DOM.
 
 wait_until_the_page_is_ready ()
 Waits until the page is completely loaded.
 

Public Attributes

string const MAIN_WINDOW_NAME = '__moodle_behat_main_window_name'
 used by switch_to_window() and switch_to_the_main_window() to work-around a Chrome browser issue.
 
string const PAGE_LOAD_DETECTION_STRING = 'new_page_not_loaded_since_behat_started_watching'
 when we want to check whether or not a new page has loaded, we first write this unique string into the page.
 
const PAGE_READY_JS
 The JS code to check that the page is ready.
 

Protected Member Functions

 check_element_order (?string $containerelement, ?string $containerselectortype, string $preelement, string $preselectortype, string $postelement, string $postselectortype, string $msg)
 Shared code to check whether an element is before or after another one.
 
 get_page_load_xpath ()
 Helper used by a_new_page_should_have_loaded_since_i_started_watching and a_new_page_should_not_have_loaded_since_i_started_watching.
 

Detailed Description

Member Function Documentation

◆ a_new_page_should_have_loaded_since_i_started_watching()

behat_general::a_new_page_should_have_loaded_since_i_started_watching ( )
inherited

Verify that a new page has loaded (or the same page has reloaded) since the last "I start watching to see if a new page loads" step.

@Given /^a new page should have loaded since I started watching$/

◆ a_new_page_should_not_have_loaded_since_i_started_watching()

behat_general::a_new_page_should_not_have_loaded_since_i_started_watching ( )
inherited

Verify that a new page has not loaded (or the same page has reloaded) since the last "I start watching to see if a new page loads" step.

@Given /^a new page should not have loaded since I started watching$/

◆ accept_currently_displayed_alert_dialog()

behat_general::accept_currently_displayed_alert_dialog ( )
inherited

Accepts the currently displayed alert dialog.

This step does not work in all the browsers, consider it experimental. @Given /^I accept the currently displayed dialog$/

◆ assert_element_contains_text()

behat_general::assert_element_contains_text ( $text,
$element,
$selectortype )
inherited

Checks, that the specified element contains the specified text.

When running Javascript tests it also considers that texts may be hidden.

@Then /^I should see "(?P<text_string>(?:[^"]|::")*)" in the "(?P<element_string>(?:[^"]|")*)" "(?P<text_selector_string>[^"]*)"$/

Exceptions
ElementNotFoundException
ExpectationException
Parameters
string$text
string$elementElement we look in.
string$selectortypeThe type of element where we are looking in.

◆ assert_element_not_contains_text()

behat_general::assert_element_not_contains_text ( $text,
$element,
$selectortype )
inherited

Checks, that the specified element does not contain the specified text.

When running Javascript tests it also considers that texts may be hidden.

@Then /^I should not see "(?P<text_string>(?:[^"]|::")*)" in the "(?P<element_string>(?:[^"]|")*)" "(?P<text_selector_string>[^"]*)"$/

Exceptions
ElementNotFoundException
ExpectationException
Parameters
string$text
string$elementElement we look in.
string$selectortypeThe type of element where we are looking in.

◆ assert_page_contains_text()

behat_general::assert_page_contains_text ( $text)
inherited

Checks, that page contains specified text.

It also checks if the text is visible when running Javascript tests.

@Then /^I should see "(?P<text_string>(?:[^"]|::")*)"$/

Exceptions
ExpectationException
Parameters
string$text

◆ assert_page_not_contains_text()

behat_general::assert_page_not_contains_text ( $text)
inherited

Checks, that page doesn't contain specified text.

When running Javascript tests it also considers that texts may be hidden.

@Then /^I should not see "(?P<text_string>(?:[^"]|::")*)"$/

Exceptions
ExpectationException
Parameters
string$text

◆ check_element_order()

behat_general::check_element_order ( ?string $containerelement,
?string $containerselectortype,
string $preelement,
string $preselectortype,
string $postelement,
string $postselectortype,
string $msg )
protectedinherited

Shared code to check whether an element is before or after another one.

Parameters
string$containerelement
string$containerselectortype
string$preelementThe locator of the preceding element
string$preselectortypeThe locator of the preceding element
string$postelementThe locator of the following element
string$postselectortypeThe selector type of the following element
string$msgMessage to output if this fails

◆ click_link()

behat_general::click_link ( $link)
inherited

Clicks link with specified id|title|alt|text.

@When /^I follow "(?P<link_string>(?:[^"]|::")*)"$/

Exceptions
ElementNotFoundExceptionThrown by behat_base\find
Parameters
string$link

◆ database_family_used_is_one_of_the_following()

behat_general::database_family_used_is_one_of_the_following ( TableNode $databasefamilies)
inherited

Checks if database family used is using one of the specified, else skip.

(mysql, postgres, mssql, oracle, etc.)

@Given /^database family used is one of the following:$/

Parameters
TableNode$databasefamilieslist of database.
Return values
void.
Exceptions
Moodle\BehatExtension\Exception\SkippedException

◆ dismiss_currently_displayed_alert_dialog()

behat_general::dismiss_currently_displayed_alert_dialog ( )
inherited

Dismisses the currently displayed alert dialog.

This step does not work in all the browsers, consider it experimental. @Given /^I dismiss the currently displayed dialog$/

◆ download_file_from_link()

behat_general::download_file_from_link ( $link)
inherited

Given the text of a link, download the linked file and return the contents.

This is a helper method used by following_should_download_bytes() and following_should_download_between_and_bytes()

Parameters
string$linkthe text of the link.
Return values
stringthe content of the downloaded file.

◆ edit_mode_should_be_available()

behat_general::edit_mode_should_be_available ( bool $not = false)
inherited

Ensure that edit mode is (not) available on the current page.

@Then edit mode should be available on the current page @Then edit mode should :not be available on the current page

Parameters
bool$not

◆ following_should_download_between_and_bytes()

behat_general::following_should_download_between_and_bytes ( $link,
$minexpectedsize,
$maxexpectedsize )
inherited

Downloads the file from a link on the page and checks the size is in a given range.

Only works if the link has an href attribute. Javascript downloads are not supported. Currently, the href must be an absolute URL.

The range includes the endpoints. That is, a 10 byte file in considered to be between "5" and "10" bytes, and between "10" and "20" bytes.

@Then /^following "(?P<link_string>[^"]*)" should download between "(?P<min_bytes>\d+)" and "(?P<max_bytes>\d+)" bytes$/

Exceptions
ExpectationException
Parameters
string$linkthe text of the link.
number$minexpectedsizethe minimum expected file size in bytes.
number$maxexpectedsizethe maximum expected file size in bytes.

◆ following_should_download_bytes()

behat_general::following_should_download_bytes ( $link,
$expectedsize )
inherited

Downloads the file from a link on the page and checks the size.

Only works if the link has an href attribute. Javascript downloads are not supported. Currently, the href must be an absolute URL.

@Then /^following "(?P<link_string>[^"]*)" should download "(?P<expected_bytes>\d+)" bytes$/

Exceptions
ExpectationException
Parameters
string$linkthe text of the link.
number$expectedsizethe expected file size in bytes.

◆ following_should_exist_in_the_table()

behat_general::following_should_exist_in_the_table ( $table,
TableNode $data )
inherited

Checks that the provided value exist in table.

First row may contain column headers or numeric indexes of the columns (syntax -1- is also considered to be column index). Column indexes are useful in case of multirow headers and/or presence of cells with colspan.

@Then /^the following should exist in the "(?P<table_string>[^"]*)" table:$/

Exceptions
ExpectationException
Parameters
string$tablename of table
TableNode$datatable with first row as header and following values | Header 1 | Header 2 | Header 3 | | Value 1 | Value 2 | Value 3|

◆ following_should_not_exist_in_the_table()

behat_general::following_should_not_exist_in_the_table ( $table,
TableNode $data )
inherited

Checks that the provided values do not exist in a table.

@Then /^the following should not exist in the "(?P<table_string>[^"]*)" table:$/

Exceptions
ExpectationException
Parameters
string$tablename of table
TableNode$datatable with first row as header and following values | Header 1 | Header 2 | Header 3 | | Value 1 | Value 2 | Value 3|

◆ get_page_load_xpath()

behat_general::get_page_load_xpath ( )
protectedinherited

◆ getSession()

behat_session_interface::getSession ( $name = null)
inherited

Returns the Mink session.

Parameters
string | null$namename of the session OR active session will be used
Return values
Behat\Mink\Session

Implemented in behat_form_field.

◆ i_am_on_course_index()

behat_general::i_am_on_course_index ( )
inherited

Opens course index page.

@Given /^I am on course index$/

◆ i_am_on_homepage()

behat_general::i_am_on_homepage ( )
inherited

Opens Moodle homepage.

@Given /^I am on homepage$/

◆ i_am_on_site_homepage()

behat_general::i_am_on_site_homepage ( )
inherited

Opens Moodle site homepage.

@Given /^I am on site homepage$/

◆ i_change_window_size_to()

behat_general::i_change_window_size_to ( $windowviewport,
$windowsize )
inherited

Change browser window size.

Allowed sizes:

  • mobile: 425x750
  • tablet: 768x1024
  • small: 1024x768
  • medium: 1366x768
  • large: 2560x1600
  • custom: widthxheight

Example: I change window size to "small" or I change window size to "1024x768" or I change viewport size to "800x600". The viewport option is useful to guarantee that the browser window has same viewport size even when you run Behat on multiple operating systems.

Exceptions
ExpectationException@Then /^I change (window|viewport) size to "(mobile|tablet|small|medium|large|d+x::d+)"$/ @Then /^I change the (window|viewport) size to "(mobile|tablet|small|medium|large|d+x::d+)"$/
Parameters
string$windowsizesize of the window (mobile|tablet|small|medium|large|wxh).

◆ i_click_on()

behat_general::i_click_on ( $element,
$selectortype )
inherited

Generic click action.

Click on the element of the specified type.

@When /^I click on "(?P<element_string>(?:[^"]|::")*)" "(?P<selector_string>[^"]*)"$/

Parameters
string$elementElement we look for
string$selectortypeThe type of what we look for

◆ i_click_on_confirming_the_dialogue()

behat_general::i_click_on_confirming_the_dialogue ( $element,
$selectortype )
inherited

Clicks the specified element and confirms the expected dialogue.

@When /^I click on "(?P<element_string>(?:[^"]|::")*)" "(?P<selector_string>[^"]*)" confirming the dialogue$/

Exceptions
ElementNotFoundExceptionThrown by behat_base\find
Parameters
string$elementElement we look for
string$selectortypeThe type of what we look for

◆ i_click_on_dismissing_the_dialogue()

behat_general::i_click_on_dismissing_the_dialogue ( $element,
$selectortype )
inherited

Clicks the specified element and dismissing the expected dialogue.

@When /^I click on "(?P<element_string>(?:[^"]|::")*)" "(?P<selector_string>[^"]*)" dismissing the dialogue$/

Exceptions
ElementNotFoundExceptionThrown by behat_base\find
Parameters
string$elementElement we look for
string$selectortypeThe type of what we look for

◆ i_click_on_in_the()

behat_general::i_click_on_in_the ( $element,
$selectortype,
$nodeelement,
$nodeselectortype )
inherited

Click on the element of the specified type which is located inside the second element.

@When /^I click on "(?P<element_string>(?:[^"]|::")*)" "(?P<selector_string>[^"]*)" in the "(?P<element_container_string>(?:[^"]|::")*)" "(?P<text_selector_string>[^"]*)"$/

Parameters
string$elementElement we look for
string$selectortypeThe type of what we look for
string$nodeelementElement we look in
string$nodeselectortypeThe type of selector where we look in

◆ i_click_on_skipping_visibility_check()

behat_general::i_click_on_skipping_visibility_check ( $element,
$selectortype )
inherited

Trigger click on node via javascript instead of actually clicking on it via pointer.

This function resolves the issue of nested elements.

@When /^I click on "(?P<element_string>(?:[^"]|::")*)" "(?P<selector_string>[^"]*)" skipping visibility check$/

Parameters
string$element
string$selectortype

◆ i_click_on_the_dynamic_tab()

behat_general::i_click_on_the_dynamic_tab ( string $tabname)
inherited

Click on a dynamic tab to load its content.

@Given /^I click on the "(?P<tab_string>(?:[^"]|::")*)" dynamic tab$/

Parameters
string$tabname

◆ i_close_all_opened_windows()

behat_general::i_close_all_opened_windows ( )
inherited

Closes all extra windows opened during the navigation.

This assumes all popups are opened by the main tab and you will now get back.

@Given /^I close all opened windows$/

Exceptions
DriverExceptionIf there aren't exactly 1 tabs open when finish or no javascript running

◆ i_drag_and_i_drop_it_in()

behat_general::i_drag_and_i_drop_it_in ( $source,
$sourcetype,
$target,
$targettype )
inherited

Drags and drops the specified element to the specified container.

This step does not work in all the browsers, consider it experimental.

The steps definitions calling this step as part of them should manage the wait times by themselves as the times and when the waits should be done depends on what is being dragged & dropper.

@Given /^I drag "(?P<element_string>(?:[^"]|::")*)" "(?P<selector1_string>(?:[^"]|")*)" and I drop it in "(?P<container_element_string>(?:[^"]|::")*)" "(?P<selector2_string>(?:[^"]|\")*)"$/

Parameters
string$element
string$selectortype
string$containerelement
string$containerselectortype

◆ i_enable_plugin()

behat_general::i_enable_plugin ( $plugin,
$plugintype )
inherited

Enable an specific plugin.

@When /^I enable "(?P<plugin_string>(?:[^"]|::")*)" "(?P<plugintype_string>[^"]*)" plugin$/

Parameters
string$pluginPlugin we look for
string$plugintypeThe type of the plugin

◆ i_hover()

behat_general::i_hover ( $element,
$selectortype )
inherited

Generic mouse over action.

Mouse over a element of the specified type.

@When /^I hover "(?P<element_string>(?:[^"]|::")*)" "(?P<selector_string>[^"]*)"$/

Parameters
string$elementElement we look for
string$selectortypeThe type of what we look for

◆ i_hover_in_the()

behat_general::i_hover_in_the ( string $element,
$selectortype,
string $containerelement,
$containerselectortype )
inherited

Generic mouse over action.

Mouse over a element of the specified type.

@When /^I hover over the "(?P<element_string>(?:[^"]|::")*)" "(?P<selector_string>[^"]*) in the "(?P<container_element_string>(?:[^"]|::")*)" "(?P<container_selector_string>[^"]*)"$/

Parameters
string$elementElement we look for
string$selectortypeThe type of what we look for
string$containerelementElement we look for
string$containerselectortypeThe type of what we look for

◆ i_key_click_on_in_the()

behat_general::i_key_click_on_in_the ( $modifier,
$element,
$selectortype,
$nodeelement,
$nodeselectortype )
inherited

Click on the element with some modifier key pressed (alt, shift, meta or control).

It is important to note that not all HTML elements are compatible with this step because the webdriver limitations. For example, alt click on checkboxes with a visible label will produce a normal checkbox click without the modifier.

@When I :modifier click on :element :selectortype in the :nodeelement :nodeselectortype

Parameters
string$modifierthe extra modifier to press (for example, alt+shift or shift)
string$elementElement we look for
string$selectortypeThe type of what we look for
string$nodeelementElement we look in
string$nodeselectortypeThe type of selector where we look in

◆ i_manually_press_enter()

behat_general::i_manually_press_enter ( )
inherited

Manually press enter key.

@When /^I press enter/

Exceptions
DriverException

◆ i_manually_press_tab()

behat_general::i_manually_press_tab ( $shift = '')
inherited

Manually press tab key.

@When /^I press( shift)? tab$/

Parameters
string$shiftstring optional step verifier
Exceptions
DriverException

◆ i_mark_this_test_as_long_running()

behat_general::i_mark_this_test_as_long_running ( int $factor = 2)
inherited

Increase the webdriver timeouts.

This should be reset between scenarios, or can be called again to decrease the timeouts.

@Given I mark this test as slow setting a timeout factor of :factor

◆ i_pause_scenario_execution()

behat_general::i_pause_scenario_execution ( )
inherited

Wait unit user press Enter/Return key.

Useful when debugging a scenario.

@Then /^(?:|I )pause(?:| scenario execution)$/

◆ i_post_tab_key_in_element()

behat_general::i_post_tab_key_in_element ( $element,
$selectortype )
inherited

Press tab key on a specific element.

@When /^I press tab key in "(?P<element_string>(?:[^"]|::")*)" "(?P<selector_string>[^"]*)"$/

Parameters
string$elementElement we look for
string$selectortypeThe type of what we look for
Exceptions
DriverException
ExpectationException

◆ i_press_in_the_browser()

behat_general::i_press_in_the_browser ( $button)
inherited

Presses a given button in the browser.

NOTE: Phantomjs and goutte driver reloads page while navigating back and forward.

@Then /^I press the "(back|forward|reload)" button in the browser$/

Parameters
string$buttonthe button to press.
Exceptions
ExpectationException

◆ i_press_key_in_element()

behat_general::i_press_key_in_element ( $key,
$element,
$selectortype )
inherited

Trigger a keydown event for a key on a specific element.

@When /^I press key "(?P<key_string>(?:[^"]|::")*)" in "(?P<element_string>(?:[^"]|")*)" "(?P<selector_string>[^"]*)"$/

Parameters
string$keyeither char-code or character itself, may optionally be prefixed with ctrl-, alt-, shift- or meta-
string$elementElement we look for
string$selectortypeThe type of what we look for
Exceptions
DriverException
ExpectationException

◆ i_press_named_key()

behat_general::i_press_named_key ( string $modifiers,
string $key )
inherited

Press a named or character key with an optional set of modifiers.

Supported named keys are:

  • up
  • down
  • left
  • right
  • pageup|page_up
  • pagedown|page_down
  • home
  • end
  • insert
  • delete
  • backspace
  • escape
  • enter
  • tab

You can also use a single character for the key name e.g. 'Ctrl C'.

Supported moderators are:

  • shift
  • ctrl
  • alt
  • meta

Example usage of this new step: When I press the up key When I press the space key When I press the shift tab key

Multiple moderator keys can be combined using the '+' operator, for example: When I press the ctrl+shift enter key When I press the ctrl + shift enter key

@When /^I press the (?P<modifiers_string>.* )?(?P<key_string>.*) key$/

Parameters
string$modifiersA list of keyboard modifiers, separated by the + character
string$keyThe name of the key to press

◆ i_run_all_adhoc_tasks()

behat_general::i_run_all_adhoc_tasks ( )
inherited

Runs all ad-hoc tasks in the queue.

This is faster and more reliable than running cron (running cron won't work more than once in the same test, for instance). However it is a little less 'realistic'.

While the task is running, we suppress mtrace output because it makes the Behat result look ugly.

@Given /^I run all adhoc tasks$/

Exceptions
DriverException

◆ i_run_the_scheduled_task()

behat_general::i_run_the_scheduled_task ( $taskname)
inherited

Runs a scheduled task immediately, given full class name.

This is faster and more reliable than running cron (running cron won't work more than once in the same test, for instance). However it is a little less 'realistic'.

While the task is running, we suppress mtrace output because it makes the Behat result look ugly.

Note: Most of the code relating to running a task is based on admin/cli/scheduled_task.php.

@Given /^I run the scheduled task "(?P<task_name>[^"]+)"$/

Parameters
string$tasknameName of task e.g. 'mod_whatever\task\do_something'

◆ i_should_see_node_occurrences_of_type_in_element()

behat_general::i_should_see_node_occurrences_of_type_in_element ( int $elementscount,
string $nodetype,
string $element,
string $selectortype )
inherited

Checks, that the specified element contains the specified node type a certain amount of times.

When running Javascript tests it also considers that texts may be hidden.

@Then /^I should see "(?P<elementscount_number>::d+)" node occurrences of type "(?P<node_type>(?:[^"]|")*)" in the "(?P<element_string>(?:[^"]|::")*)" "(?P<text_selector_string>[^"]*)"$/

Exceptions
ElementNotFoundException
ExpectationException
Parameters
int$elementscountHow many occurrences of the element we look for.
string$nodetype
string$elementElement we look in.
string$selectortypeThe type of element where we are looking in.

◆ i_should_see_occurrences_of_in_element()

behat_general::i_should_see_occurrences_of_in_element ( $elementscount,
$text,
$element,
$selectortype )
inherited

Checks, that the specified element contains the specified text a certain amount of times.

When running Javascript tests it also considers that texts may be hidden.

@Then /^I should see "(?P<elementscount_number>::d+)" occurrences of "(?P<text_string>(?:[^"]|")*)" in the "(?P<element_string>(?:[^"]|::")*)" "(?P<text_selector_string>[^"]*)"$/

Exceptions
ElementNotFoundException
ExpectationException
Parameters
int$elementscountHow many occurrences of the element we look for.
string$text
string$elementElement we look in.
string$selectortypeThe type of element where we are looking in.

◆ i_start_watching_to_see_if_a_new_page_loads()

behat_general::i_start_watching_to_see_if_a_new_page_loads ( )
inherited

Prepare to detect whether or not a new page has loaded (or the same page reloaded) some time in the future.

@Given /^I start watching to see if a new page loads$/

◆ i_take_focus_off_field()

behat_general::i_take_focus_off_field ( $element,
$selectortype )
inherited

Sets the focus and takes away the focus from an element, generating blur JS event.

@When /^I take focus off "(?P<element_string>(?:[^"]|::")*)" "(?P<selector_string>[^"]*)"$/

Parameters
string$elementElement we look for
string$selectortypeThe type of what we look for

◆ i_trigger_cron()

behat_general::i_trigger_cron ( )
inherited

This step triggers cron like a user would do going to admin/cron.php.

@Given /^I trigger cron$/

◆ i_type()

behat_general::i_type ( string $keys)
inherited

Send key presses to the browser without first changing focusing, or applying the key presses to a specific element.

Example usage of this step: When I type "Penguin"

@When I type :keys

Parameters
string$keysThe key, or list of keys, to type

◆ i_visit()

behat_general::i_visit ( $localurl)
inherited

Visit a local URL relative to the behat root.

@When I visit :localurl

Parameters
string | moodle_url$localurlThe URL relative to the behat_wwwroot to visit.

◆ i_wait_seconds()

behat_general::i_wait_seconds ( $seconds)
inherited

Waits X seconds.

Required after an action that requires data from an AJAX request.

@Then /^I wait "(?P<seconds_number>::d+)" seconds$/

Parameters
int$seconds

◆ i_wait_to_be_redirected()

behat_general::i_wait_to_be_redirected ( )
inherited

Follows the page redirection.

Use this step after any action that shows a message and waits for a redirection

@Given /^I wait to be redirected$/

◆ in_the_should_be_visible()

behat_general::in_the_should_be_visible ( $element,
$selectortype,
$nodeelement,
$nodeselectortype )
inherited

Checks, that the specified element is visible inside the specified container.

Only available in tests using Javascript.

@Then /^"(?P<element_string>(?:[^"]|::")*)" "(?P<selector_string>[^"]*)" in the "(?P<element_container_string>(?:[^"]|::")*)" "(?P<text_selector_string>[^"]*)" should be visible$/

Exceptions
ElementNotFoundException
DriverException
ExpectationException
Parameters
string$elementElement we look for
string$selectortypeThe type of what we look for
string$nodeelementElement we look in
string$nodeselectortypeThe type of selector where we look in

◆ in_the_should_not_be_visible()

behat_general::in_the_should_not_be_visible ( $element,
$selectortype,
$nodeelement,
$nodeselectortype )
inherited

Checks, that the existing element is not visible inside the existing container.

Only available in tests using Javascript.

As a "not" method, it's performance could not be good, but in this case the performance is good because the element must exist, otherwise there would be a ElementNotFoundException, also here we are not spinning until the element is visible.

@Then /^"(?P<element_string>(?:[^"]|::")*)" "(?P<selector_string>[^"]*)" in the "(?P<element_container_string>(?:[^"]|::")*)" "(?P<text_selector_string>[^"]*)" should not be visible$/

Exceptions
ElementNotFoundException
ExpectationException
Parameters
string$elementElement we look for
string$selectortypeThe type of what we look for
string$nodeelementElement we look in
string$nodeselectortypeThe type of selector where we look in

◆ is_edit_mode_available()

behat_theme_classic_behat_general::is_edit_mode_available ( )

Check whether edit mode is available on the current page.

Return values
bool

Reimplemented from behat_general.

◆ plugin_is_installed()

behat_general::plugin_is_installed ( string $plugin)
inherited

Checks if given plugin is installed, and skips the current scenario if not.

@Given the :plugin plugin is installed

Parameters
string$pluginfrankenstyle plugin name, e.g. 'filter_embedquestion'.
Exceptions
Moodle\BehatExtension\Exception\SkippedException

◆ reload()

behat_general::reload ( )
inherited

Reloads the current page.

@Given /^I reload the page$/

◆ row_column_of_table_should_contain()

behat_general::row_column_of_table_should_contain ( $row,
$column,
$table,
$value )
inherited

Checks the provided value exists in specific row/column of table.

@Then /^"(?P<row_string>[^"]*)" row "(?P<column_string>[^"]*)" column of "(?P<table_string>[^"]*)" table should contain "(?P<value_string>[^"]*)"$/

Exceptions
ElementNotFoundException
Parameters
string$rowrow text which will be looked in.
string$columncolumn text to search (or numeric value for the column position)
string$tabletable id/class/caption
string$valuetext to check.

◆ row_column_of_table_should_not_contain()

behat_general::row_column_of_table_should_not_contain ( $row,
$column,
$table,
$value )
inherited

Checks the provided value should not exist in specific row/column of table.

@Then /^"(?P<row_string>[^"]*)" row "(?P<column_string>[^"]*)" column of "(?P<table_string>[^"]*)" table should not contain "(?P<value_string>[^"]*)"$/

Exceptions
ElementNotFoundException
Parameters
string$rowrow text which will be looked in.
string$columncolumn text to search
string$tabletable id/class/caption
string$valuetext to check.

◆ should_appear_after()

behat_general::should_appear_after ( string $postelement,
string $postselectortype,
string $preelement,
string $preselectortype,
?string $containerelement = null,
?string $containerselectortype = null )
inherited

Checks, that the first specified element appears after the second one.

@Then :postelement :postselectortype should appear after :preelement :preselectortype @Then :postelement :postselectortype should appear after :preelement :preselectortype in the :containerelement :containerselectortype

Exceptions
ExpectationException
Parameters
string$postelementThe locator of the latest element
string$postselectortypeThe selector type of the latest element
string$preelementThe locator of the preceding element
string$preselectortypeThe selector type of the preceding element
string$containerelement
string$containerselectortype

◆ should_appear_before()

behat_general::should_appear_before ( string $preelement,
string $preselectortype,
string $postelement,
string $postselectortype,
?string $containerelement = null,
?string $containerselectortype = null )
inherited

Checks, that the first specified element appears before the second one.

@Then :preelement :preselectortype should appear before :postelement :postselectortype @Then :preelement :preselectortype should appear before :postelement :postselectortype in the :containerelement :containerselectortype

Exceptions
ExpectationException
Parameters
string$preelementThe locator of the preceding element
string$preselectortypeThe selector type of the preceding element
string$postelementThe locator of the latest element
string$postselectortypeThe selector type of the latest element
string$containerelement
string$containerselectortype

◆ should_be_visible()

behat_general::should_be_visible ( $element,
$selectortype )
inherited

Checks, that the specified element is visible.

Only available in tests using Javascript.

@Then /^"(?P<element_string>(?:[^"]|::")*)" "(?P<selector_string>(?:[^"]|")*)" should be visible$/

Exceptions
ElementNotFoundException
ExpectationException
DriverException
Parameters
string$element
string$selectortype
Return values
void

◆ should_exist()

behat_general::should_exist ( $element,
$selectortype )
inherited

Checks the provided element and selector type exists in the current page.

This step is for advanced users, use it if you don't find anything else suitable for what you need.

@Then /^"(?P<element_string>(?:[^"]|::")*)" "(?P<selector_string>[^"]*)" should exist$/

Exceptions
ElementNotFoundExceptionThrown by behat_base\find
Parameters
string$elementThe locator of the specified selector
string$selectortypeThe selector type

◆ should_exist_in_the()

behat_general::should_exist_in_the ( $element,
$selectortype,
$containerelement,
$containerselectortype )
inherited

Checks that an element and selector type exists in another element and selector type on the current page.

This step is for advanced users, use it if you don't find anything else suitable for what you need.

@Then /^"(?P<element_string>(?:[^"]|::")*)" "(?P<selector_string>[^"]*)" should exist in the "(?P<element2_string>(?:[^"]|::")*)" "(?P<selector2_string>[^"]*)"$/

Exceptions
ElementNotFoundExceptionThrown by behat_base\find
Parameters
string$elementThe locator of the specified selector
string$selectortypeThe selector type
NodeElement | string$containerelementThe locator of the container selector
string$containerselectortypeThe container selector type

◆ should_not_be_visible()

behat_general::should_not_be_visible ( $element,
$selectortype )
inherited

Checks, that the existing element is not visible.

Only available in tests using Javascript.

As a "not" method, it's performance could not be good, but in this case the performance is good because the element must exist, otherwise there would be a ElementNotFoundException, also here we are not spinning until the element is visible.

@Then /^"(?P<element_string>(?:[^"]|::")*)" "(?P<selector_string>(?:[^"]|")*)" should not be visible$/

Exceptions
ElementNotFoundException
ExpectationException
Parameters
string$element
string$selectortype
Return values
void

◆ should_not_exist()

behat_general::should_not_exist ( $element,
$selectortype )
inherited

Checks that the provided element and selector type not exists in the current page.

This step is for advanced users, use it if you don't find anything else suitable for what you need.

@Then /^"(?P<element_string>(?:[^"]|::")*)" "(?P<selector_string>[^"]*)" should not exist$/

Exceptions
ExpectationException
Parameters
string$elementThe locator of the specified selector
string$selectortypeThe selector type

◆ should_not_exist_in_the()

behat_general::should_not_exist_in_the ( $element,
$selectortype,
$containerelement,
$containerselectortype )
inherited

Checks that an element and selector type does not exist in another element and selector type on the current page.

This step is for advanced users, use it if you don't find anything else suitable for what you need.

@Then /^"(?P<element_string>(?:[^"]|::")*)" "(?P<selector_string>[^"]*)" should not exist in the "(?P<element2_string>(?:[^"]|::")*)" "(?P<selector2_string>[^"]*)"$/

Exceptions
ExpectationException
Parameters
string$elementThe locator of the specified selector
string$selectortypeThe selector type
NodeElement | string$containerelementThe locator of the container selector
string$containerselectortypeThe container selector type

◆ switch_to_iframe()

behat_general::switch_to_iframe ( $name)
inherited

Switches to the specified iframe.

@Given /^I switch to "(?P<iframe_name_string>(?:[^"]|::")*)" iframe$/ @Given /^I switch to "(?P<iframe_name_string>(?:[^"]|::")*)" class iframe$/

Parameters
string$nameThe name of the iframe

◆ switch_to_second_window()

behat_general::switch_to_second_window ( )
inherited

Switches to a second window.

@Given /^I switch to a second window$/

Exceptions
DriverExceptionIf there aren't exactly 2 windows open.

◆ switch_to_the_main_frame()

behat_general::switch_to_the_main_frame ( )
inherited

Switches to the main Moodle frame.

@Given /^I switch to the main frame$/

◆ switch_to_the_main_window()

behat_general::switch_to_the_main_window ( )
inherited

Switches to the main Moodle window.

Useful when you finish interacting with popup windows.

@Given /^I switch to the main (window|tab)$/

◆ switch_to_window()

behat_general::switch_to_window ( $windowname)
inherited

Switches to the specified window.

Useful when interacting with popup windows.

@Given /^I switch to "(?P<window_name_string>(?:[^"]|::")*)" (window|tab)$/

Parameters
string$windowname

◆ the_attribute_of_should_be_set()

behat_general::the_attribute_of_should_be_set ( $attribute,
$element,
$selectortype,
$not = null )
inherited

Checks whether there the specified attribute is set or not.

@Then the :attribute attribute of :element :selectortype should be set @Then the :attribute attribute of :element :selectortype should :not be set

Exceptions
ExpectationException
Parameters
string$attributeName of attribute
string$elementThe locator of the specified selector
string$selectortypeThe selector type
string$not

◆ the_attribute_of_should_contain()

behat_general::the_attribute_of_should_contain ( $attribute,
$element,
$selectortype,
$text )
inherited

Checks whether there is an attribute on the given element that contains the specified text.

@Then /^the "(?P<attribute_string>[^"]*)" attribute of "(?P<element_string>(?:[^"]|::")*)" "(?P<selector_string>[^"]*)" should contain "(?P<text_string>(?:[^"]|::")*)"$/

Exceptions
ExpectationException
Parameters
string$attributeName of attribute
string$elementThe locator of the specified selector
string$selectortypeThe selector type
string$textExpected substring

◆ the_attribute_of_should_not_contain()

behat_general::the_attribute_of_should_not_contain ( $attribute,
$element,
$selectortype,
$text )
inherited

Checks that the attribute on the given element does not contain the specified text.

@Then /^the "(?P<attribute_string>[^"]*)" attribute of "(?P<element_string>(?:[^"]|::")*)" "(?P<selector_string>[^"]*)" should not contain "(?P<text_string>(?:[^"]|::")*)"$/

Exceptions
ExpectationException
Parameters
string$attributeName of attribute
string$elementThe locator of the specified selector
string$selectortypeThe selector type
string$textExpected substring

◆ the_default_editor_is_set_to()

behat_general::the_default_editor_is_set_to ( string $editor)
inherited

Set the default text editor to the named text editor.

@Given the default editor is set to :editor

Parameters
string$editor
Exceptions
ExpectationExceptionIf the specified editor is not available.

◆ the_element_should_be_disabled()

behat_general::the_element_should_be_disabled ( $element,
$selectortype )
inherited

Checks, that element of specified type is disabled.

@Then /^the "(?P<element_string>(?:[^"]|::")*)" "(?P<selector_string>[^"]*)" should be disabled$/

Exceptions
ExpectationExceptionThrown by behat_base\find
Parameters
string$elementElement we look in
string$selectortypeThe type of element where we are looking in.

◆ the_element_should_be_enabled()

behat_general::the_element_should_be_enabled ( $element,
$selectortype )
inherited

Checks, that element of specified type is enabled.

@Then /^the "(?P<element_string>(?:[^"]|::")*)" "(?P<selector_string>[^"]*)" should be enabled$/

Exceptions
ExpectationExceptionThrown by behat_base\find
Parameters
string$elementElement we look on
string$selectortypeThe type of where we look

◆ the_element_should_be_readonly()

behat_general::the_element_should_be_readonly ( $element,
$selectortype )
inherited

Checks the provided element and selector type are readonly on the current page.

@Then /^the "(?P<element_string>(?:[^"]|::")*)" "(?P<selector_string>[^"]*)" should be readonly$/

Exceptions
ExpectationExceptionThrown by behat_base\find
Parameters
string$elementElement we look in
string$selectortypeThe type of element where we are looking in.

◆ the_element_should_not_be_readonly()

behat_general::the_element_should_not_be_readonly ( $element,
$selectortype )
inherited

Checks the provided element and selector type are not readonly on the current page.

@Then /^the "(?P<element_string>(?:[^"]|::")*)" "(?P<selector_string>[^"]*)" should not be readonly$/

Exceptions
ExpectationExceptionThrown by behat_base\find
Parameters
string$elementElement we look in
string$selectortypeThe type of element where we are looking in.

◆ the_focused_element_is()

behat_general::the_focused_element_is ( $not,
$nodeelement,
$nodeselectortype )
inherited

Checks focus is with the given element.

@Then /^the focused element is( not)? "(?P<node_string>(?:[^"]|::")*)" "(?P<node_selector_string>[^"]*)"$/

Parameters
string$notoptional step verifier
string$nodeelementElement identifier
string$nodeselectortypeElement type
Exceptions
DriverExceptionIf not using JavaScript
ExpectationException

◆ the_focused_element_is_in_the()

behat_general::the_focused_element_is_in_the ( $not,
$element,
$selectortype,
$nodeelement,
$nodeselectortype )
inherited

Checks focus is with the given element.

@Then /^the focused element is( not)? "(?P<n>(?:[^"]|::")*)" "(?P<ns>[^"]*)" in the "(?P<c>(?:[^"]|::")*)" "(?P<cs>[^"]*)"$/

Parameters
string$notstring optional step verifier
string$elementElement identifier
string$selectortypeElement type
string$nodeelementElement we look in
string$nodeselectortypeThe type of selector where we look in
Exceptions
DriverExceptionIf not using JavaScript
ExpectationException

◆ the_image_at_should_be_identical_to()

behat_general::the_image_at_should_be_identical_to ( $element,
$selectortype,
$filepath )
inherited

Checks that the image on the page is the same as one of the fixture files.

@Then /^the image at "(?P<element_string>(?:[^"]|::")*)" "(?P<selector_string>[^"]*)" should be identical to "(?P<filepath_string>(?:[^"]|::")*)"$/

Exceptions
ExpectationException
Parameters
string$elementThe locator of the image
string$selectortypeThe selector type
string$filepathpath to the fixture file

◆ the_page_title_should_contain()

behat_general::the_page_title_should_contain ( string $title)
inherited

Check that the page title contains a given string.

@Given the page title should contain ":title"

Parameters
string$titleThe string that should be present on the page title.

◆ the_site_is_running_moodle_version_or_higher()

behat_general::the_site_is_running_moodle_version_or_higher ( string $minversion)
inherited

Allow to check for minimal Moodle version.

@Given the site is running Moodle version :minversion or higher

Parameters
string$minversionThe minimum version of Moodle required (inclusive).

◆ the_site_is_running_moodle_version_or_lower()

behat_general::the_site_is_running_moodle_version_or_lower ( string $maxversion)
inherited

Allow to check for maximum Moodle version.

@Given the site is running Moodle version :maxversion or lower

Parameters
string$maxversionThe maximum version of Moodle required (inclusive).

◆ wait_until_does_not_exists()

behat_general::wait_until_does_not_exists ( $element,
$selectortype )
inherited

Waits until the provided element does not exist in the DOM.

Using the protected method as this method will be usually called by other methods which are not returning a set of steps and performs the actions directly, so it would not be executed if it returns another step.

@Given /^I wait until "(?P<element_string>(?:[^"]|::")*)" "(?P<selector_string>[^"]*)" does not exist$/

Parameters
string$element
string$selector
Return values
void

◆ wait_until_exists()

behat_general::wait_until_exists ( $element,
$selectortype )
inherited

Waits until the provided element selector exists in the DOM.

Using the protected method as this method will be usually called by other methods which are not returning a set of steps and performs the actions directly, so it would not be executed if it returns another step.

@Given /^I wait until "(?P<element_string>(?:[^"]|::")*)" "(?P<selector_string>[^"]*)" exists$/

Parameters
string$element
string$selector
Return values
void

◆ wait_until_the_page_is_ready()

behat_general::wait_until_the_page_is_ready ( )
inherited

Waits until the page is completely loaded.

This step is auto-executed after every step.

@Given /^I wait until the page is ready$/

Member Data Documentation

◆ PAGE_LOAD_DETECTION_STRING

string const behat_general::PAGE_LOAD_DETECTION_STRING = 'new_page_not_loaded_since_behat_started_watching'
inherited

when we want to check whether or not a new page has loaded, we first write this unique string into the page.

Then later, by checking whether it is still there, we can tell if a new page has been loaded.

◆ PAGE_READY_JS

const behat_session_interface::PAGE_READY_JS
inherited
Initial value:
= "document.readyState === 'complete' && " .
"(typeof M !== 'object' || typeof M.util !== 'object' || " .
"typeof M.util.pending_js === 'undefined' || M.util.pending_js.length === 0)"

The JS code to check that the page is ready.

The document must be complete and either M.util.pending_js must be empty, or it must not be defined at all.


The documentation for this class was generated from the following file: