1 # from modula import * 表示默认导入modula中所有不以下划线开头的成员

 2 from _logging import _LoggingKeywords

 3 from _runonfailure import _RunOnFailureKeywords

 4 from _browsermanagement import _BrowserManagementKeywords

 5 from _element import _ElementKeywords

 6 from _tableelement import _TableElementKeywords

 7 from _formelement import _FormElementKeywords

 8 from _selectelement import _SelectElementKeywords

 9 from _javascript import _JavaScriptKeywords

10 from _cookie import _CookieKeywords

11 from _screenshot import _ScreenshotKeywords

12 from _waiting import _WaitingKeywords

13

14 # 定义了__all__后, 表示只导出以下列表中的成员

15 __all__ = [

16     "_LoggingKeywords",

17     "_RunOnFailureKeywords",

18     "_BrowserManagementKeywords",

19     "_ElementKeywords",

20     "_TableElementKeywords",

21     "_FormElementKeywords",

22     "_SelectElementKeywords",

23     "_JavaScriptKeywords",

24     "_CookieKeywords",

25     "_ScreenshotKeywords",

26     "_WaitingKeywords"

27 ]

1     def _wait_until_no_error(self, timeout, wait_func, *args):

2         timeout = robot.utils.timestr_to_secs(timeout) if timeout is not None else self._timeout_in_secs

3         maxtime = time.time() + timeout

4         while True:

5             timeout_error = wait_func(*args)

6             if not timeout_error: return  #如果wait_func()无返回,进行超时判断;否则返回wait_func()执行结果

7             if time.time() > maxtime:     #超时强制抛出timeout_error异常

8                 raise AssertionError(timeout_error)

9             time.sleep(0.2)

1     def _wait_until(self, timeout, error, function, *args):

2         error = error.replace('<TIMEOUT>', self._format_timeout(timeout))

3         def wait_func():

4             return None if function(*args) else error

5         self._wait_until_no_error(timeout, wait_func)

1     def wait_for_condition(self, condition, timeout=None, error=None):

2         if not error:

3             error = "Condition '%s' did not become true in <TIMEOUT>" % condition

4         self._wait_until(timeout, error, lambda: self._current_browser().execute_script(condition) == True)

1 class KeywordGroupMetaClass(type):

2     def __new__(cls, clsname, bases, dict):

3         if decorator:

4             for name, method in dict.items():

5                 if not name.startswith('_') and inspect.isroutine(method):

6                     dict[name] = decorator(_run_on_failure_decorator, method)

7         return type.__new__(cls, clsname, bases, dict)

 1     def register_keyword_to_run_on_failure(self, keyword):

 2         old_keyword = self._run_on_failure_keyword

 3         old_keyword_text = old_keyword if old_keyword is not None else "No keyword"

 4

 5         new_keyword = keyword if keyword.strip().lower() != "nothing" else None

 6         new_keyword_text = new_keyword if new_keyword is not None else "No keyword"

 7

 8         self._run_on_failure_keyword = new_keyword

 9         self._info('%s will be run on failure.' % new_keyword_text)

10

11         return old_keyword_text

 1     def __init__(self):

 2         strategies = {

 3             'identifier': self._find_by_identifier,

 4             'id': self._find_by_id,

 5             'name': self._find_by_name,

 6             'xpath': self._find_by_xpath,

 7             'dom': self._find_by_dom,

 8             'link': self._find_by_link_text,

 9             'partial link': self._find_by_partial_link_text,

10             'css': self._find_by_css_selector,

11             'jquery': self._find_by_sizzle_selector,

12             'sizzle': self._find_by_sizzle_selector,

13             'tag': self._find_by_tag_name,

14             'scLocator': self._find_by_sc_locator,

15             'default': self._find_by_default

16         }

17         self._strategies = NormalizedDict(initial=strategies, caseless=True, spaceless=True)

18         self._default_strategies = strategies.keys()

 1     def find(self, browser, locator, tag=None):

 2         assert browser is not None

 3         assert locator is not None and len(locator) > 0

 4         (prefix, criteria) = self._parse_locator(locator) # 从locator对象中提取prefix和criteria

 5         prefix = 'default' if prefix is None else prefix

 6         strategy = self._strategies.get(prefix) # self._strategies对象的属性石robot.util中的NormalizeDict(标准化字典)

 7         if strategy is None:

 8             raise ValueError("Element locator with prefix '" + prefix + "' is not supported")

 9         (tag, constraints) = self._get_tag_and_constraints(tag)

10         return strategy(browser, criteria, tag, constraints) # 返回strategy的find结果