{
  "specversion": 3,
  "name": "XML",
  "doc": "Robot Framework library for verifying and modifying XML documents.\n\nAs the name implies, _XML_ is a library for verifying contents of XML files.\nIn practice, it is a pretty thin wrapper on top of Python's\n[http://docs.python.org/library/xml.etree.elementtree.html|ElementTree XML API].\n\nThe library has the following main usages:\n\n- Parsing an XML file, or a string containing XML, into an XML element\n  structure and finding certain elements from it for further analysis\n  (e.g. `Parse XML` and `Get Element` keywords).\n- Getting text or attributes of elements\n  (e.g. `Get Element Text` and `Get Element Attribute`).\n- Directly verifying text, attributes, or whole elements\n  (e.g `Element Text Should Be` and `Elements Should Be Equal`).\n- Modifying XML and saving it (e.g. `Set Element Text`, `Add Element`\n  and `Save XML`).\n\n== Table of contents ==\n\n- `Parsing XML`\n- `Using lxml`\n- `Example`\n- `Finding elements with xpath`\n- `Element attributes`\n- `Handling XML namespaces`\n- `Boolean arguments`\n- `Importing`\n- `Keywords`\n\n= Parsing XML =\n\nXML can be parsed into an element structure using `Parse XML` keyword.\nThe XML to be parsed can be specified using a path to an XML file or as\na string or bytes that contain XML directly. The keyword returns the root\nelement of the structure, which then contains other elements as its\nchildren and their children. Possible comments and processing instructions\nin the source XML are removed.\n\nXML is not validated during parsing even if it has a schema defined. How\npossible doctype elements are handled otherwise depends on the used XML\nmodule and on the platform. The standard ElementTree strips doctypes\naltogether, but when `using lxml` they are preserved when XML is saved.\n\nThe element structure returned by `Parse XML`, as well as elements\nreturned by keywords such as `Get Element`, can be used as the ``source``\nargument with other keywords. In addition to an already parsed XML\nstructure, other keywords also accept paths to XML files and strings\ncontaining XML similarly as `Parse XML`. Notice that keywords that modify\nXML do not write those changes back to disk even if the source would be\ngiven as a path to a file. Changes must always be saved explicitly using\n`Save XML` keyword.\n\nWhen the source is given as a path to a file, the forward slash character\n(``/``) can be used as the path separator regardless the operating system.\nOn Windows also the backslash works, but in the data it needs to be\nescaped by doubling it (``\\\\``). Using the built-in variable ``${/}``\nnaturally works too.\n\n= Using lxml =\n\nBy default, this library uses Python's standard\n[http://docs.python.org/library/xml.etree.elementtree.html|ElementTree]\nmodule for parsing XML, but it can be configured to use\n[http://lxml.de|lxml] module instead when `importing` the library.\nThe resulting element structure has same API regardless which module\nis used for parsing.\n\nThe main benefits of using lxml is that it supports richer xpath syntax\nthan the standard ElementTree and enables using `Evaluate Xpath` keyword.\nIt also preserves the doctype and possible namespace prefixes saving XML.\n\n= Example =\n\nThe following simple example demonstrates parsing XML and verifying its\ncontents both using keywords in this library and in _BuiltIn_ and\n_Collections_ libraries. How to use xpath expressions to find elements\nand what attributes the returned elements contain are discussed, with\nmore examples, in `Finding elements with xpath` and `Element attributes`\nsections.\n\nIn this example, as well as in many other examples in this documentation,\n``${XML}`` refers to the following example XML document. In practice\n``${XML}`` could either be a path to an XML file or it could contain the XML\nitself.\n\n| <example>\n|   <first id=\"1\">text</first>\n|   <second id=\"2\">\n|     <child/>\n|   </second>\n|   <third>\n|     <child>more text</child>\n|     <second id=\"child\"/>\n|     <child><grandchild/></child>\n|   </third>\n|   <html>\n|     <p>\n|       Text with <b>bold</b> and <i>italics</i>.\n|     </p>\n|   </html>\n| </example>\n\n| ${root} =                | `Parse XML`   | ${XML}  |       |             |\n| `Should Be Equal`        | ${root.tag}   | example |       |             |\n| ${first} =               | `Get Element` | ${root} | first |             |\n| `Should Be Equal`        | ${first.text} | text    |       |             |\n| `Dictionary Should Contain Key` | ${first.attrib}  | id    |             |\n| `Element Text Should Be` | ${first}      | text    |       |             |\n| `Element Attribute Should Be` | ${first} | id      | 1     |             |\n| `Element Attribute Should Be` | ${root}  | id      | 1     | xpath=first |\n| `Element Attribute Should Be` | ${XML}   | id      | 1     | xpath=first |\n\nNotice that in the example three last lines are equivalent. Which one to\nuse in practice depends on which other elements you need to get or verify.\nIf you only need to do one verification, using the last line alone would\nsuffice. If more verifications are needed, parsing the XML with `Parse XML`\nonly once would be more efficient.\n\n= Finding elements with xpath =\n\nElementTree, and thus also this library, supports finding elements using\nxpath expressions. ElementTree does not, however, support the full xpath\nstandard. The supported xpath syntax is explained below and\n[https://docs.python.org/library/xml.etree.elementtree.html#xpath-support|\nElementTree documentation] provides more details. In the examples\n``${XML}`` refers to the same XML structure as in the earlier example.\n\nIf lxml support is enabled when `importing` the library, the whole\n[http://www.w3.org/TR/xpath/|xpath 1.0 standard] is supported.\nThat includes everything listed below but also a lot of other useful\nconstructs.\n\n== Tag names ==\n\nWhen just a single tag name is used, xpath matches all direct child\nelements that have that tag name.\n\n| ${elem} =          | `Get Element`  | ${XML}      | third |\n| `Should Be Equal`  | ${elem.tag}    | third       |       |\n| @{children} =      | `Get Elements` | ${elem}     | child |\n| `Length Should Be` | ${children}    | 2           |       |\n\n== Paths ==\n\nPaths are created by combining tag names with a forward slash (``/``). For\nexample, ``parent/child`` matches all ``child`` elements under ``parent``\nelement. Notice that if there are multiple ``parent`` elements that all\nhave ``child`` elements, ``parent/child`` xpath will match all these\n``child`` elements.\n\n| ${elem} =         | `Get Element` | ${XML}     | second/child            |\n| `Should Be Equal` | ${elem.tag}   | child      |                         |\n| ${elem} =         | `Get Element` | ${XML}     | third/child/grandchild  |\n| `Should Be Equal` | ${elem.tag}   | grandchild |                         |\n\n== Wildcards ==\n\nAn asterisk (``*``) can be used in paths instead of a tag name to denote\nany element.\n\n| @{children} =      | `Get Elements` | ${XML} | */child |\n| `Length Should Be` | ${children}    | 3      |         |\n\n== Current element ==\n\nThe current element is denoted with a dot (``.``). Normally the current\nelement is implicit and does not need to be included in the xpath.\n\n== Parent element ==\n\nThe parent element of another element is denoted with two dots (``..``).\nNotice that it is not possible to refer to the parent of the current\nelement.\n\n| ${elem} =         | `Get Element` | ${XML} | */second/.. |\n| `Should Be Equal` | ${elem.tag}   | third  |             |\n\n== Search all sub elements ==\n\nTwo forward slashes (``//``) mean that all sub elements, not only the\ndirect children, are searched. If the search is started from the current\nelement, an explicit dot is required.\n\n| @{elements} =      | `Get Elements` | ${XML} | .//second |\n| `Length Should Be` | ${elements}    | 2      |           |\n| ${b} =             | `Get Element`  | ${XML} | html//b   |\n| `Should Be Equal`  | ${b.text}      | bold   |           |\n\n== Predicates ==\n\nPredicates allow selecting elements using also other criteria than tag\nnames, for example, attributes or position. They are specified after the\nnormal tag name or path using syntax ``path[predicate]``. The path can have\nwildcards and other special syntax explained earlier. What predicates\nthe standard ElementTree supports is explained in the table below.\n\n|  = Predicate =  |             = Matches =           |    = Example =     |\n| @attrib         | Elements with attribute ``attrib``. | second[@id]        |\n| @attrib=\"value\" | Elements with attribute ``attrib`` having value ``value``. | *[@id=\"2\"] |\n| position        | Elements at the specified position. Position can be an integer (starting from 1), expression ``last()``, or relative expression like ``last() - 1``. | third/child[1] |\n| tag             | Elements with a child element named ``tag``. | third/child[grandchild] |\n\nPredicates can also be stacked like ``path[predicate1][predicate2]``.\nA limitation is that possible position predicate must always be first.\n\n= Element attributes =\n\nAll keywords returning elements, such as `Parse XML`, and `Get Element`,\nreturn ElementTree's\n[http://docs.python.org/library/xml.etree.elementtree.html#element-objects|Element objects].\nThese elements can be used as inputs for other keywords, but they also\ncontain several useful attributes that can be accessed directly using\nthe extended variable syntax.\n\nThe attributes that are both useful and convenient to use in the data\nare explained below. Also other attributes, including methods, can\nbe accessed, but that is typically better to do in custom libraries than\ndirectly in the data.\n\nThe examples use the same ``${XML}`` structure as the earlier examples.\n\n== tag ==\n\nThe tag of the element.\n\n| ${root} =         | `Parse XML` | ${XML}  |\n| `Should Be Equal` | ${root.tag} | example |\n\n== text ==\n\nThe text that the element contains or Python ``None`` if the element has no\ntext. Notice that the text _does not_ contain texts of possible child\nelements nor text after or between children. Notice also that in XML\nwhitespace is significant, so the text contains also possible indentation\nand newlines. To get also text of the possible children, optionally\nwhitespace normalized, use `Get Element Text` keyword.\n\n| ${1st} =          | `Get Element` | ${XML}  | first        |\n| `Should Be Equal` | ${1st.text}   | text    |              |\n| ${2nd} =          | `Get Element` | ${XML}  | second/child |\n| `Should Be Equal` | ${2nd.text}   | ${NONE} |              |\n| ${p} =            | `Get Element` | ${XML}  | html/p       |\n| `Should Be Equal` | ${p.text}     | \\n${SPACE*6}Text with${SPACE} |\n\n== tail ==\n\nThe text after the element before the next opening or closing tag. Python\n``None`` if the element has no tail. Similarly as with ``text``, also\n``tail`` contains possible indentation and newlines.\n\n| ${b} =            | `Get Element` | ${XML}  | html/p/b  |\n| `Should Be Equal` | ${b.tail}     | ${SPACE}and${SPACE} |\n\n== attrib ==\n\nA Python dictionary containing attributes of the element.\n\n| ${2nd} =          | `Get Element`       | ${XML} | second |\n| `Should Be Equal` | ${2nd.attrib['id']} | 2      |        |\n| ${3rd} =          | `Get Element`       | ${XML} | third  |\n| `Should Be Empty` | ${3rd.attrib}       |        |        |\n\n= Handling XML namespaces =\n\nElementTree and lxml handle possible namespaces in XML documents by adding\nthe namespace URI to tag names in so-called Clark Notation. That is\ninconvenient especially with xpaths, and by default this library strips\nthose namespaces away and moves them to ``xmlns`` attribute instead. That\ncan be avoided by passing ``keep_clark_notation`` argument to `Parse XML`\nkeyword. Alternatively `Parse XML` supports stripping namespace information\naltogether by using ``strip_namespaces`` argument. The pros and cons of\ndifferent approaches are discussed in more detail below.\n\n== How ElementTree handles namespaces ==\n\nIf an XML document has namespaces, ElementTree adds namespace information\nto tag names in [http://www.jclark.com/xml/xmlns.htm|Clark Notation]\n(e.g. ``{http://ns.uri}tag``) and removes original ``xmlns`` attributes.\nThis is done both with default namespaces and with namespaces with a prefix.\nHow it works in practice is illustrated by the following example, where\n``${NS}`` variable contains this XML document:\n\n| <xsl:stylesheet xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\"\n|                 xmlns=\"http://www.w3.org/1999/xhtml\">\n|   <xsl:template match=\"/\">\n|     <html></html>\n|   </xsl:template>\n| </xsl:stylesheet>\n\n| ${root} = | `Parse XML` | ${NS} | keep_clark_notation=yes |\n| `Should Be Equal` | ${root.tag} | {http://www.w3.org/1999/XSL/Transform}stylesheet |\n| `Element Should Exist` | ${root} | {http://www.w3.org/1999/XSL/Transform}template/{http://www.w3.org/1999/xhtml}html |\n| `Should Be Empty` | ${root.attrib} |\n\nAs you can see, including the namespace URI in tag names makes xpaths\nreally long and complex.\n\nIf you save the XML, ElementTree moves namespace information back to\n``xmlns`` attributes. Unfortunately it does not restore the original\nprefixes:\n\n| <ns0:stylesheet xmlns:ns0=\"http://www.w3.org/1999/XSL/Transform\">\n|   <ns0:template match=\"/\">\n|     <ns1:html xmlns:ns1=\"http://www.w3.org/1999/xhtml\"></ns1:html>\n|   </ns0:template>\n| </ns0:stylesheet>\n\nThe resulting output is semantically same as the original, but mangling\nprefixes like this may still not be desirable. Notice also that the actual\noutput depends slightly on ElementTree version.\n\n== Default namespace handling ==\n\nBecause the way ElementTree handles namespaces makes xpaths so complicated,\nthis library, by default, strips namespaces from tag names and moves that\ninformation back to ``xmlns`` attributes. How this works in practice is\nshown by the example below, where ``${NS}`` variable contains the same XML\ndocument as in the previous example.\n\n| ${root} = | `Parse XML` | ${NS} |\n| `Should Be Equal` | ${root.tag} | stylesheet |\n| `Element Should Exist` | ${root} | template/html |\n| `Element Attribute Should Be` | ${root} | xmlns | http://www.w3.org/1999/XSL/Transform |\n| `Element Attribute Should Be` | ${root} | xmlns | http://www.w3.org/1999/xhtml | xpath=template/html |\n\nNow that tags do not contain namespace information, xpaths are simple again.\n\nA minor limitation of this approach is that namespace prefixes are lost.\nAs a result the saved output is not exactly same as the original one in\nthis case either:\n\n| <stylesheet xmlns=\"http://www.w3.org/1999/XSL/Transform\">\n|   <template match=\"/\">\n|     <html xmlns=\"http://www.w3.org/1999/xhtml\"></html>\n|   </template>\n| </stylesheet>\n\nAlso this output is semantically same as the original. If the original XML\nhad only default namespaces, the output would also look identical.\n\n== Namespaces when using lxml ==\n\nThis library handles namespaces same way both when `using lxml` and when\nnot using it. There are, however, differences how lxml internally handles\nnamespaces compared to the standard ElementTree. The main difference is\nthat lxml stores information about namespace prefixes and they are thus\npreserved if XML is saved. Another visible difference is that lxml includes\nnamespace information in child elements got with `Get Element` if the\nparent element has namespaces.\n\n== Stripping namespaces altogether ==\n\nBecause namespaces often add unnecessary complexity, `Parse XML` supports\nstripping them altogether by using ``strip_namespaces=True``. When this\noption is enabled, namespaces are not shown anywhere nor are they included\nif XML is saved.\n\n== Attribute namespaces ==\n\nAttributes in XML documents are, by default, in the same namespaces as\nthe element they belong to. It is possible to use different namespaces\nby using prefixes, but this is pretty rare.\n\nIf an attribute has a namespace prefix, ElementTree will replace it with\nClark Notation the same way it handles elements. Because stripping\nnamespaces from attributes could cause attribute conflicts, this library\ndoes not handle attribute namespaces at all. Thus the following example\nworks the same way regardless how namespaces are handled.\n\n| ${root} = | `Parse XML` | <root id=\"1\" ns:id=\"2\" xmlns:ns=\"http://my.ns\"/> |\n| `Element Attribute Should Be` | ${root} | id | 1 |\n| `Element Attribute Should Be` | ${root} | {http://my.ns}id | 2 |\n\n= Boolean arguments =\n\nSome keywords accept arguments that are handled as Boolean values true or\nfalse. If such an argument is given as a string, it is considered false if\nit is an empty string or equal to ``FALSE``, ``NONE``, ``NO``, ``OFF`` or\n``0``, case-insensitively. Other strings are considered true regardless\ntheir value, and other argument types are tested using the same\n[http://docs.python.org/library/stdtypes.html#truth|rules as in Python].\n\nTrue examples:\n| `Parse XML` | ${XML} | keep_clark_notation=True    | # Strings are generally true.    |\n| `Parse XML` | ${XML} | keep_clark_notation=yes     | # Same as the above.             |\n| `Parse XML` | ${XML} | keep_clark_notation=${TRUE} | # Python ``True`` is true.       |\n| `Parse XML` | ${XML} | keep_clark_notation=${42}   | # Numbers other than 0 are true. |\n\nFalse examples:\n| `Parse XML` | ${XML} | keep_clark_notation=False    | # String ``false`` is false.   |\n| `Parse XML` | ${XML} | keep_clark_notation=no       | # Also string ``no`` is false. |\n| `Parse XML` | ${XML} | keep_clark_notation=${EMPTY} | # Empty string is false.       |\n| `Parse XML` | ${XML} | keep_clark_notation=${FALSE} | # Python ``False`` is false.   |\n\n== Pattern matching ==\n\nSome keywords, for example `Elements Should Match`, support so called\n[http://en.wikipedia.org/wiki/Glob_(programming)|glob patterns] where:\n\n| ``*``        | matches any string, even an empty string                |\n| ``?``        | matches any single character                            |\n| ``[chars]``  | matches one character in the bracket                    |\n| ``[!chars]`` | matches one character not in the bracket                |\n| ``[a-z]``    | matches one character from the range in the bracket     |\n| ``[!a-z]``   | matches one character not from the range in the bracket |\n\nUnlike with glob patterns normally, path separator characters ``/`` and\n``\\`` and the newline character ``\\n`` are matches by the above\nwildcards.",
  "version": "7.2.dev1",
  "generated": "2024-10-02T23:00:47+00:00",
  "type": "LIBRARY",
  "scope": "GLOBAL",
  "docFormat": "ROBOT",
  "source": "/home/peke/Devel/robotframework/src/robot/libraries/XML.py",
  "lineno": 45,
  "tags": [],
  "inits": [
    {
      "name": "__init__",
      "args": [
        {
          "name": "use_lxml",
          "type": null,
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "use_lxml=False"
        }
      ],
      "returnType": null,
      "doc": "Import library with optionally lxml mode enabled.\n\nThis library uses Python's standard\n[http://docs.python.org/library/xml.etree.elementtree.html|ElementTree]\nmodule for parsing XML by default. If ``use_lxml`` argument is given\na true value (see `Boolean arguments`), the [http://lxml.de|lxml] module\nis used instead. See the `Using lxml` section for benefits provided by lxml.\n\nUsing lxml requires that the lxml module is installed on the system.\nIf lxml mode is enabled but the module is not installed, this library\nemits a warning and reverts back to using the standard ElementTree.",
      "shortdoc": "Import library with optionally lxml mode enabled.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/XML.py",
      "lineno": 452
    }
  ],
  "keywords": [
    {
      "name": "Add Element",
      "args": [
        {
          "name": "source",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "source"
        },
        {
          "name": "element",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "element"
        },
        {
          "name": "index",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "index=None"
        },
        {
          "name": "xpath",
          "type": null,
          "defaultValue": ".",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "xpath=."
        }
      ],
      "returnType": null,
      "doc": "Adds a child element to the specified element.\n\nThe element to whom to add the new element is specified using ``source``\nand ``xpath``. They have exactly the same semantics as with `Get Element`\nkeyword. The resulting XML structure is returned, and if the ``source``\nis an already parsed XML structure, it is also modified in place.\n\nThe ``element`` to add can be specified as a path to an XML file or\nas a string containing XML, or it can be an already parsed XML element.\nThe element is copied before adding so modifying either the original\nor the added element has no effect on the other\n.\nThe element is added as the last child by default, but a custom index\ncan be used to alter the position. Indices start from zero (0 = first\nposition, 1 = second position, etc.), and negative numbers refer to\npositions at the end (-1 = second last position, -2 = third last, etc.).\n\nExamples using ``${XML}`` structure from `Example`:\n| Add Element | ${XML} | <new id=\"x\"><c1/></new> |\n| Add Element | ${XML} | <c2/> | xpath=new |\n| Add Element | ${XML} | <c3/> | index=1 | xpath=new |\n| ${new} = | Get Element | ${XML} | new |\n| Elements Should Be Equal | ${new} | <new id=\"x\"><c1/><c3/><c2/></new> |\n\nUse `Remove Element` or `Remove Elements` to remove elements.",
      "shortdoc": "Adds a child element to the specified element.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/XML.py",
      "lineno": 1135
    },
    {
      "name": "Clear Element",
      "args": [
        {
          "name": "source",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "source"
        },
        {
          "name": "xpath",
          "type": null,
          "defaultValue": ".",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "xpath=."
        },
        {
          "name": "clear_tail",
          "type": null,
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "clear_tail=False"
        }
      ],
      "returnType": null,
      "doc": "Clears the contents of the specified element.\n\nThe element to clear is specified using ``source`` and ``xpath``. They\nhave exactly the same semantics as with `Get Element` keyword.\nThe resulting XML structure is returned, and if the ``source`` is\nan already parsed XML structure, it is also modified in place.\n\nClearing the element means removing its text, attributes, and children.\nElement's tail text is not removed by default, but that can be changed\nby giving ``clear_tail`` a true value (see `Boolean arguments`). See\n`Element attributes` section for more information about tail in\ngeneral.\n\nExamples using ``${XML}`` structure from `Example`:\n| Clear Element            | ${XML}   | xpath=first |\n| ${first} = | Get Element | ${XML}   | xpath=first |\n| Elements Should Be Equal | ${first} | <first/>    |\n| Clear Element            | ${XML}   | xpath=html/p/b | clear_tail=yes |\n| Element Text Should Be   | ${XML}   | Text with italics. | xpath=html/p | normalize_whitespace=yes |\n| Clear Element            | ${XML}   |\n| Elements Should Be Equal | ${XML}   | <example/> |\n\nUse `Remove Element` to remove the whole element.",
      "shortdoc": "Clears the contents of the specified element.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/XML.py",
      "lineno": 1244
    },
    {
      "name": "Copy Element",
      "args": [
        {
          "name": "source",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "source"
        },
        {
          "name": "xpath",
          "type": null,
          "defaultValue": ".",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "xpath=."
        }
      ],
      "returnType": null,
      "doc": "Returns a copy of the specified element.\n\nThe element to copy is specified using ``source`` and ``xpath``. They\nhave exactly the same semantics as with `Get Element` keyword.\n\nIf the copy or the original element is modified afterward, the changes\nhave no effect on the other.\n\nExamples using ``${XML}`` structure from `Example`:\n| ${elem} =  | Get Element  | ${XML}  | xpath=first |\n| ${copy1} = | Copy Element | ${elem} |\n| ${copy2} = | Copy Element | ${XML}  | xpath=first |\n| Set Element Text         | ${XML}   | new text    | xpath=first      |\n| Set Element Attribute    | ${copy1} | id          | new              |\n| Elements Should Be Equal | ${elem}  | <first id=\"1\">new text</first> |\n| Elements Should Be Equal | ${copy1} | <first id=\"new\">text</first>   |\n| Elements Should Be Equal | ${copy2} | <first id=\"1\">text</first>     |",
      "shortdoc": "Returns a copy of the specified element.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/XML.py",
      "lineno": 1277
    },
    {
      "name": "Element Attribute Should Be",
      "args": [
        {
          "name": "source",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "source"
        },
        {
          "name": "name",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "name"
        },
        {
          "name": "expected",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "expected"
        },
        {
          "name": "xpath",
          "type": null,
          "defaultValue": ".",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "xpath=."
        },
        {
          "name": "message",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "message=None"
        }
      ],
      "returnType": null,
      "doc": "Verifies that the specified attribute is ``expected``.\n\nThe element whose attribute is verified is specified using ``source``\nand ``xpath``. They have exactly the same semantics as with\n`Get Element` keyword.\n\nThe keyword passes if the attribute ``name`` of the element is equal to\nthe ``expected`` value, and otherwise it fails. The default error\nmessage can be overridden with the ``message`` argument.\n\nTo test that the element does not have a certain attribute, Python\n``None`` (i.e. variable ``${NONE}``) can be used as the expected value.\nA cleaner alternative is using `Element Should Not Have Attribute`.\n\nExamples using ``${XML}`` structure from `Example`:\n| Element Attribute Should Be | ${XML} | id | 1       | xpath=first |\n| Element Attribute Should Be | ${XML} | id | ${NONE} |             |\n\nSee also `Element Attribute Should Match` and `Get Element Attribute`.",
      "shortdoc": "Verifies that the specified attribute is ``expected``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/XML.py",
      "lineno": 805
    },
    {
      "name": "Element Attribute Should Match",
      "args": [
        {
          "name": "source",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "source"
        },
        {
          "name": "name",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "name"
        },
        {
          "name": "pattern",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "pattern"
        },
        {
          "name": "xpath",
          "type": null,
          "defaultValue": ".",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "xpath=."
        },
        {
          "name": "message",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "message=None"
        }
      ],
      "returnType": null,
      "doc": "Verifies that the specified attribute matches ``expected``.\n\nThis keyword works exactly like `Element Attribute Should Be` except\nthat the expected value can be given as a pattern that the attribute of\nthe element must match.\n\nPattern matching is similar as matching files in a shell with\n``*``, ``?`` and ``[chars]`` acting as wildcards. See the\n`Pattern matching` section for more information.\n\nExamples using ``${XML}`` structure from `Example`:\n| Element Attribute Should Match | ${XML} | id | ?   | xpath=first |\n| Element Attribute Should Match | ${XML} | id | c*d | xpath=third/second |",
      "shortdoc": "Verifies that the specified attribute matches ``expected``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/XML.py",
      "lineno": 830
    },
    {
      "name": "Element Should Exist",
      "args": [
        {
          "name": "source",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "source"
        },
        {
          "name": "xpath",
          "type": null,
          "defaultValue": ".",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "xpath=."
        },
        {
          "name": "message",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "message=None"
        }
      ],
      "returnType": null,
      "doc": "Verifies that one or more element match the given ``xpath``.\n\nArguments ``source`` and ``xpath`` have exactly the same semantics as\nwith `Get Elements` keyword. Keyword passes if the ``xpath`` matches\none or more elements in the ``source``. The default error message can\nbe overridden with the ``message`` argument.\n\nSee also `Element Should Not Exist` as well as `Get Element Count`\nthat this keyword uses internally.",
      "shortdoc": "Verifies that one or more element match the given ``xpath``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/XML.py",
      "lineno": 616
    },
    {
      "name": "Element Should Not Exist",
      "args": [
        {
          "name": "source",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "source"
        },
        {
          "name": "xpath",
          "type": null,
          "defaultValue": ".",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "xpath=."
        },
        {
          "name": "message",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "message=None"
        }
      ],
      "returnType": null,
      "doc": "Verifies that no element match the given ``xpath``.\n\nArguments ``source`` and ``xpath`` have exactly the same semantics as\nwith `Get Elements` keyword. Keyword fails if the ``xpath`` matches any\nelement in the ``source``. The default error message can be overridden\nwith the ``message`` argument.\n\nSee also `Element Should Exist` as well as `Get Element Count`\nthat this keyword uses internally.",
      "shortdoc": "Verifies that no element match the given ``xpath``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/XML.py",
      "lineno": 631
    },
    {
      "name": "Element Should Not Have Attribute",
      "args": [
        {
          "name": "source",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "source"
        },
        {
          "name": "name",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "name"
        },
        {
          "name": "xpath",
          "type": null,
          "defaultValue": ".",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "xpath=."
        },
        {
          "name": "message",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "message=None"
        }
      ],
      "returnType": null,
      "doc": "Verifies that the specified element does not have attribute ``name``.\n\nThe element whose attribute is verified is specified using ``source``\nand ``xpath``. They have exactly the same semantics as with\n`Get Element` keyword.\n\nThe keyword fails if the specified element has attribute ``name``. The\ndefault error message can be overridden with the ``message`` argument.\n\nExamples using ``${XML}`` structure from `Example`:\n| Element Should Not Have Attribute | ${XML} | id  |\n| Element Should Not Have Attribute | ${XML} | xxx | xpath=first |\n\nSee also `Get Element Attribute`, `Get Element Attributes`,\n`Element Text Should Be` and `Element Text Should Match`.",
      "shortdoc": "Verifies that the specified element does not have attribute ``name``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/XML.py",
      "lineno": 851
    },
    {
      "name": "Element Text Should Be",
      "args": [
        {
          "name": "source",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "source"
        },
        {
          "name": "expected",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "expected"
        },
        {
          "name": "xpath",
          "type": null,
          "defaultValue": ".",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "xpath=."
        },
        {
          "name": "normalize_whitespace",
          "type": null,
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "normalize_whitespace=False"
        },
        {
          "name": "message",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "message=None"
        }
      ],
      "returnType": null,
      "doc": "Verifies that the text of the specified element is ``expected``.\n\nThe element whose text is verified is specified using ``source`` and\n``xpath``. They have exactly the same semantics as with `Get Element`\nkeyword.\n\nThe text to verify is got from the specified element using the same\nlogic as with `Get Element Text`. This includes optional whitespace\nnormalization using the ``normalize_whitespace`` option.\n\nThe keyword passes if the text of the element is equal to the\n``expected`` value, and otherwise it fails. The default error message\ncan be overridden with the ``message`` argument.  Use `Element Text\nShould Match` to verify the text against a pattern instead of an exact\nvalue.\n\nExamples using ``${XML}`` structure from `Example`:\n| Element Text Should Be | ${XML}       | text     | xpath=first      |\n| Element Text Should Be | ${XML}       | ${EMPTY} | xpath=second/child |\n| ${paragraph} =         | Get Element  | ${XML}   | xpath=html/p     |\n| Element Text Should Be | ${paragraph} | Text with bold and italics. | normalize_whitespace=yes |",
      "shortdoc": "Verifies that the text of the specified element is ``expected``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/XML.py",
      "lineno": 715
    },
    {
      "name": "Element Text Should Match",
      "args": [
        {
          "name": "source",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "source"
        },
        {
          "name": "pattern",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "pattern"
        },
        {
          "name": "xpath",
          "type": null,
          "defaultValue": ".",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "xpath=."
        },
        {
          "name": "normalize_whitespace",
          "type": null,
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "normalize_whitespace=False"
        },
        {
          "name": "message",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "message=None"
        }
      ],
      "returnType": null,
      "doc": "Verifies that the text of the specified element matches ``expected``.\n\nThis keyword works exactly like `Element Text Should Be` except that\nthe expected value can be given as a pattern that the text of the\nelement must match.\n\nPattern matching is similar as matching files in a shell with\n``*``, ``?`` and ``[chars]`` acting as wildcards. See the\n`Pattern matching` section for more information.\n\nExamples using ``${XML}`` structure from `Example`:\n| Element Text Should Match | ${XML}       | t???   | xpath=first  |\n| ${paragraph} =            | Get Element  | ${XML} | xpath=html/p |\n| Element Text Should Match | ${paragraph} | Text with * and *. | normalize_whitespace=yes |",
      "shortdoc": "Verifies that the text of the specified element matches ``expected``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/XML.py",
      "lineno": 742
    },
    {
      "name": "Element To String",
      "args": [
        {
          "name": "source",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "source"
        },
        {
          "name": "xpath",
          "type": null,
          "defaultValue": ".",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "xpath=."
        },
        {
          "name": "encoding",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "encoding=None"
        }
      ],
      "returnType": null,
      "doc": "Returns the string representation of the specified element.\n\nThe element to convert to a string is specified using ``source`` and\n``xpath``. They have exactly the same semantics as with `Get Element`\nkeyword.\n\nThe string is returned as Unicode by default. If ``encoding`` argument\nis given any value, the string is returned as bytes in the specified\nencoding. The resulting string never contains the XML declaration.\n\nSee also `Log Element` and `Save XML`.",
      "shortdoc": "Returns the string representation of the specified element.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/XML.py",
      "lineno": 1298
    },
    {
      "name": "Elements Should Be Equal",
      "args": [
        {
          "name": "source",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "source"
        },
        {
          "name": "expected",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "expected"
        },
        {
          "name": "exclude_children",
          "type": null,
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "exclude_children=False"
        },
        {
          "name": "normalize_whitespace",
          "type": null,
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "normalize_whitespace=False"
        },
        {
          "name": "sort_children",
          "type": null,
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "sort_children=False"
        }
      ],
      "returnType": null,
      "doc": "Verifies that the given ``source`` element is equal to ``expected``.\n\nBoth ``source`` and ``expected`` can be given as a path to an XML file,\nas a string containing XML, or as an already parsed XML element\nstructure. See `introduction` for more information about parsing XML in\ngeneral.\n\nThe keyword passes if the ``source`` element and ``expected`` element\nare equal. This includes testing the tag names, texts, and attributes\nof the elements. By default, also child elements are verified the same\nway, but this can be disabled by setting ``exclude_children`` to a\ntrue value (see `Boolean arguments`). Child elements are expected to\nbe in the same order, but that can be changed by giving ``sort_children``\na true value. Notice that elements are sorted solely based on tag names.\n\nAll texts inside the given elements are verified, but possible text\noutside them is not. By default, texts must match exactly, but setting\n``normalize_whitespace`` to a true value makes text verification\nindependent on newlines, tabs, and the amount of spaces. For more\ndetails about handling text see `Get Element Text` keyword and\ndiscussion about elements' `text` and `tail` attributes in the\n`introduction`.\n\nExamples using ``${XML}`` structure from `Example`:\n| ${first} =               | Get Element | ${XML} | first             |\n| Elements Should Be Equal | ${first}    | <first id=\"1\">text</first> |\n| ${p} =                   | Get Element | ${XML} | html/p            |\n| Elements Should Be Equal | ${p} | <p>Text with <b>bold</b> and <i>italics</i>.</p> | normalize_whitespace=yes |\n| Elements Should Be Equal | ${p} | <p>Text with</p> | exclude | normalize |\n\nThe last example may look a bit strange because the ``<p>`` element\nonly has text ``Text with``. The reason is that rest of the text\ninside ``<p>`` actually belongs to the child elements. This includes\nthe ``.`` at the end that is the `tail` text of the ``<i>`` element.\n\nSee also `Elements Should Match`.\n\n``sort_children`` is new in Robot Framework 7.0.",
      "shortdoc": "Verifies that the given ``source`` element is equal to ``expected``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/XML.py",
      "lineno": 873
    },
    {
      "name": "Elements Should Match",
      "args": [
        {
          "name": "source",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "source"
        },
        {
          "name": "expected",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "expected"
        },
        {
          "name": "exclude_children",
          "type": null,
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "exclude_children=False"
        },
        {
          "name": "normalize_whitespace",
          "type": null,
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "normalize_whitespace=False"
        },
        {
          "name": "sort_children",
          "type": null,
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "sort_children=False"
        }
      ],
      "returnType": null,
      "doc": "Verifies that the given ``source`` element matches ``expected``.\n\nThis keyword works exactly like `Elements Should Be Equal` except that\ntexts and attribute values in the expected value can be given as\npatterns.\n\nPattern matching is similar as matching files in a shell with\n``*``, ``?`` and ``[chars]`` acting as wildcards. See the\n`Pattern matching` section for more information.\n\nExamples using ``${XML}`` structure from `Example`:\n| ${first} =            | Get Element | ${XML} | first          |\n| Elements Should Match | ${first}    | <first id=\"?\">*</first> |\n\nSee `Elements Should Be Equal` for more examples.",
      "shortdoc": "Verifies that the given ``source`` element matches ``expected``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/XML.py",
      "lineno": 917
    },
    {
      "name": "Evaluate Xpath",
      "args": [
        {
          "name": "source",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "source"
        },
        {
          "name": "expression",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "expression"
        },
        {
          "name": "context",
          "type": null,
          "defaultValue": ".",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "context=."
        }
      ],
      "returnType": null,
      "doc": "Evaluates the given xpath expression and returns results.\n\nThe element in which context the expression is executed is specified\nusing ``source`` and ``context`` arguments. They have exactly the same\nsemantics as ``source`` and ``xpath`` arguments have with `Get Element`\nkeyword.\n\nThe xpath expression to evaluate is given as ``expression`` argument.\nThe result of the evaluation is returned as-is.\n\nExamples using ``${XML}`` structure from `Example`:\n| ${count} =      | Evaluate Xpath | ${XML}  | count(third/*) |\n| Should Be Equal | ${count}       | ${3}    |\n| ${text} =       | Evaluate Xpath | ${XML}  | string(descendant::second[last()]/@id) |\n| Should Be Equal | ${text}        | child   |\n| ${bold} =       | Evaluate Xpath | ${XML}  | boolean(preceding-sibling::*[1] = 'bold') | context=html/p/i |\n| Should Be Equal | ${bold}        | ${True} |\n\nThis keyword works only if lxml mode is taken into use when `importing`\nthe library.",
      "shortdoc": "Evaluates the given xpath expression and returns results.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/XML.py",
      "lineno": 1373
    },
    {
      "name": "Get Child Elements",
      "args": [
        {
          "name": "source",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "source"
        },
        {
          "name": "xpath",
          "type": null,
          "defaultValue": ".",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "xpath=."
        }
      ],
      "returnType": null,
      "doc": "Returns the child elements of the specified element as a list.\n\nThe element whose children to return is specified using ``source`` and\n``xpath``. They have exactly the same semantics as with `Get Element`\nkeyword.\n\nAll the direct child elements of the specified element are returned.\nIf the element has no children, an empty list is returned.\n\nExamples using ``${XML}`` structure from `Example`:\n| ${children} =    | Get Child Elements | ${XML} |             |\n| Length Should Be | ${children}        | 4      |             |\n| ${children} =    | Get Child Elements | ${XML} | xpath=first |\n| Should Be Empty  | ${children}        |        |             |",
      "shortdoc": "Returns the child elements of the specified element as a list.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/XML.py",
      "lineno": 586
    },
    {
      "name": "Get Element",
      "args": [
        {
          "name": "source",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "source"
        },
        {
          "name": "xpath",
          "type": null,
          "defaultValue": ".",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "xpath=."
        }
      ],
      "returnType": null,
      "doc": "Returns an element in the ``source`` matching the ``xpath``.\n\nThe ``source`` can be a path to an XML file, a string containing XML, or\nan already parsed XML element. The ``xpath`` specifies which element to\nfind. See the `introduction` for more details about both the possible\nsources and the supported xpath syntax.\n\nThe keyword fails if more, or less, than one element matches the\n``xpath``. Use `Get Elements` if you want all matching elements to be\nreturned.\n\nExamples using ``${XML}`` structure from `Example`:\n| ${element} = | Get Element | ${XML}     | second |\n| ${child} =   | Get Element | ${element} | child  |\n\n`Parse XML` is recommended for parsing XML when the whole structure\nis needed. It must be used if there is a need to configure how XML\nnamespaces are handled.\n\nMany other keywords use this keyword internally, and keywords modifying\nXML are typically documented to both to modify the given source and\nto return it. Modifying the source does not apply if the source is\ngiven as a string. The XML structure parsed based on the string and\nthen modified is nevertheless returned.",
      "shortdoc": "Returns an element in the ``source`` matching the ``xpath``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/XML.py",
      "lineno": 521
    },
    {
      "name": "Get Element Attribute",
      "args": [
        {
          "name": "source",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "source"
        },
        {
          "name": "name",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "name"
        },
        {
          "name": "xpath",
          "type": null,
          "defaultValue": ".",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "xpath=."
        },
        {
          "name": "default",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "default=None"
        }
      ],
      "returnType": null,
      "doc": "Returns the named attribute of the specified element.\n\nThe element whose attribute to return is specified using ``source`` and\n``xpath``. They have exactly the same semantics as with `Get Element`\nkeyword.\n\nThe value of the attribute ``name`` of the specified element is returned.\nIf the element does not have such element, the ``default`` value is\nreturned instead.\n\nExamples using ``${XML}`` structure from `Example`:\n| ${attribute} =  | Get Element Attribute | ${XML} | id | xpath=first |\n| Should Be Equal | ${attribute}          | 1      |    |             |\n| ${attribute} =  | Get Element Attribute | ${XML} | xx | xpath=first | default=value |\n| Should Be Equal | ${attribute}          | value  |    |             |\n\nSee also `Get Element Attributes`, `Element Attribute Should Be`,\n`Element Attribute Should Match` and `Element Should Not Have Attribute`.",
      "shortdoc": "Returns the named attribute of the specified element.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/XML.py",
      "lineno": 763
    },
    {
      "name": "Get Element Attributes",
      "args": [
        {
          "name": "source",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "source"
        },
        {
          "name": "xpath",
          "type": null,
          "defaultValue": ".",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "xpath=."
        }
      ],
      "returnType": null,
      "doc": "Returns all attributes of the specified element.\n\nThe element whose attributes to return is specified using ``source`` and\n``xpath``. They have exactly the same semantics as with `Get Element`\nkeyword.\n\nAttributes are returned as a Python dictionary. It is a copy of the\noriginal attributes so modifying it has no effect on the XML structure.\n\nExamples using ``${XML}`` structure from `Example`:\n| ${attributes} = | Get Element Attributes      | ${XML} | first |\n| Dictionary Should Contain Key | ${attributes} | id     |       |\n| ${attributes} = | Get Element Attributes      | ${XML} | third |\n| Should Be Empty | ${attributes}               |        |       |\n\nUse `Get Element Attribute` to get the value of a single attribute.",
      "shortdoc": "Returns all attributes of the specified element.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/XML.py",
      "lineno": 785
    },
    {
      "name": "Get Element Count",
      "args": [
        {
          "name": "source",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "source"
        },
        {
          "name": "xpath",
          "type": null,
          "defaultValue": ".",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "xpath=."
        }
      ],
      "returnType": null,
      "doc": "Returns and logs how many elements the given ``xpath`` matches.\n\nArguments ``source`` and ``xpath`` have exactly the same semantics as\nwith `Get Elements` keyword that this keyword uses internally.\n\nSee also `Element Should Exist` and `Element Should Not Exist`.",
      "shortdoc": "Returns and logs how many elements the given ``xpath`` matches.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/XML.py",
      "lineno": 604
    },
    {
      "name": "Get Element Text",
      "args": [
        {
          "name": "source",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "source"
        },
        {
          "name": "xpath",
          "type": null,
          "defaultValue": ".",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "xpath=."
        },
        {
          "name": "normalize_whitespace",
          "type": null,
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "normalize_whitespace=False"
        }
      ],
      "returnType": null,
      "doc": "Returns all text of the element, possibly whitespace normalized.\n\nThe element whose text to return is specified using ``source`` and\n``xpath``. They have exactly the same semantics as with `Get Element`\nkeyword.\n\nThis keyword returns all the text of the specified element, including\nall the text its children and grandchildren contain. If the element\nhas no text, an empty string is returned. The returned text is thus not\nalways the same as the `text` attribute of the element.\n\nBy default all whitespace, including newlines and indentation, inside\nthe element is returned as-is. If ``normalize_whitespace`` is given\na true value (see `Boolean arguments`), then leading and trailing\nwhitespace is stripped, newlines and tabs converted to spaces, and\nmultiple spaces collapsed into one. This is especially useful when\ndealing with HTML data.\n\nExamples using ``${XML}`` structure from `Example`:\n| ${text} =       | Get Element Text | ${XML}       | first        |\n| Should Be Equal | ${text}          | text         |              |\n| ${text} =       | Get Element Text | ${XML}       | second/child |\n| Should Be Empty | ${text}          |              |              |\n| ${paragraph} =  | Get Element      | ${XML}       | html/p       |\n| ${text} =       | Get Element Text | ${paragraph} | normalize_whitespace=yes |\n| Should Be Equal | ${text}          | Text with bold and italics. |\n\nSee also `Get Elements Texts`, `Element Text Should Be` and\n`Element Text Should Match`.",
      "shortdoc": "Returns all text of the element, possibly whitespace normalized.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/XML.py",
      "lineno": 646
    },
    {
      "name": "Get Elements",
      "args": [
        {
          "name": "source",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "source"
        },
        {
          "name": "xpath",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "xpath"
        }
      ],
      "returnType": null,
      "doc": "Returns a list of elements in the ``source`` matching the ``xpath``.\n\nThe ``source`` can be a path to an XML file, a string containing XML, or\nan already parsed XML element. The ``xpath`` specifies which element to\nfind. See the `introduction` for more details.\n\nElements matching the ``xpath`` are returned as a list. If no elements\nmatch, an empty list is returned. Use `Get Element` if you want to get\nexactly one match.\n\nExamples using ``${XML}`` structure from `Example`:\n| ${children} =    | Get Elements | ${XML} | third/child |\n| Length Should Be | ${children}  | 2      |             |\n| ${children} =    | Get Elements | ${XML} | first/child |\n| Should Be Empty  |  ${children} |        |             |",
      "shortdoc": "Returns a list of elements in the ``source`` matching the ``xpath``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/XML.py",
      "lineno": 564
    },
    {
      "name": "Get Elements Texts",
      "args": [
        {
          "name": "source",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "source"
        },
        {
          "name": "xpath",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "xpath"
        },
        {
          "name": "normalize_whitespace",
          "type": null,
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "normalize_whitespace=False"
        }
      ],
      "returnType": null,
      "doc": "Returns text of all elements matching ``xpath`` as a list.\n\nThe elements whose text to return is specified using ``source`` and\n``xpath``. They have exactly the same semantics as with `Get Elements`\nkeyword.\n\nThe text of the matched elements is returned using the same logic\nas with `Get Element Text`. This includes optional whitespace\nnormalization using the ``normalize_whitespace`` option.\n\nExamples using ``${XML}`` structure from `Example`:\n| @{texts} =       | Get Elements Texts | ${XML}    | third/child |\n| Length Should Be | ${texts}           | 2         |             |\n| Should Be Equal  | @{texts}[0]        | more text |             |\n| Should Be Equal  | @{texts}[1]        | ${EMPTY}  |             |",
      "shortdoc": "Returns text of all elements matching ``xpath`` as a list.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/XML.py",
      "lineno": 695
    },
    {
      "name": "Log Element",
      "args": [
        {
          "name": "source",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "source"
        },
        {
          "name": "level",
          "type": null,
          "defaultValue": "INFO",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "level=INFO"
        },
        {
          "name": "xpath",
          "type": null,
          "defaultValue": ".",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "xpath=."
        }
      ],
      "returnType": null,
      "doc": "Logs the string representation of the specified element.\n\nThe element specified with ``source`` and ``xpath`` is first converted\ninto a string using `Element To String` keyword internally. The\nresulting string is then logged using the given ``level``.\n\nThe logged string is also returned.",
      "shortdoc": "Logs the string representation of the specified element.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/XML.py",
      "lineno": 1320
    },
    {
      "name": "Parse Xml",
      "args": [
        {
          "name": "source",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "source"
        },
        {
          "name": "keep_clark_notation",
          "type": null,
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "keep_clark_notation=False"
        },
        {
          "name": "strip_namespaces",
          "type": null,
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "strip_namespaces=False"
        }
      ],
      "returnType": null,
      "doc": "Parses the given XML file or string into an element structure.\n\nThe ``source`` can either be a path to an XML file or a string\ncontaining XML. In both cases the XML is parsed into ElementTree\n[http://docs.python.org/library/xml.etree.elementtree.html#element-objects|element structure]\nand the root element is returned. Possible comments and processing\ninstructions in the source XML are removed.\n\nAs discussed in `Handling XML namespaces` section, this keyword, by\ndefault, removes namespace information ElementTree has added to tag\nnames and moves it into ``xmlns`` attributes. This typically eases\nhandling XML documents with namespaces considerably. If you do not\nwant that to happen, or want to avoid the small overhead of going\nthrough the element structure when your XML does not have namespaces,\nyou can disable this feature by giving ``keep_clark_notation`` argument\na true value (see `Boolean arguments`).\n\nIf you want to strip namespace information altogether so that it is\nnot included even if XML is saved, you can give a true value to\n``strip_namespaces`` argument.\n\nExamples:\n| ${root} = | Parse XML | <root><child/></root> |\n| ${xml} = | Parse XML | ${CURDIR}/test.xml | keep_clark_notation=True |\n| ${xml} = | Parse XML | ${CURDIR}/test.xml | strip_namespaces=True |\n\nUse `Get Element` keyword if you want to get a certain element and not\nthe whole structure. See `Parsing XML` section for more details and\nexamples.",
      "shortdoc": "Parses the given XML file or string into an element structure.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/XML.py",
      "lineno": 478
    },
    {
      "name": "Remove Element",
      "args": [
        {
          "name": "source",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "source"
        },
        {
          "name": "xpath",
          "type": null,
          "defaultValue": "",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "xpath="
        },
        {
          "name": "remove_tail",
          "type": null,
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "remove_tail=False"
        }
      ],
      "returnType": null,
      "doc": "Removes the element matching ``xpath`` from the ``source`` structure.\n\nThe element to remove from the ``source`` is specified with ``xpath``\nusing the same semantics as with `Get Element` keyword. The resulting\nXML structure is returned, and if the ``source`` is an already parsed\nXML structure, it is also modified in place.\n\nThe keyword fails if ``xpath`` does not match exactly one element.\nUse `Remove Elements` to remove all matched elements.\n\nElement's tail text is not removed by default, but that can be changed\nby giving ``remove_tail`` a true value (see `Boolean arguments`). See\n`Element attributes` section for more information about `tail` in\ngeneral.\n\nExamples using ``${XML}`` structure from `Example`:\n| Remove Element           | ${XML} | xpath=second |\n| Element Should Not Exist | ${XML} | xpath=second |\n| Remove Element           | ${XML} | xpath=html/p/b | remove_tail=yes |\n| Element Text Should Be   | ${XML} | Text with italics. | xpath=html/p | normalize_whitespace=yes |",
      "shortdoc": "Removes the element matching ``xpath`` from the ``source`` structure.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/XML.py",
      "lineno": 1171
    },
    {
      "name": "Remove Element Attribute",
      "args": [
        {
          "name": "source",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "source"
        },
        {
          "name": "name",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "name"
        },
        {
          "name": "xpath",
          "type": null,
          "defaultValue": ".",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "xpath=."
        }
      ],
      "returnType": null,
      "doc": "Removes attribute ``name`` from the specified element.\n\nThe element whose attribute to remove is specified using ``source`` and\n``xpath``. They have exactly the same semantics as with `Get Element`\nkeyword. The resulting XML structure is returned, and if the ``source``\nis an already parsed XML structure, it is also modified in place.\n\nIt is not a failure to remove a non-existing attribute. Use `Remove\nElement Attributes` to remove all attributes and `Set Element Attribute`\nto set them.\n\nExamples using ``${XML}`` structure from `Example`:\n| Remove Element Attribute          | ${XML} | id | xpath=first |\n| Element Should Not Have Attribute | ${XML} | id | xpath=first |\n\nCan only remove an attribute from a single element. Use `Remove Elements\nAttribute` to remove an attribute of multiple elements in one call.",
      "shortdoc": "Removes attribute ``name`` from the specified element.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/XML.py",
      "lineno": 1066
    },
    {
      "name": "Remove Element Attributes",
      "args": [
        {
          "name": "source",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "source"
        },
        {
          "name": "xpath",
          "type": null,
          "defaultValue": ".",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "xpath=."
        }
      ],
      "returnType": null,
      "doc": "Removes all attributes from the specified element.\n\nThe element whose attributes to remove is specified using ``source`` and\n``xpath``. They have exactly the same semantics as with `Get Element`\nkeyword. The resulting XML structure is returned, and if the ``source``\nis an already parsed XML structure, it is also modified in place.\n\nUse `Remove Element Attribute` to remove a single attribute and\n`Set Element Attribute` to set them.\n\nExamples using ``${XML}`` structure from `Example`:\n| Remove Element Attributes         | ${XML} | xpath=first |\n| Element Should Not Have Attribute | ${XML} | id | xpath=first |\n\nCan only remove attributes from a single element. Use `Remove Elements\nAttributes` to remove all attributes of multiple elements in one call.",
      "shortdoc": "Removes all attributes from the specified element.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/XML.py",
      "lineno": 1102
    },
    {
      "name": "Remove Elements",
      "args": [
        {
          "name": "source",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "source"
        },
        {
          "name": "xpath",
          "type": null,
          "defaultValue": "",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "xpath="
        },
        {
          "name": "remove_tail",
          "type": null,
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "remove_tail=False"
        }
      ],
      "returnType": null,
      "doc": "Removes all elements matching ``xpath`` from the ``source`` structure.\n\nThe elements to remove from the ``source`` are specified with ``xpath``\nusing the same semantics as with `Get Elements` keyword. The resulting\nXML structure is returned, and if the ``source`` is an already parsed\nXML structure, it is also modified in place.\n\nIt is not a failure if ``xpath`` matches no elements. Use `Remove\nElement` to remove exactly one element.\n\nElement's tail text is not removed by default, but that can be changed\nby using ``remove_tail`` argument similarly as with `Remove Element`.\n\nExamples using ``${XML}`` structure from `Example`:\n| Remove Elements          | ${XML} | xpath=*/child      |\n| Element Should Not Exist | ${XML} | xpath=second/child |\n| Element Should Not Exist | ${XML} | xpath=third/child  |",
      "shortdoc": "Removes all elements matching ``xpath`` from the ``source`` structure.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/XML.py",
      "lineno": 1197
    },
    {
      "name": "Remove Elements Attribute",
      "args": [
        {
          "name": "source",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "source"
        },
        {
          "name": "name",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "name"
        },
        {
          "name": "xpath",
          "type": null,
          "defaultValue": ".",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "xpath=."
        }
      ],
      "returnType": null,
      "doc": "Removes attribute ``name`` from the specified elements.\n\nLike `Remove Element Attribute` but removes the attribute of all\nelements matching the given ``xpath``.",
      "shortdoc": "Removes attribute ``name`` from the specified elements.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/XML.py",
      "lineno": 1091
    },
    {
      "name": "Remove Elements Attributes",
      "args": [
        {
          "name": "source",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "source"
        },
        {
          "name": "xpath",
          "type": null,
          "defaultValue": ".",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "xpath=."
        }
      ],
      "returnType": null,
      "doc": "Removes all attributes from the specified elements.\n\nLike `Remove Element Attributes` but removes all attributes of all\nelements matching the given ``xpath``.",
      "shortdoc": "Removes all attributes from the specified elements.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/XML.py",
      "lineno": 1124
    },
    {
      "name": "Save Xml",
      "args": [
        {
          "name": "source",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "source"
        },
        {
          "name": "path",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "path"
        },
        {
          "name": "encoding",
          "type": null,
          "defaultValue": "UTF-8",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "encoding=UTF-8"
        }
      ],
      "returnType": null,
      "doc": "Saves the given element to the specified file.\n\nThe element to save is specified with ``source`` using the same\nsemantics as with `Get Element` keyword.\n\nThe file where the element is saved is denoted with ``path`` and the\nencoding to use with ``encoding``. The resulting file always contains\nthe XML declaration.\n\nThe resulting XML file may not be exactly the same as the original:\n- Comments and processing instructions are always stripped.\n- Possible doctype and namespace prefixes are only preserved when\n  `using lxml`.\n- Other small differences are possible depending on the ElementTree\n  or lxml version.\n\nUse `Element To String` if you just need a string representation of\nthe element.",
      "shortdoc": "Saves the given element to the specified file.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/XML.py",
      "lineno": 1333
    },
    {
      "name": "Set Element Attribute",
      "args": [
        {
          "name": "source",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "source"
        },
        {
          "name": "name",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "name"
        },
        {
          "name": "value",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "value"
        },
        {
          "name": "xpath",
          "type": null,
          "defaultValue": ".",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "xpath=."
        }
      ],
      "returnType": null,
      "doc": "Sets attribute ``name`` of the specified element to ``value``.\n\nThe element whose attribute to set is specified using ``source`` and\n``xpath``. They have exactly the same semantics as with `Get Element`\nkeyword. The resulting XML structure is returned, and if the ``source``\nis an already parsed XML structure, it is also modified in place.\n\nIt is possible to both set new attributes and to overwrite existing.\nUse `Remove Element Attribute` or `Remove Element Attributes` for\nremoving them.\n\nExamples using ``${XML}`` structure from `Example`:\n| Set Element Attribute       | ${XML} | attr | value |\n| Element Attribute Should Be | ${XML} | attr | value |\n| Set Element Attribute       | ${XML} | id   | new   | xpath=first |\n| Element Attribute Should Be | ${XML} | id   | new   | xpath=first |\n\nCan only set an attribute of a single element. Use `Set Elements\nAttribute` to set an attribute of multiple elements in one call.",
      "shortdoc": "Sets attribute ``name`` of the specified element to ``value``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/XML.py",
      "lineno": 1028
    },
    {
      "name": "Set Element Tag",
      "args": [
        {
          "name": "source",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "source"
        },
        {
          "name": "tag",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "tag"
        },
        {
          "name": "xpath",
          "type": null,
          "defaultValue": ".",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "xpath=."
        }
      ],
      "returnType": null,
      "doc": "Sets the tag of the specified element.\n\nThe element whose tag to set is specified using ``source`` and\n``xpath``. They have exactly the same semantics as with `Get Element`\nkeyword. The resulting XML structure is returned, and if the ``source``\nis an already parsed XML structure, it is also modified in place.\n\nExamples using ``${XML}`` structure from `Example`:\n| Set Element Tag      | ${XML}     | newTag     |\n| Should Be Equal      | ${XML.tag} | newTag     |\n| Set Element Tag      | ${XML}     | xxx        | xpath=second/child |\n| Element Should Exist | ${XML}     | second/xxx |\n| Element Should Not Exist | ${XML} | second/child |\n\nCan only set the tag of a single element. Use `Set Elements Tag` to set\nthe tag of multiple elements in one call.",
      "shortdoc": "Sets the tag of the specified element.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/XML.py",
      "lineno": 951
    },
    {
      "name": "Set Element Text",
      "args": [
        {
          "name": "source",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "source"
        },
        {
          "name": "text",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "text=None"
        },
        {
          "name": "tail",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "tail=None"
        },
        {
          "name": "xpath",
          "type": null,
          "defaultValue": ".",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "xpath=."
        }
      ],
      "returnType": null,
      "doc": "Sets text and/or tail text of the specified element.\n\nThe element whose text to set is specified using ``source`` and\n``xpath``. They have exactly the same semantics as with `Get Element`\nkeyword. The resulting XML structure is returned, and if the ``source``\nis an already parsed XML structure, it is also modified in place.\n\nElement's text and tail text are changed only if new ``text`` and/or\n``tail`` values are given. See `Element attributes` section for more\ninformation about `text` and `tail` in general.\n\nExamples using ``${XML}`` structure from `Example`:\n| Set Element Text       | ${XML} | new text | xpath=first    |\n| Element Text Should Be | ${XML} | new text | xpath=first    |\n| Set Element Text       | ${XML} | tail=&   | xpath=html/p/b |\n| Element Text Should Be | ${XML} | Text with bold&italics. | xpath=html/p  | normalize_whitespace=yes |\n| Set Element Text       | ${XML} | slanted  | !! | xpath=html/p/i |\n| Element Text Should Be | ${XML} | Text with bold&slanted!! | xpath=html/p  | normalize_whitespace=yes |\n\nCan only set the text/tail of a single element. Use `Set Elements Text`\nto set the text/tail of multiple elements in one call.",
      "shortdoc": "Sets text and/or tail text of the specified element.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/XML.py",
      "lineno": 985
    },
    {
      "name": "Set Elements Attribute",
      "args": [
        {
          "name": "source",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "source"
        },
        {
          "name": "name",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "name"
        },
        {
          "name": "value",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "value"
        },
        {
          "name": "xpath",
          "type": null,
          "defaultValue": ".",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "xpath=."
        }
      ],
      "returnType": null,
      "doc": "Sets attribute ``name`` of the specified elements to ``value``.\n\nLike `Set Element Attribute` but sets the attribute of all elements\nmatching the given ``xpath``.",
      "shortdoc": "Sets attribute ``name`` of the specified elements to ``value``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/XML.py",
      "lineno": 1055
    },
    {
      "name": "Set Elements Tag",
      "args": [
        {
          "name": "source",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "source"
        },
        {
          "name": "tag",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "tag"
        },
        {
          "name": "xpath",
          "type": null,
          "defaultValue": ".",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "xpath=."
        }
      ],
      "returnType": null,
      "doc": "Sets the tag of the specified elements.\n\nLike `Set Element Tag` but sets the tag of all elements matching\nthe given ``xpath``.",
      "shortdoc": "Sets the tag of the specified elements.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/XML.py",
      "lineno": 973
    },
    {
      "name": "Set Elements Text",
      "args": [
        {
          "name": "source",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "source"
        },
        {
          "name": "text",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "text=None"
        },
        {
          "name": "tail",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "tail=None"
        },
        {
          "name": "xpath",
          "type": null,
          "defaultValue": ".",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "xpath=."
        }
      ],
      "returnType": null,
      "doc": "Sets text and/or tail text of the specified elements.\n\nLike `Set Element Text` but sets the text or tail of all elements\nmatching the given ``xpath``.",
      "shortdoc": "Sets text and/or tail text of the specified elements.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/XML.py",
      "lineno": 1017
    }
  ],
  "typedocs": []
}