Using lxml

 By default this library uses Python's standard ElementTree module for parsing XML, but it can be configured to use lxml module instead when importing the library. The resulting element structure has same API regardless which module is used for parsing.

 The main benefits of using lxml is that it supports richer xpath syntax than the standard ElementTree and enables using Evaluate Xpath keyword. It also preserves the doctype and possible namespace prefixes saving XML.

 The lxml support is new in Robot Framework 2.8.5.

 import copy

 import re

 import os

 try:

     from lxml import etree as lxml_etree

 except ImportError:

     lxml_etree = None

 from robot.api import logger

 from robot.libraries.BuiltIn import BuiltIn

 from robot.utils import (asserts, ET, ETSource, is_string, is_truthy,

                          plural_or_not as s)

 from robot.version import get_version

 should_be_equal = asserts.assert_equal

 should_match = BuiltIn().should_match

 class XML(object):

  ROBOT_LIBRARY_SCOPE = 'GLOBAL'

     ROBOT_LIBRARY_VERSION = get_version()

     _xml_declaration = re.compile('^<\?xml .*\?>')

   def __init__(self, use_lxml=False):

   　　use_lxml = is_truthy(use_lxml)

         if use_lxml and lxml_etree:

             self.etree = lxml_etree

             self.modern_etree = True

             self.lxml_etree = True

         else:

             self.etree = ET

             self.modern_etree = ET.VERSION >= '1.3'

             self.lxml_etree = False

         if use_lxml and not lxml_etree:

             logger.warn('XML library reverted to use standard ElementTree '

                         'because lxml module is not installed.')

   def parse_xml(self, source, keep_clark_notation=False):

  　　with ETSource(source) as source:

             tree = self.etree.parse(source)

         if self.lxml_etree:

             strip = (lxml_etree.Comment, lxml_etree.ProcessingInstruction)

             lxml_etree.strip_elements(tree, *strip, **dict(with_tail=False))

         root = tree.getroot()

         if not is_truthy(keep_clark_notation):

             NameSpaceStripper().strip(root)

         return root

　　python提供了几个标准库都可以对xml进行解析，之前我使用的是DOM，基于RF使用的是ETree，便开始学习了下ETree的开发文档。学习对XML文件的操作,那肯定也得对XML本身有最基本的了解，比如XML的用途，树结构，节点类型（DOM），带命名空间的xml。下面是部分的知识点的总结：

