batuhan-basoglu/Kargi-Sitesi
1
1
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Deployed the page to Github Pages.

Browse source
This commit is contained in:
Batuhan Berk Başoğlu 2024-11-03 21:30:09 -05:00
parent 1d79754e93
commit 2c89899458
Signed by: batuhan-basoglu
SSH key fingerprint: SHA256:kEsnuHX+qbwhxSAXPUQ4ox535wFHu/hIRaa53FzxRpo
62797 changed files with 6551425 additions and 15279 deletions
Download patch file Download diff file Expand all files Collapse all files

216
node_modules/protractor/built/selenium-webdriver/locators.js generated vendored Normal file
View file

@ -0,0 +1,216 @@
// Used to provide better protractor documentation for webdriver. These files
// are not used to provide code for protractor and are only used for the website.
/**
* @fileoverview Factory methods for the supported locator strategies.
*/
goog.provide('webdriver');
/**
* A collection of factory functions for creating {@link webdriver.Locator}
* instances.
*/
webdriver.By = {};
/**
* Locates elements that have a specific class name. The returned locator
* is equivalent to searching for elements with the CSS selector ".clazz".
*
* @view
* <ul class="pet">
* <li class="dog">Dog</li>
* <li class="cat">Cat</li>
* </ul>
*
* @example
* // Returns the web element for dog
* var dog = element(by.className('dog'));
* expect(dog.getText()).toBe('Dog');
*
* @param {string} className The class name to search for.
* @returns {!webdriver.Locator} The new locator.
* @see http://www.w3.org/TR/2011/WD-html5-20110525/elements.html#classes
* @see http://www.w3.org/TR/CSS2/selector.html#class-html
*/
webdriver.By.className = webdriver.Locator.factory_('class name');
/**
* Locates elements using a CSS selector. For browsers that do not support
* CSS selectors, WebDriver implementations may return an
* {@linkplain bot.Error.State.INVALID_SELECTOR invalid selector} error. An
* implementation may, however, emulate the CSS selector API.
*
* @view
* <ul class="pet">
* <li class="dog">Dog</li>
* <li class="cat">Cat</li>
* </ul>
*
* @example
* // Returns the web element for cat
* var cat = element(by.css('.pet .cat'));
* expect(cat.getText()).toBe('Cat');
*
* @param {string} selector The CSS selector to use.
* @returns {!webdriver.Locator} The new locator.
* @see http://www.w3.org/TR/CSS2/selector.html
*/
webdriver.By.css = webdriver.Locator.factory_('css selector');
/**
* Locates an element by its ID.
*
* @view
* <ul id="pet_id">
* <li id="dog_id">Dog</li>
* <li id="cat_id">Cat</li>
* </ul>
*
* @example
* // Returns the web element for dog
* var dog = element(by.id('dog_id'));
* expect(dog.getText()).toBe('Dog');
*
* @param {string} id The ID to search for.
* @returns {!webdriver.Locator} The new locator.
*/
webdriver.By.id = webdriver.Locator.factory_('id');
/**
* Locates link elements whose {@linkplain webdriver.WebElement#getText visible
* text} matches the given string.
*
* @view
* <a href="http://www.google.com">Google</a>
*
* @example
* expect(element(by.linkText('Google')).getTagName()).toBe('a');
*
* @param {string} text The link text to search for.
* @returns {!webdriver.Locator} The new locator.
*/
webdriver.By.linkText = webdriver.Locator.factory_('link text');
/**
* Locates an elements by evaluating a JavaScript expression, which may
* be either a function or a string. Like
* {@link webdriver.WebDriver.executeScript}, the expression is evaluated
* in the context of the page and cannot access variables from
* the test file.
*
* The result of this expression must be an element or list of elements.
*
* @alias by.js(expression)
* @view
* <span class="small">One</span>
* <span class="medium">Two</span>
* <span class="large">Three</span>
*
* @example
* var wideElement = element(by.js(function() {
* var spans = document.querySelectorAll('span');
* for (var i = 0; i < spans.length; ++i) {
* if (spans[i].offsetWidth > 100) {
* return spans[i];
* }
* }
* }));
* expect(wideElement.getText()).toEqual('Three');
*
* @param {!(string|Function)} script The script to execute.
* @param {...*} var_args The arguments to pass to the script.
* @returns {!webdriver.Locator}
*/
webdriver.By.js = function(script, var_args) {};
/**
* Locates elements whose {@code name} attribute has the given value.
*
* @view
* <ul>
* <li name="dog_name">Dog</li>
* <li name="cat_name">Cat</li>
* </ul>
*
* @example
* // Returns the web element for dog
* var dog = element(by.name('dog_name'));
* expect(dog.getText()).toBe('Dog');
*
* @param {string} name The name attribute to search for.
* @returns {!webdriver.Locator} The new locator.
*/
webdriver.By.name = webdriver.Locator.factory_('name');
/**
* Locates link elements whose {@linkplain webdriver.WebElement#getText visible
* text} contains the given substring.
*
* @view
* <ul>
* <li><a href="https://en.wikipedia.org/wiki/Doge_(meme)">Doge meme</a></li>
* <li>Cat</li>
* </ul>
*
* @example
* // Returns the 'a' web element for doge meme and navigate to that link
* var doge = element(by.partialLinkText('Doge'));
* doge.click();
*
* @param {string} text The substring to check for in a link's visible text.
* @returns {!webdriver.Locator} The new locator.
*/
webdriver.By.partialLinkText = webdriver.Locator.factory_(
'partial link text');
/**
* Locates elements with a given tag name. The returned locator is
* equivalent to using the
* [getElementsByTagName](https://developer.mozilla.org/en-US/docs/Web/API/Element.getElementsByTagName)
* DOM function.
*
* @view
* <a href="http://www.google.com">Google</a>
*
* @example
* expect(element(by.tagName('a')).getText()).toBe('Google');
*
* @param {string} text The substring to check for in a link's visible text.
* @returns {!webdriver.Locator} The new locator.
* @see http://www.w3.org/TR/REC-DOM-Level-1/level-one-core.html
*/
webdriver.By.tagName = webdriver.Locator.factory_('tag name');
/**
* Locates elements matching a XPath selector. Care should be taken when
* using an XPath selector with a {@link webdriver.WebElement} as WebDriver
* will respect the context in the specified in the selector. For example,
* given the selector {@code "//div"}, WebDriver will search from the
* document root regardless of whether the locator was used with a
* WebElement.
*
* @view
* <ul>
* <li><a href="https://en.wikipedia.org/wiki/Doge_(meme)">Doge meme</a></li>
* <li>Cat</li>
* </ul>
*
* @example
* // Returns the 'a' element for doge meme
* var li = element(by.xpath('//ul/li/a'));
* expect(li.getText()).toBe('Doge meme');
*
* @param {string} xpath The XPath selector to use.
* @returns {!webdriver.Locator} The new locator.
* @see http://www.w3.org/TR/xpath/
*/
webdriver.By.xpath = webdriver.Locator.factory_('xpath');