xml是一种可扩展的标记语言。要求标记需要成对的出现（有时候会进行简写<b/>）。一个典型的xml文档如下所示：

 <example>

   <first id="">text</first>

   <second id="">

     <child/>

   </second>

   <third>

     <child>more text</child>

     <second id="child"/>

     <child><grandchild/></child>

   </third>

 </example>

 XML

 Library version:    3.0.2

 Library scope:    global

 Named arguments:    supported

 Introduction

 Robot Framework test library for verifying and modifying XML documents.

 As the name implies, XML is a test library for verifying contents of XML files. In practice it is a pretty thin wrapper on top of Python's ElementTree XML API.

 The library has the following main usages:

 Parsing an XML file, or a string containing XML, into an XML element structure and finding certain elements from it for for further analysis (e.g. Parse XML and Get Element keywords).

 Getting text or attributes of elements (e.g. Get Element Text and Get Element Attribute).

 Directly verifying text, attributes, or whole elements (e.g Element Text Should Be and Elements Should Be Equal).

 Modifying XML and saving it (e.g. Set Element Text, Add Element and Save XML).

 Table of contents

 Parsing XML

 Using lxml

 Example

 Finding elements with xpath

 Element attributes

 Handling XML namespaces

 Boolean arguments

 Shortcuts

 Keywords

 Parsing XML

 XML can be parsed into an element structure using Parse XML keyword. It accepts both paths to XML files and strings that contain XML. The keyword returns the root element of the structure, which then contains other elements as its children and their children. Possible comments and processing instructions in the source XML are removed.

 XML is not validated during parsing even if has a schema defined. How possible doctype elements are handled otherwise depends on the used XML module and on the platform. The standard ElementTree strips doctypes altogether but when using lxml they are preserved when XML is saved. With IronPython parsing XML with a doctype is not supported at all.

 The element structure returned by Parse XML, as well as elements returned by keywords such as Get Element, can be used as the source argument with other keywords. In addition to an already parsed XML structure, other keywords also accept paths to XML files and strings containing XML similarly as Parse XML. Notice that keywords that modify XML do not write those changes back to disk even if the source would be given as a path to a file. Changes must always saved explicitly using Save XML keyword.

 When the source is given as a path to a file, the forward slash character (/) can be used as the path separator regardless the operating system. On Windows also the backslash works, but it the test data it needs to be escaped by doubling it (\\). Using the built-in variable ${/} naturally works too.

 解析XML

 可以使用Parse XML关键字将XML解析为元素结构。它接受XML文件和包含XML的字符串的路径。关键字返回结构的根元素，然后包含其他元素作为其子元素和子元素。源XML中的可能注释和处理指令将被删除。

 即使定义了模式，XML在分析过程中也不会被验证。如何处理doctype元素，否则取决于使用的XML模块和平台。标准ElementTree完全去除doctypes，但是当使用lxml时，保存XML时会保留它们。 IronPython用doctype解析XML根本不被支持。

 由Parse XML返回的元素结构以及由Get Element等关键字返回的元素可用作其他关键字的源参数。除已经解析的XML结构之外，其他关键字也接受XML文件的路径和包含XML的字符串，类似于解析XML。请注意，修改XML的关键字不会将这些更改写回到磁盘，即使源将作为文件的路径提供。必须始终使用保存XML关键字保存更改。

 当源被指定为文件的路径时，无论操作系统如何，正斜杠字符（/）都可以用作路径分隔符。在Windows上，反斜杠也可以工作，但是它需要通过加倍（\\）来转义测试数据。使用内置变量$ {/}自然也可以。

 Example

 The following simple example demonstrates parsing XML and verifying its contents both using keywords in this library and in BuiltIn and Collections libraries. How to use xpath expressions to find elements and what attributes the returned elements contain are discussed, with more examples, in Finding elements with xpath and Element attributes sections.

 In this example, as well as in many other examples in this documentation, ${XML} refers to the following example XML document. In practice ${XML} could either be a path to an XML file or it could contain the XML itself.

 <example>

   <first id="">text</first>

   <second id="">

     <child/>

   </second>

   <third>

     <child>more text</child>

     <second id="child"/>

     <child><grandchild/></child>

   </third>

   <html>

     <p>

       Text with <b>bold</b> and <i>italics</i>.

     </p>

   </html>

 </example>

 ${root} =    Parse XML    ${XML}

 Should Be Equal    ${root.tag}    example

 ${first} =    Get Element    ${root}    first

 Should Be Equal    ${first.text}    text

 Dictionary Should Contain Key    ${first.attrib}    id

 Element Text Should Be    ${first}    text

 Element Attribute Should Be    ${first}    id    1

 Element Attribute Should Be    ${root}    id    1    xpath=first

 Element Attribute Should Be    ${XML}    id    1    xpath=first

 Notice that in the example three last lines are equivalent. Which one to use in practice depends on which other elements you need to get or verify. If you only need to do one verification, using the last line alone would suffice. If more verifications are needed, parsing the XML with Parse XML only once would be more efficient.

 Finding elements with xpath

 ElementTree, and thus also this library, supports finding elements using xpath expressions. ElementTree does not, however, support the full xpath syntax, and what is supported depends on its version. ElementTree 1.3 that is distributed with Python 2.7 supports richer syntax than earlier versions.

 The supported xpath syntax is explained below and ElementTree documentation provides more details. In the examples ${XML} refers to the same XML structure as in the earlier example.

 If lxml support is enabled when importing the library, the whole xpath 1.0 standard is supported. That includes everything listed below but also lot of other useful constructs.

 Tag names

 When just a single tag name is used, xpath matches all direct child elements that have that tag name.

 ${elem} =    Get Element    ${XML}    third

 Should Be Equal    ${elem.tag}    third

 @{children} =    Get Elements    ${elem}    child

 Length Should Be    ${children}    2

 Paths

 Paths are created by combining tag names with a forward slash (/). For example, parent/child matches all child elements under parent element. Notice that if there are multiple parent elements that all have child elements, parent/child xpath will match all these child elements.

 ${elem} =    Get Element    ${XML}    second/child

 Should Be Equal    ${elem.tag}    child

 ${elem} =    Get Element    ${XML}    third/child/grandchild

 Should Be Equal    ${elem.tag}    grandchild

 Wildcards

 An asterisk (*) can be used in paths instead of a tag name to denote any element.

 @{children} =    Get Elements    ${XML}    */child

 Length Should Be    ${children}    3

 Current element

 The current element is denoted with a dot (.). Normally the current element is implicit and does not need to be included in the xpath.

 Parent element

 The parent element of another element is denoted with two dots (..). Notice that it is not possible to refer to the parent of the current element. This syntax is supported only in ElementTree 1.3 (i.e. Python/Jython 2.7 and newer).

 ${elem} =    Get Element    ${XML}    */second/..

 Should Be Equal    ${elem.tag}    third

 Search all sub elements

 Two forward slashes (//) mean that all sub elements, not only the direct children, are searched. If the search is started from the current element, an explicit dot is required.

 @{elements} =    Get Elements    ${XML}    .//second

 Length Should Be    ${elements}    2

 ${b} =    Get Element    ${XML}    html//b

 Should Be Equal    ${b.text}    bold

 Predicates

 Predicates allow selecting elements using also other criteria than tag names, for example, attributes or position. They are specified after the normal tag name or path using syntax path[predicate]. The path can have wildcards and other special syntax explained above.

 What predicates ElementTree supports is explained in the table below. Notice that predicates in general are supported only in ElementTree 1.3 (i.e. Python/Jython 2.7 and newer).

 Predicate    Matches    Example

 @attrib    Elements with attribute attrib.    second[@id]

 @attrib="value"    Elements with attribute attrib having value value.    *[@id=""]

 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]

 tag    Elements with a child element named tag.    third/child[grandchild]

 Predicates can also be stacked like path[predicate1][predicate2]. A limitation is that possible position predicate must always be first.