765
node_modules/protractor/built/selenium-webdriver/webdriver.js generated vendored Normal file
View file

@ -0,0 +1,765 @@
// Used to provide better protractor documentation for webdriver. These files
// are not used to provide code for protractor and are only used for the website.
/**
* @fileoverview The heart of the WebDriver JavaScript API.
*/
goog.provide('webdriver');
/**
* Class for defining sequences of complex user interactions.
* @external webdriver.ActionSequence
* @see http://seleniumhq.github.io/selenium/docs/api/javascript/module/selenium-webdriver/lib/actions_exports_ActionSequence.html
*/
webdriver.ActionSequence = function() {};
/**
* Class for defining sequences of user touch interactions.
* @external webdriver.TouchSequence
* @see http://seleniumhq.github.io/selenium/docs/api/javascript/module/selenium-webdriver/index_exports_TouchSequence.html
*/
webdriver.TouchSequence = function() {};
// //////////////////////////////////////////////////////////////////////////////
// //
// // webdriver.WebDriver
// //
// /////////////////////////////////////////////////////////////////////////////
/**
* Protractor's `browser` object is a wrapper for `selenium-webdriver` WebDriver.
* It inherits call of WebDriver's methods, but only the methods most useful to
* Protractor users are documented here.
*
* A full list of all functions available on WebDriver can be found
* in the selenium-webdriver
* <a href="http://seleniumhq.github.io/selenium/docs/api/javascript/module/selenium-webdriver/lib/webdriver_exports_WebDriver.html">documentation</a>
* @constructor
*/
webdriver.WebDriver = function() {};
/**
* Creates a sequence of user actions using this driver. The sequence will not be
* scheduled for execution until {@link webdriver.ActionSequence#perform} is
* called.
*
* See the selenium webdriver docs <a href="http://seleniumhq.github.io/selenium/docs/api/javascript/module/selenium-webdriver/lib/actions_exports_ActionSequence.html">
* for more details on action sequences</a>.
*
* Mouse actions do not work on Chrome with the HTML5 Drag and Drop API due to a known <a href="https://bugs.chromium.org/p/chromedriver/issues/detail?id=841">
* Chromedriver issue</a>
*
* @example
* // Dragging one element to another.
* browser.actions().
* mouseDown(element1).
* mouseMove(element2).
* mouseUp().
* perform();
*
* // You can also use the `dragAndDrop` convenience action.
* browser.actions().
* dragAndDrop(element1, element2).
* perform();
*
* // Instead of specifying an element as the target, you can specify an offset
* // in pixels. This example double-clicks slightly to the right of an element.
* browser.actions().
* mouseMove(element).
* mouseMove({x: 50, y: 0}).
* doubleClick().
* perform();
*
* @returns {!webdriver.ActionSequence} A new action sequence for this instance.
*/
webdriver.WebDriver.prototype.actions = function() {};
/**
* Creates a new touch sequence using this driver. The sequence will not be
* scheduled for execution until {@link actions.TouchSequence#perform} is
* called.
*
* See the selenium webdriver docs <a href="http://seleniumhq.github.io/selenium/docs/api/javascript/module/selenium-webdriver/index_exports_TouchSequence.html">
* for more details on touch sequences</a>.
*
* @example
* browser.touchActions().
* tap(element1).
* doubleTap(element2).
* perform();
*
* @return {!webdriver.TouchSequence} A new touch sequence for this instance.
*/
webdriver.WebDriver.prototype.touchActions = function() {};
/**
* Schedules a command to execute JavaScript in the context of the currently
* selected frame or window. The script fragment will be executed as the body
* of an anonymous function. If the script is provided as a function object,
* that function will be converted to a string for injection into the target
* window.
*
* Any arguments provided in addition to the script will be included as script
* arguments and may be referenced using the {@code arguments} object.
* Arguments may be a boolean, number, string, or {@linkplain WebElement}.
* Arrays and objects may also be used as script arguments as long as each item
* adheres to the types previously mentioned.
*
* The script may refer to any variables accessible from the current window.
* Furthermore, the script will execute in the window's context, thus
* {@code document} may be used to refer to the current document. Any local
* variables will not be available once the script has finished executing,
* though global variables will persist.
*
* If the script has a return value (i.e. if the script contains a return
* statement), then the following steps will be taken for resolving this
* functions return value:
*
* - For a HTML element, the value will resolve to a {@linkplain WebElement}
* - Null and undefined return values will resolve to null</li>
* - Booleans, numbers, and strings will resolve as is</li>
* - Functions will resolve to their string representation</li>
* - For arrays and objects, each member item will be converted according to
* the rules above
*
* @example
* var el = element(by.module('header'));
* var tag = browser.executeScript('return arguments[0].tagName', el);
* expect(tag).toEqual('h1');
*
* @param {!(string|Function)} script The script to execute.
* @param {...*} var_args The arguments to pass to the script.
* @return {!promise.Promise<T>} A promise that will resolve to the
* scripts return value.
* @template T
*/
webdriver.WebDriver.prototype.executeScript = function(script, var_args) {};
/**
* Schedules a command to execute asynchronous JavaScript in the context of the
* currently selected frame or window. The script fragment will be executed as
* the body of an anonymous function. If the script is provided as a function
* object, that function will be converted to a string for injection into the
* target window.
*
* Any arguments provided in addition to the script will be included as script
* arguments and may be referenced using the {@code arguments} object.
* Arguments may be a boolean, number, string, or {@code WebElement}.
* Arrays and objects may also be used as script arguments as long as each item
* adheres to the types previously mentioned.
*
* Unlike executing synchronous JavaScript with {@link #executeScript},
* scripts executed with this function must explicitly signal they are finished
* by invoking the provided callback. This callback will always be injected
* into the executed function as the last argument, and thus may be referenced
* with {@code arguments[arguments.length - 1]}. The following steps will be
* taken for resolving this functions return value against the first argument
* to the script's callback function:
*
* - For a HTML element, the value will resolve to a
* {@link WebElement}
* - Null and undefined return values will resolve to null
* - Booleans, numbers, and strings will resolve as is
* - Functions will resolve to their string representation
* - For arrays and objects, each member item will be converted according to
* the rules above
*
* @example
* // Example 1
* // Performing a sleep that is synchronized with the currently selected window
* var start = new Date().getTime();
* browser.executeAsyncScript(
* 'window.setTimeout(arguments[arguments.length - 1], 500);').
* then(function() {
* console.log(
* 'Elapsed time: ' + (new Date().getTime() - start) + ' ms');
* });
*
* // Example 2
* // Synchronizing a test with an AJAX application:
* var button = element(by.id('compose-button'));
* button.click();
* browser.executeAsyncScript(
* 'var callback = arguments[arguments.length - 1];' +
* 'mailClient.getComposeWindowWidget().onload(callback);');
* browser.switchTo().frame('composeWidget');
* element(by.id('to')).sendKeys('dog@example.com');
*
* // Example 3
* // Injecting a XMLHttpRequest and waiting for the result. In this example,
* // the inject script is specified with a function literal. When using this
* // format, the function is converted to a string for injection, so it should
* // not reference any symbols not defined in the scope of the page under test.
* browser.executeAsyncScript(function() {
* var callback = arguments[arguments.length - 1];
* var xhr = new XMLHttpRequest();
* xhr.open("GET", "/resource/data.json", true);
* xhr.onreadystatechange = function() {
* if (xhr.readyState == 4) {
* callback(xhr.responseText);
* }
* };
* xhr.send('');
* }).then(function(str) {
* console.log(JSON.parse(str)['food']);
* });
*
* @param {!(string|Function)} script The script to execute.
* @param {...*} var_args The arguments to pass to the script.
* @return {!promise.Promise<T>} A promise that will resolve to the
* scripts return value.
* @template T
*/
webdriver.WebDriver.prototype.executeAsyncScript = (script, var_args) => {};
/**
* Schedules a command to execute a custom function within the context of
* webdriver's control flow.
*
* Most webdriver actions are asynchronous, but the control flow makes sure that
* commands are executed in the order they were received. By running your
* function in the control flow, you can ensure that it is executed before/after
* other webdriver actions. Additionally, Protractor will wait until the
* control flow is empty before deeming a test finished.
*
* @example
* var logText = function(el) {
* return el.getText().then((text) => {
* console.log(text);
* });
* };
* var counter = element(by.id('counter'));
* var button = element(by.id('button'));
* // Use `browser.call()` to make sure `logText` is run before and after
* // `button.click()`
* browser.call(logText, counter);
* button.click();
* browser.call(logText, counter);
*
* @param {function(...): (T|promise.Promise<T>)} fn The function to
* execute.
* @param {Object=} opt_scope The object in whose scope to execute the function
* (i.e. the `this` object for the function).
* @param {...*} var_args Any arguments to pass to the function. If any of the
* arguments are promised, webdriver will wait for these promised to resolve
* and pass the resulting value onto the function.
* @return {!promise.Promise<T>} A promise that will be resolved
* with the function's result.
* @template T
*/
webdriver.WebDriver.prototype.call = function(fn, opt_scope, var_args) {};
/**
* Schedules a command to wait for a condition to hold or {@link
* webdriver.promise.Promise promise} to be resolved.
*
* This function blocks WebDriver's control flow, not the javascript runtime.
* It will only delay future webdriver commands from being executed (e.g. it
* will cause Protractor to wait before sending future commands to the selenium
* server), and only when the webdriver control flow is enabled.
*
* This function returnes a promise, which can be used if you need to block
* javascript execution and not just the control flow.
*
* See also {@link ExpectedConditions}
*
* *Example:* Suppose you have a function, `startTestServer`, that returns a
* promise for when a server is ready for requests. You can block a `WebDriver`
* client on this promise with:
*
* @example
* var started = startTestServer();
* browser.wait(started, 5 * 1000, 'Server should start within 5 seconds');
* browser.get(getServerUrl());
*
* @param {!(webdriver.promise.Promise<T>|
* webdriver.until.Condition<T>|
* function(!webdriver.WebDriver): T)} condition The condition to
* wait on, defined as a promise, condition object, or a function to
* evaluate as a condition.
* @param {number=} opt_timeout How long to wait for the condition to be true. Will default 30 seconds, or to the jasmineNodeOpts.defaultTimeoutInterval in your protractor.conf.js file.
* @param {string=} opt_message An optional message to use if the wait times
* out.
* @returns {!webdriver.promise.Promise<T>} A promise that will be fulfilled
* with the first truthy value returned by the condition function, or
* rejected if the condition times out.
*/
webdriver.WebDriver.prototype.wait = function() {};
/**
* Schedules a command to make the driver sleep for the given amount of time.
* @param {number} ms The amount of time, in milliseconds, to sleep.
* @returns {!webdriver.promise.Promise.<void>} A promise that will be resolved
* when the sleep has finished.
*/
webdriver.WebDriver.prototype.sleep = function() {};
/**
* Schedules a command to retrieve the current page's source. The page source
* returned is a representation of the underlying DOM: do not expect it to be
* formatted or escaped in the same way as the response sent from the web
* server.
* @return {!promise.Promise<string>} A promise that will be
* resolved with the current page source.
*/
webdriver.WebDriver.prototype.getPageSource = function() {};
/**
* Schedules a command to close the current window.
* @return {!promise.Promise<void>} A promise that will be resolved
* when this command has completed.
*/
webdriver.WebDriver.prototype.close = function() {};
/**
* Schedules a command to retrieve the URL of the current page.
* @returns {!webdriver.promise.Promise.<string>} A promise that will be
* resolved with the current URL.
*/
webdriver.WebDriver.prototype.getCurrentUrl = function() {};
/**
* Schedules a command to retrieve the current page's title.
* @returns {!webdriver.promise.Promise.<string>} A promise that will be
* resolved with the current page's title.
*/
webdriver.WebDriver.prototype.getTitle = function() {};
/**
* Schedule a command to take a screenshot. The driver makes a best effort to
* return a screenshot of the following, in order of preference:
* <ol>
* <li>Entire page
* <li>Current window
* <li>Visible portion of the current frame
* <li>The screenshot of the entire display containing the browser
* </ol>
*
* @returns {!webdriver.promise.Promise.<string>} A promise that will be
* resolved to the screenshot as a base-64 encoded PNG.
*/
webdriver.WebDriver.prototype.takeScreenshot = function() {};
/**
* Used to switch WebDriver's focus to a frame or window (e.g. an alert, an
* iframe, another window).
*
* See [WebDriver's TargetLocator Docs](http://seleniumhq.github.io/selenium/docs/api/javascript/module/selenium-webdriver/lib/webdriver_exports_TargetLocator.html)
* for more information.
*
* @example
* browser.switchTo().frame(element(by.tagName('iframe')).getWebElement());
*
* @return {!TargetLocator} The target locator interface for this
* instance.
*/
webdriver.WebDriver.prototype.switchTo = function() {}
// /////////////////////////////////////////////////////////////////////////////
// //
// // webdriver.WebElement
// //
// /////////////////////////////////////////////////////////////////////////////
//
//
//
/**
* Protractor's ElementFinders are wrappers for selenium-webdriver WebElement.
* A full list of all functions available on WebElement can be found
* in the selenium-webdriver
* <a href="http://seleniumhq.github.io/selenium/docs/api/javascript/module/selenium-webdriver/lib/webdriver_exports_WebElement.html">documentation</a>.
*
* @param {!webdriver.WebDriver} driver The webdriver driver or the parent WebDriver instance for this
* element.
* @param {!(webdriver.promise.Promise.<webdriver.WebElement.Id>|
* webdriver.WebElement.Id)} id The server-assigned opaque ID for the
* underlying DOM element.
* @constructor
*/
webdriver.WebElement = function(driver, id) {};
/**
* Gets the parent web element of this web element.
*
* @view
* <ul class="pet">
* <li class="dog">Dog</li>
* <li class="cat">Cat</li>
* </ul>
*
* @example
* // Using getDriver to find the parent web element to find the cat li
* var liDog = element(by.css('.dog')).getWebElement();
* var liCat = liDog.getDriver().findElement(by.css('.cat'));
*
* @returns {!webdriver.WebDriver} The parent driver for this instance.
*/
webdriver.WebElement.prototype.getDriver = function() {};
/**
* Gets the WebDriver ID string representation for this web element.
*
* @view
* <ul class="pet">
* <li class="dog">Dog</li>
* <li class="cat">Cat</li>
* </ul>
*
* @example
* // returns the dog web element
* var dog = element(by.css('.dog')).getWebElement();
* expect(dog.getId()).not.toBe(undefined);
*
* @returns {!webdriver.promise.Promise.<webdriver.WebElement.Id>} A promise
* that resolves to this element's JSON representation as defined by the
* WebDriver wire protocol.
* @see https://github.com/SeleniumHQ/selenium/wiki/JsonWireProtocol
*/
webdriver.WebElement.prototype.getId = function() {};
/**
* Use {@link ElementFinder.prototype.element} instead
*
* @see ElementFinder.prototype.element
*
* @param {webdriver.Locator} subLocator
*
* @returns {!webdriver.WebElement}
*/
webdriver.WebElement.prototype.findElement = function(subLocator) {};
/**
* Schedules a command to click on this element.
*
* @view
* <ul>
* <li><a href="https://en.wikipedia.org/wiki/Doge_(meme)">Doge meme</a></li>
* <li>Cat</li>
* </ul>
*
* @example
* // Clicks on the web link
* element(by.partialLinkText('Doge')).click();
*
* @returns {!webdriver.promise.Promise.<void>} A promise that will be resolved
* when the click command has completed.
*/
webdriver.WebElement.prototype.click = function() {};
/**
* Schedules a command to type a sequence on the DOM element represented by this
* instance.
*
* Modifier keys (SHIFT, CONTROL, ALT, META) are stateful; once a modifier is
* processed in the keysequence, that key state is toggled until one of the
* following occurs:
*
* - The modifier key is encountered again in the sequence. At this point the
* state of the key is toggled (along with the appropriate keyup/down events).
* - The {@link webdriver.Key.NULL} key is encountered in the sequence. When
* this key is encountered, all modifier keys current in the down state are
* released (with accompanying keyup events). The NULL key can be used to
* simulate common keyboard shortcuts:
*
* element.sendKeys("text was",
* protractor.Key.CONTROL, "a", protractor.Key.NULL,
* "now text is");
* // Alternatively:
* element.sendKeys("text was",
* protractor.Key.chord(protractor.Key.CONTROL, "a"),
* "now text is");
*
* - The end of the keysequence is encountered. When there are no more keys
* to type, all depressed modifier keys are released (with accompanying keyup
* events).
*
* If this element is a file input ({@code <input type="file">}), the
* specified key sequence should specify the path to the file to attach to
* the element. This is analgous to the user clicking "Browse..." and entering
* the path into the file select dialog.
*
* var form = driver.findElement(By.css('form'));
* var element = form.findElement(By.css('input[type=file]'));
* element.sendKeys('/path/to/file.txt');
* form.submit();
*
* For uploads to function correctly, the entered path must reference a file
* on the _browser's_ machine, not the local machine running this script. When
* running against a remote Selenium server, a {@link webdriver.FileDetector}
* may be used to transparently copy files to the remote machine before
* attempting to upload them in the browser.
*
* __Note:__ On browsers where native keyboard events are not supported
* (e.g. Firefox on OS X), key events will be synthesized. Special
* punctionation keys will be synthesized according to a standard QWERTY en-us
* keyboard layout.
*
* @param {...(string|!webdriver.promise.Promise<string>)} var_args The sequence
* of keys to type. All arguments will be joined into a single sequence.
* @returns {!webdriver.promise.Promise.<void>} A promise that will be resolved
* when all keys have been typed.
*/
webdriver.WebElement.prototype.sendKeys = function(var_args) {};
/**
* Gets the tag/node name of this element.
*
* @view
* <span>{{person.name}}</span>
*
* @example
* expect(element(by.binding('person.name')).getTagName()).toBe('span');
*
* @returns {!webdriver.promise.Promise.<string>} A promise that will be
* resolved with the element's tag name.
*/
webdriver.WebElement.prototype.getTagName = function() {};
/**
* Gets the computed style of an element. If the element inherits the named
* style from its parent, the parent will be queried for its value. Where
* possible, color values will be converted to their hex representation (e.g.
* #00ff00 instead of rgb(0, 255, 0)).
*
* _Warning:_ the value returned will be as the browser interprets it, so
* it may be tricky to form a proper assertion.
*
* @view
* <span style='color: #000000'>{{person.name}}</span>
*
* @example
* expect(element(by.binding('person.name')).getCssValue('color')).toBe('#000000');
*
* @param {string} cssStyleProperty The name of the CSS style property to look
* up.
* @returns {!webdriver.promise.Promise.<string>} A promise that will be
* resolved with the requested CSS value.
*/
webdriver.WebElement.prototype.getCssValue = function(cssStyleProperty) {};
/**
* Schedules a command to query for the value of the given attribute of the
* element. Will return the current value, even if it has been modified after
* the page has been loaded. More exactly, this method will return the value of
* the given attribute, unless that attribute is not present, in which case the
* value of the property with the same name is returned. If neither value is
* set, null is returned (for example, the "value" property of a textarea
* element). The "style" attribute is converted as best can be to a
* text representation with a trailing semi-colon. The following are deemed to
* be "boolean" attributes and will return either "true" or null:
*
* async, autofocus, autoplay, checked, compact, complete, controls, declare,
* defaultchecked, defaultselected, defer, disabled, draggable, ended,
* formnovalidate, hidden, indeterminate, iscontenteditable, ismap, itemscope,
* loop, multiple, muted, nohref, noresize, noshade, novalidate, nowrap, open,
* paused, pubdate, readonly, required, reversed, scoped, seamless, seeking,
* selected, spellcheck, truespeed, willvalidate
*
* Finally, the following commonly mis-capitalized attribute/property names
* are evaluated as expected:
*
* - "class"
* - "readonly"
*
* @view
* <div id="foo" class="bar"></div>
*
* @example
* var foo = element(by.id('foo'));
* expect(foo.getAttribute('class')).toEqual('bar');
*
* @param {string} attributeName The name of the attribute to query.
* @returns {!webdriver.promise.Promise.<?string>} A promise that will be
* resolved with the attribute's value. The returned value will always be
* either a string or null.
*/
webdriver.WebElement.prototype.getAttribute = function(attributeName) {};
/**
* Get the visible innerText of this element, including sub-elements, without
* any leading or trailing whitespace. Visible elements are not hidden by CSS.
*
* @view
* <div id="foo" class="bar">Inner text</div>
*
* @example
* var foo = element(by.id('foo'));
* expect(foo.getText()).toEqual('Inner text');
*
* @returns {!webdriver.promise.Promise.<string>} A promise that will be
* resolved with the element's visible text.
*/
webdriver.WebElement.prototype.getText = function() {};
/**
* Schedules a command to compute the size of this element's bounding box, in
* pixels.
*
* @view
* <div id="foo" style="width:50px; height: 20px">
* Inner text
* </div>
*
* @example
* var foo = element(by.id('foo'));
* expect(foo.getSize()).toEqual(jasmine.objectContaining({
* width: 50,
* height: 20
* });
*
* @returns {!webdriver.promise.Promise.<{width: number, height: number}>} A
* promise that will be resolved with the element's size as a
* {@code {width:number, height:number}} object.
*/
webdriver.WebElement.prototype.getSize = function() {};
/**
* Schedules a command to compute the location of this element in page space.
*
* @view
* <div id="foo" style="position: absolute; top:20px; left: 15px">
* Inner text
* </div>
*
* @example
* var foo = element(by.id('foo'));
* expect(foo.getLocation()).toEqual(jasmine.objectContaining({
* x: 15,
* y: 20
* });
*
* @returns {!webdriver.promise.Promise.<{x: number, y: number}>} A promise that
* will be resolved to the element's location as a
* {@code {x:number, y:number}} object.
*/
webdriver.WebElement.prototype.getLocation = function() {};
/**
* Schedules a command to query whether the DOM element represented by this
* instance is enabled, as dicted by the {@code disabled} attribute.
*
* @view
* <input id="foo" disabled=true>
*
* @example
* var foo = element(by.id('foo'));
* expect(foo.isEnabled()).toBe(false);
*
* @returns {!webdriver.promise.Promise.<boolean>} A promise that will be
* resolved with whether this element is currently enabled.
*/
webdriver.WebElement.prototype.isEnabled = function() {};
/**
* Schedules a command to query whether this element is selected.
*
* @view
* <input id="foo" type="checkbox">
*
* @example
* var foo = element(by.id('foo'));
* expect(foo.isSelected()).toBe(false);
* foo.click();
* expect(foo.isSelected()).toBe(true);
*
* @returns {!webdriver.promise.Promise.<boolean>} A promise that will be
* resolved with whether this element is currently selected.
*/
webdriver.WebElement.prototype.isSelected = function() {};
/**
* Schedules a command to submit the form containing this element (or this
* element if it is a FORM element). This command is a no-op if the element is
* not contained in a form.
*
* @view
* <form id="login">
* <input name="user">
* </form>
*
* @example
* var login_form = element(by.id('login'));
* login_form.submit();
*
* @returns {!webdriver.promise.Promise.<void>} A promise that will be resolved
* when the form has been submitted.
*/
webdriver.WebElement.prototype.submit = function() {};
/**
* Schedules a command to clear the {@code value} of this element. This command
* has no effect if the underlying DOM element is neither a text INPUT element
* nor a TEXTAREA element.
*
* @view
* <input id="foo" value="Default Text">
*
* @example
* var foo = element(by.id('foo'));
* expect(foo.getAttribute('value')).toEqual('Default Text');
* foo.clear();
* expect(foo.getAttribute('value')).toEqual('');
*
* @returns {!webdriver.promise.Promise.<void>} A promise that will be resolved
* when the element has been cleared.
*/
webdriver.WebElement.prototype.clear = function() {};
/**
* Schedules a command to test whether this element is currently displayed.
*
* @view
* <div id="foo" style="visibility:hidden">
*
* @example
* var foo = element(by.id('foo'));
* expect(foo.isDisplayed()).toBe(false);
*
* @returns {!webdriver.promise.Promise.<boolean>} A promise that will be
* resolved with whether this element is currently visible on the page.
*/
webdriver.WebElement.prototype.isDisplayed = function() {};
/**
* Take a screenshot of the visible region encompassed by this element's
* bounding rectangle.
*
* @view
* <div id="foo">Inner Text</div>
*
* @example
* function writeScreenShot(data, filename) {
* var stream = fs.createWriteStream(filename);
* stream.write(new Buffer(data, 'base64'));
* stream.end();
* }
* var foo = element(by.id('foo'));
* foo.takeScreenshot().then((png) => {
* writeScreenShot(png, 'foo.png');
* });
*
* Note that this is a new feature in WebDriver and may not be supported by
* your browser's driver. It isn't yet supported in Chromedriver as of 2.21.
*
* @param {boolean=} opt_scroll Optional argument that indicates whether the
* element should be scrolled into view before taking a screenshot. Defaults
* to false.
* @returns {!webdriver.promise.Promise.<string>} A promise that will be
* resolved to the screenshot as a base-64 encoded PNG.
*/
webdriver.WebElement.prototype.takeScreenshot = function(opt_scroll) {};