Split body reading from document reading

4 files changed, 859 insertions, 801 deletions

diff --git a/mammoth/docx/body_xml.py b/mammoth/docx/body_xml.py
new file mode 100644
index 0000000..cb42f05
--- /dev/null
+++ b/mammoth/docx/body_xml.py
@@ -0,0 +1,356 @@
+import contextlib
+
+from .. import documents
+from .. import results
+from .. import lists
+from .xmlparser import node_types
+
+
+def reader(numbering=None,
+        content_types=None,
+        relationships=None,
+        styles=None,
+        docx_file=None):
+    
+    read, read_all = _create_reader(
+        numbering=numbering,
+        content_types=content_types,
+        relationships=relationships,
+        styles=styles,
+        docx_file=docx_file,
+    )
+    return _BodyReader(read, read_all)
+
+
+
+class _BodyReader(object):
+    def __init__(self, read, read_all):
+        self._read = read
+        self._read_all = read_all
+    
+    def read(self, element):
+        result = self._read(element)
+        return results.Result(result.value, result.messages)
+    
+    def read_all(self, elements):
+        result = self._read_all(elements)
+        return results.Result(result.value, result.messages)
+
+
+def _create_reader(numbering, content_types, relationships, styles, docx_file):
+    _handlers = {}
+    _ignored_elements = set([
+        "w:bookmarkStart",
+        "w:bookmarkEnd",
+        "w:sectPr",
+        "w:proofErr",
+        "w:lastRenderedPageBreak",
+        "w:commentRangeStart",
+        "w:commentRangeEnd",
+        "w:commentReference",
+        "w:del",
+        "w:footnoteRef",
+        "w:endnoteRef",
+        "w:pPr",
+        "w:rPr",
+        "w:tblPr",
+        "w:tblGrid",
+        "w:tcPr",
+    ])
+
+    def handler(name):
+        def add(func):
+            _handlers[name] = func
+            return func
+            
+        return add
+
+    @handler("w:t")
+    def text(element):
+        return _success(documents.Text(_inner_text(element)))
+
+
+    @handler("w:r")
+    def run(element):
+        properties = element.find_child_or_null("w:rPr")
+        style_id = properties \
+            .find_child_or_null("w:rStyle") \
+            .attributes.get("w:val")
+        
+        if style_id is None:
+            style_name = None
+        else:
+            style_name = styles.find_character_style_by_id(style_id).name
+        
+        vertical_alignment = properties \
+            .find_child_or_null("w:vertAlign") \
+            .attributes.get("w:val")
+        
+        is_bold = properties.find_child("w:b")
+        is_italic = properties.find_child("w:i")
+        is_underline = properties.find_child("w:u")
+        is_strikethrough = properties.find_child("w:strike")
+        
+        return _read_xml_elements(element.children) \
+            .map(lambda children: documents.run(
+                children=children,
+                style_id=style_id,
+                style_name=style_name,
+                is_bold=is_bold,
+                is_italic=is_italic,
+                is_underline=is_underline,
+                is_strikethrough=is_strikethrough,
+                vertical_alignment=vertical_alignment,
+            ))
+
+
+    @handler("w:p")
+    def paragraph(element):
+        properties = element.find_child_or_null("w:pPr")
+        style_id = properties \
+            .find_child_or_null("w:pStyle") \
+            .attributes.get("w:val")
+        
+        if style_id is None:
+            style_name = None
+        else:
+            style_name = styles.find_paragraph_style_by_id(style_id).name
+        
+        numbering_properties = properties.find_child("w:numPr")
+        if numbering_properties is None:
+            numbering = None
+        else:
+            numbering = _read_numbering_properties(numbering_properties)
+        
+        return _read_xml_elements(element.children) \
+            .map(lambda children: documents.paragraph(
+                children=children,
+                style_id=style_id,
+                style_name=style_name,
+                numbering=numbering,
+            )) \
+            .append_extra()
+
+    def _read_numbering_properties(element):
+        num_id = element.find_child("w:numId").attributes["w:val"]
+        level_index = element.find_child("w:ilvl").attributes["w:val"]
+        return numbering.find_level(num_id, level_index)
+
+
+    @handler("w:tab")
+    def tab(element):
+        return _success(documents.tab())
+    
+    
+    @handler("w:tbl")
+    def table(element):
+        return _read_xml_elements(element.children) \
+            .map(documents.table)
+    
+    
+    @handler("w:tr")
+    def table_row(element):
+        return _read_xml_elements(element.children) \
+            .map(documents.table_row)
+    
+    
+    @handler("w:tc")
+    def table_cell(element):
+        return _read_xml_elements(element.children) \
+            .map(documents.table_cell)
+    
+    
+    @handler("w:ins")
+    @handler("w:smartTag")
+    @handler("w:drawing")
+    @handler("v:shape")
+    @handler("v:textbox")
+    @handler("w:txbxContent")
+    def read_child_elements(element):
+        return _read_xml_elements(element.children)
+    
+    
+    @handler("w:pict")
+    def pict(element):
+        return read_child_elements(element).to_extra()
+    
+    
+    @handler("w:hyperlink")
+    def hyperlink(element):
+        relationship_id = element.attributes.get("r:id")
+        anchor = element.attributes.get("w:anchor")
+        children_result = _read_xml_elements(element.children)
+        if relationship_id is not None:
+            href = relationships[relationship_id].target
+            return children_result.map(lambda children: documents.hyperlink(href=href, children=children))
+        elif anchor is not None:
+            return children_result.map(lambda children: documents.hyperlink(anchor=anchor, children=children))
+        else:
+            return children_result
+    
+    @handler("w:bookmarkStart")
+    def bookmark_start(element):
+        name = element.attributes.get("w:name")
+        if name == "_GoBack":
+            return _empty_result
+        else:
+            return _success(documents.bookmark(name))
+    
+    
+    @handler("w:br")
+    def br(element):
+        break_type = element.attributes.get("w:type")
+        if break_type:
+            warning = results.warning("Unsupported break type: {0}".format(break_type))
+            return _empty_result_with_messages([warning])
+        else:
+            return _success(documents.line_break())
+    
+    @handler("wp:inline")
+    @handler("wp:anchor")
+    def inline(element):
+        alt_text = element.find_child_or_null("wp:docPr").attributes.get("descr")
+        blips = element.find_children("a:graphic") \
+            .find_children("a:graphicData") \
+            .find_children("pic:pic") \
+            .find_children("pic:blipFill") \
+            .find_children("a:blip")
+        return _read_blips(blips, alt_text)
+    
+    def _read_blips(blips, alt_text):
+        return _combine_results(map(lambda blip: _read_blip(blip, alt_text), blips))
+    
+    def _read_blip(element, alt_text):
+        relationship_id = element.attributes["r:embed"]
+        image_path = "word/" + relationships[relationship_id].target.lstrip("/")
+        content_type = content_types.find_content_type(image_path)
+        
+        def open_image():
+            image_file = docx_file.open(image_path)
+            if hasattr(image_file, "__exit__"):
+                return image_file
+            else:
+                return contextlib.closing(image_file)
+        
+        image = documents.image(alt_text=alt_text, content_type=content_type, open=open_image)
+        
+        if content_type in ["image/png", "image/gif", "image/jpeg", "image/svg+xml", "image/tiff"]:
+            messages = []
+        else:
+            messages = [results.warning("Image of type {0} is unlikely to display in web browsers".format(content_type))]
+            
+        return _element_result_with_messages(image, messages)
+    
+    def note_reference_reader(note_type):
+        @handler("w:{0}Reference".format(note_type))
+        def note_reference(element):
+            return _success(documents.note_reference(note_type, element.attributes["w:id"]))
+        
+        return note_reference
+    
+    note_reference_reader("footnote")
+    note_reference_reader("endnote")
+    
+    @handler("mc:AlternateContent")
+    def alternate_content(element):
+        return read_child_elements(element.find_child("mc:Fallback"))
+    
+    def read(element):
+        handler = _handlers.get(element.name)
+        if handler is None:
+            if element.name not in _ignored_elements:
+                warning = results.warning("An unrecognised element was ignored: {0}".format(element.name))
+                return _empty_result_with_messages([warning])
+            else:
+                return _success(None)
+        else:
+            return handler(element)
+        
+
+    def _read_xml_elements(elements):
+        return _combine_results(map(read, elements)) \
+            .map(lambda values: lists.collect(values))
+    
+    return read, _read_xml_elements
+
+
+def _find(predicate, iterable):
+    for item in iterable:
+        if predicate(item):
+            return item
+
+
+def _find_child(element, name):
+    return _find(lambda child: child.name == name, element.children)
+
+
+def _inner_text(node):
+    if node.node_type == node_types.text:
+        return node.value
+    else:
+        return "".join(_inner_text(child) for child in node.children)
+
+
+
+class _ReadResult(object):
+    def __init__(self, value, extra, messages):
+        if extra is None:
+            extra = []
+        self._result = results.Result((value, extra), messages)
+    
+    @property
+    def value(self):
+        return self._result.value[0]
+    
+    @property
+    def extra(self):
+        return self._result.value[1]
+    
+    @property
+    def messages(self):
+        return self._result.messages
+    
+    def map(self, func):
+        result = self._result.map(lambda value: func(value[0]))
+        return _ReadResult(result.value, self.extra, result.messages)
+    
+    def to_extra(self):
+        return _ReadResult(None, _concat(self.extra, self.value), self.messages)
+    
+    def append_extra(self):
+        return _ReadResult(_concat(self.value, self.extra), None, self.messages)
+
+def _success(element):
+    return _ReadResult(element, None, [])
+
+def _element_result_with_messages(element, messages):
+    return _ReadResult(element, None, messages)
+
+def _combine_results(read_results):
+    combined = results.combine(result._result for result in read_results)
+    if combined.value:
+        value, extras = map(list, zip(*combined.value))
+        extra = sum(extras, [])
+    else:
+        value, extra = [], None
+    return _ReadResult(value, extra, combined.messages)
+
+_empty_result = _success(None)
+
+def _empty_result_with_messages(messages):
+    return _ReadResult(None, None, messages)
+
+def _concat(*values):
+    valid_values = list(filter(None, values))
+    if not valid_values:
+        return None
+    elif len(valid_values) == 1:
+        return valid_values[0]
+    else:
+        return sum(list(map(_to_list, valid_values)), [])
+
+def _to_list(value):
+    if isinstance(value, list):
+        return value
+    else:
+        return [value]
diff --git a/mammoth/docx/document_xml.py b/mammoth/docx/document_xml.py
index 3147ed4..7288dc2 100644
--- a/mammoth/docx/document_xml.py
+++ b/mammoth/docx/document_xml.py
@@ -1,9 +1,6 @@
-import contextlib
-
 from .. import documents
 from .. import results
-from .. import lists
-from .xmlparser import node_types
+from . import body_xml
 
 
 def read_document_xml_element(element,
@@ -17,349 +14,19 @@ def read_document_xml_element(element,
     
     note_elements = (footnote_elements or []) + (endnote_elements or [])
     
-    reader = _create_reader(
+    body_reader = body_xml.reader(
         numbering=numbering,
         content_types=content_types,
         relationships=relationships,
         styles=styles,
-        note_elements=note_elements,
         docx_file=docx_file,
     )
-    result = reader(element)
-    return results.Result(result.value, result.messages)
-
-def _create_reader(numbering, content_types, relationships, styles, note_elements, docx_file):
-    _handlers = {}
-    _ignored_elements = set([
-        "w:bookmarkStart",
-        "w:bookmarkEnd",
-        "w:sectPr",
-        "w:proofErr",
-        "w:lastRenderedPageBreak",
-        "w:commentRangeStart",
-        "w:commentRangeEnd",
-        "w:commentReference",
-        "w:del",
-        "w:footnoteRef",
-        "w:endnoteRef",
-        "w:pPr",
-        "w:rPr",
-        "w:tblPr",
-        "w:tblGrid",
-        "w:tcPr",
-    ])
-
-    def handler(name):
-        def add(func):
-            _handlers[name] = func
-            return func
-            
-        return add
-
-    @handler("w:t")
-    def text(element):
-        return _success(documents.Text(_inner_text(element)))
-
-
-    @handler("w:r")
-    def run(element):
-        properties = element.find_child_or_null("w:rPr")
-        style_id = properties \
-            .find_child_or_null("w:rStyle") \
-            .attributes.get("w:val")
-        
-        if style_id is None:
-            style_name = None
-        else:
-            style_name = styles.find_character_style_by_id(style_id).name
-        
-        vertical_alignment = properties \
-            .find_child_or_null("w:vertAlign") \
-            .attributes.get("w:val")
-        
-        is_bold = properties.find_child("w:b")
-        is_italic = properties.find_child("w:i")
-        is_underline = properties.find_child("w:u")
-        is_strikethrough = properties.find_child("w:strike")
-        
-        return _read_xml_elements(element.children) \
-            .map(lambda children: documents.run(
-                children=children,
-                style_id=style_id,
-                style_name=style_name,
-                is_bold=is_bold,
-                is_italic=is_italic,
-                is_underline=is_underline,
-                is_strikethrough=is_strikethrough,
-                vertical_alignment=vertical_alignment,
-            ))
-
-
-    @handler("w:p")
-    def paragraph(element):
-        properties = element.find_child_or_null("w:pPr")
-        style_id = properties \
-            .find_child_or_null("w:pStyle") \
-            .attributes.get("w:val")
-        
-        if style_id is None:
-            style_name = None
-        else:
-            style_name = styles.find_paragraph_style_by_id(style_id).name
-        
-        numbering_properties = properties.find_child("w:numPr")
-        if numbering_properties is None:
-            numbering = None
-        else:
-            numbering = _read_numbering_properties(numbering_properties)
-        
-        return _read_xml_elements(element.children) \
-            .map(lambda children: documents.paragraph(
-                children=children,
-                style_id=style_id,
-                style_name=style_name,
-                numbering=numbering,
-            )) \
-            .append_extra()
-
-    def _read_numbering_properties(element):
-        num_id = element.find_child("w:numId").attributes["w:val"]
-        level_index = element.find_child("w:ilvl").attributes["w:val"]
-        return numbering.find_level(num_id, level_index)
-
-
-    @handler("w:body")
-    def body(element):
-        return _read_xml_elements(element.children)
-
-
-    @handler("w:document")
-    def document(element):
-        body_element = _find_child(element, "w:body")
-        children_result = _read_xml_elements(body_element.children)
-        notes_result = _combine_results(map(_read_note, note_elements)).map(documents.notes)
-        return results.map(documents.document, children_result, notes_result)
-    
     
     def _read_note(element):
-        return _read_xml_elements(element.body).map(
+        return body_reader.read_all(element.body).map(
             lambda body: documents.note(element.note_type, element.id, body))
-     
-    
-    @handler("w:tab")
-    def tab(element):
-        return _success(documents.tab())
-    
-    
-    @handler("w:tbl")
-    def table(element):
-        return _read_xml_elements(element.children) \
-            .map(documents.table)
-    
-    
-    @handler("w:tr")
-    def table_row(element):
-        return _read_xml_elements(element.children) \
-            .map(documents.table_row)
-    
-    
-    @handler("w:tc")
-    def table_cell(element):
-        return _read_xml_elements(element.children) \
-            .map(documents.table_cell)
-    
-    
-    @handler("w:ins")
-    @handler("w:smartTag")
-    @handler("w:drawing")
-    @handler("v:shape")
-    @handler("v:textbox")
-    @handler("w:txbxContent")
-    def read_child_elements(element):
-        return _read_xml_elements(element.children)
-    
-    
-    @handler("w:pict")
-    def pict(element):
-        return read_child_elements(element).to_extra()
-    
-    
-    @handler("w:hyperlink")
-    def hyperlink(element):
-        relationship_id = element.attributes.get("r:id")
-        anchor = element.attributes.get("w:anchor")
-        children_result = _read_xml_elements(element.children)
-        if relationship_id is not None:
-            href = relationships[relationship_id].target
-            return children_result.map(lambda children: documents.hyperlink(href=href, children=children))
-        elif anchor is not None:
-            return children_result.map(lambda children: documents.hyperlink(anchor=anchor, children=children))
-        else:
-            return children_result
-    
-    @handler("w:bookmarkStart")
-    def bookmark_start(element):
-        name = element.attributes.get("w:name")
-        if name == "_GoBack":
-            return _empty_result
-        else:
-            return _success(documents.bookmark(name))
-    
-    
-    @handler("w:br")
-    def br(element):
-        break_type = element.attributes.get("w:type")
-        if break_type:
-            warning = results.warning("Unsupported break type: {0}".format(break_type))
-            return _empty_result_with_messages([warning])
-        else:
-            return _success(documents.line_break())
-    
-    @handler("wp:inline")
-    @handler("wp:anchor")
-    def inline(element):
-        alt_text = element.find_child_or_null("wp:docPr").attributes.get("descr")
-        blips = element.find_children("a:graphic") \
-            .find_children("a:graphicData") \
-            .find_children("pic:pic") \
-            .find_children("pic:blipFill") \
-            .find_children("a:blip")
-        return _read_blips(blips, alt_text)
-    
-    def _read_blips(blips, alt_text):
-        return _combine_results(map(lambda blip: _read_blip(blip, alt_text), blips))
-    
-    def _read_blip(element, alt_text):
-        relationship_id = element.attributes["r:embed"]
-        image_path = "word/" + relationships[relationship_id].target.lstrip("/")
-        content_type = content_types.find_content_type(image_path)
-        
-        def open_image():
-            image_file = docx_file.open(image_path)
-            if hasattr(image_file, "__exit__"):
-                return image_file
-            else:
-                return contextlib.closing(image_file)
-        
-        image = documents.image(alt_text=alt_text, content_type=content_type, open=open_image)
-        
-        if content_type in ["image/png", "image/gif", "image/jpeg", "image/svg+xml", "image/tiff"]:
-            messages = []
-        else:
-            messages = [results.warning("Image of type {0} is unlikely to display in web browsers".format(content_type))]
-            
-        return _element_result_with_messages(image, messages)
-    
-    def note_reference_reader(note_type):
-        @handler("w:{0}Reference".format(note_type))
-        def note_reference(element):
-            return _success(documents.note_reference(note_type, element.attributes["w:id"]))
-        
-        return note_reference
-    
-    note_reference_reader("footnote")
-    note_reference_reader("endnote")
-    
-    @handler("mc:AlternateContent")
-    def alternate_content(element):
-        return read_child_elements(element.find_child("mc:Fallback"))
-    
-    def read(element):
-        handler = _handlers.get(element.name)
-        if handler is None:
-            if element.name not in _ignored_elements:
-                warning = results.warning("An unrecognised element was ignored: {0}".format(element.name))
-                return _empty_result_with_messages([warning])
-            else:
-                return _success(None)
-        else:
-            return handler(element)
-        
-
-    def _read_xml_elements(elements):
-        return _combine_results(map(read, elements)) \
-            .map(lambda values: lists.collect(values))
-    
-    return read
-
-
-def _find(predicate, iterable):
-    for item in iterable:
-        if predicate(item):
-            return item
-
-
-def _find_child(element, name):
-    return _find(lambda child: child.name == name, element.children)
-
-
-def _inner_text(node):
-    if node.node_type == node_types.text:
-        return node.value
-    else:
-        return "".join(_inner_text(child) for child in node.children)
-
-
-
-class _ReadResult(object):
-    def __init__(self, value, extra, messages):
-        if extra is None:
-            extra = []
-        self._result = results.Result((value, extra), messages)
-    
-    @property
-    def value(self):
-        return self._result.value[0]
-    
-    @property
-    def extra(self):
-        return self._result.value[1]
-    
-    @property
-    def messages(self):
-        return self._result.messages
-    
-    def map(self, func):
-        result = self._result.map(lambda value: func(value[0]))
-        return _ReadResult(result.value, self.extra, result.messages)
-    
-    def to_extra(self):
-        return _ReadResult(None, _concat(self.extra, self.value), self.messages)
-    
-    def append_extra(self):
-        return _ReadResult(_concat(self.value, self.extra), None, self.messages)
-
-def _success(element):
-    return _ReadResult(element, None, [])
-
-def _element_result_with_messages(element, messages):
-    return _ReadResult(element, None, messages)
-
-def _combine_results(read_results):
-    combined = results.combine(result._result for result in read_results)
-    if combined.value:
-        value, extras = map(list, zip(*combined.value))
-        extra = sum(extras, [])
-    else:
-        value, extra = [], None
-    return _ReadResult(value, extra, combined.messages)
-
-_empty_result = _success(None)
-
-def _empty_result_with_messages(messages):
-    return _ReadResult(None, None, messages)
-
-def _concat(*values):
-    valid_values = list(filter(None, values))
-    if not valid_values:
-        return None
-    elif len(valid_values) == 1:
-        return valid_values[0]
-    else:
-        return sum(list(map(_to_list, valid_values)), [])
 
-def _to_list(value):
-    if isinstance(value, list):
-        return value
-    else:
-        return [value]
+    body_element = element.find_child("w:body")
+    children_result = body_reader.read_all(body_element.children)
+    notes_result = results.combine(map(_read_note, note_elements)).map(documents.notes)
+    return results.map(documents.document, children_result, notes_result)
diff --git a/tests/docx/body_xml_tests.py b/tests/docx/body_xml_tests.py
new file mode 100644
index 0000000..1f7e10c
--- /dev/null
+++ b/tests/docx/body_xml_tests.py
@@ -0,0 +1,494 @@
+import io
+
+from nose.tools import istest, assert_equal
+import funk
+
+from mammoth import documents, results
+from mammoth.docx.xmlparser import element as xml_element, text as xml_text
+from mammoth.docx import body_xml
+from mammoth.docx.numbering_xml import Numbering
+from mammoth.docx.relationships_xml import Relationships, Relationship
+from mammoth.docx.styles_xml import Styles, Style
+
+
+@istest
+class ReadXmlElementTests(object):
+    @istest
+    def text_from_text_element_is_read(self):
+        element = _text_element("Hello!")
+        assert_equal(documents.Text("Hello!"), _read_and_get_document_xml_element(element))
+    
+    @istest
+    def can_read_text_within_run(self):
+        element = _run_element_with_text("Hello!")
+        assert_equal(
+            documents.run([documents.Text("Hello!")]),
+            _read_and_get_document_xml_element(element)
+        )
+    
+    @istest
+    def can_read_text_within_paragraph(self):
+        element = _paragraph_element_with_text("Hello!")
+        assert_equal(
+            documents.paragraph([documents.run([documents.Text("Hello!")])]),
+            _read_and_get_document_xml_element(element)
+        )
+        
+    @istest
+    def paragraph_has_no_style_if_it_has_no_properties(self):
+        element = xml_element("w:p")
+        assert_equal(None, _read_and_get_document_xml_element(element).style_id)
+        
+    @istest
+    def paragraph_has_style_id_read_from_paragraph_properties_if_present(self):
+        style_xml = xml_element("w:pStyle", {"w:val": "Heading1"})
+        properties_xml = xml_element("w:pPr", {}, [style_xml])
+        paragraph_xml = xml_element("w:p", {}, [properties_xml])
+        
+        styles = Styles({"Heading1": Style(style_id="Heading1", name="Heading 1")}, {})
+        
+        paragraph = _read_and_get_document_xml_element(paragraph_xml, styles=styles)
+        assert_equal("Heading1", paragraph.style_id)
+        
+    @istest
+    def paragraph_has_style_name_read_from_paragraph_properties_and_styles(self):
+        style_xml = xml_element("w:pStyle", {"w:val": "Heading1"})
+        properties_xml = xml_element("w:pPr", {}, [style_xml])
+        paragraph_xml = xml_element("w:p", {}, [properties_xml])
+        
+        styles = Styles({"Heading1": Style(style_id="Heading1", name="Heading 1")}, {})
+        
+        paragraph = _read_and_get_document_xml_element(paragraph_xml, styles=styles)
+        assert_equal("Heading 1", paragraph.style_name)
+        
+    @istest
+    def paragraph_has_no_numbering_if_it_has_no_numbering_properties(self):
+        element = xml_element("w:p")
+        assert_equal(None, _read_and_get_document_xml_element(element).numbering)
+        
+    @istest
+    def paragraph_has_numbering_properties_from_paragraph_properties_if_present(self):
+        numbering_properties_xml = xml_element("w:numPr", {}, [
+            xml_element("w:ilvl", {"w:val": "1"}),
+            xml_element("w:numId", {"w:val": "42"}),
+        ])
+        properties_xml = xml_element("w:pPr", {}, [numbering_properties_xml])
+        paragraph_xml = xml_element("w:p", {}, [properties_xml])
+        
+        numbering = Numbering({"42": {"1": documents.numbering_level("1", True)}})
+        paragraph = _read_and_get_document_xml_element(paragraph_xml, numbering=numbering)
+        
+        assert_equal("1", paragraph.numbering.level_index)
+        assert_equal(True, paragraph.numbering.is_ordered)
+    
+    @istest
+    def run_has_no_style_if_it_has_no_properties(self):
+        element = xml_element("w:r")
+        assert_equal(None, _read_and_get_document_xml_element(element).style_id)
+        
+    @istest
+    def run_has_style_id_read_from_run_properties_if_present(self):
+        style_xml = xml_element("w:rStyle", {"w:val": "Heading1Char"})
+        
+        styles = Styles({}, {"Heading1Char": Style(style_id="Heading1Char", name="Heading 1 Char")})
+        
+        run = self._read_run_with_properties([style_xml], styles=styles)
+        assert_equal("Heading1Char", run.style_id)
+        
+    @istest
+    def run_has_style_name_read_from_run_properties_and_styles(self):
+        style_xml = xml_element("w:rStyle", {"w:val": "Heading1Char"})
+        
+        styles = Styles({}, {"Heading1Char": Style(style_id="Heading1Char", name="Heading 1 Char")})
+        
+        run = self._read_run_with_properties([style_xml], styles=styles)
+        assert_equal("Heading 1 Char", run.style_name)
+        
+    @istest
+    def run_is_not_bold_if_bold_element_is_not_present(self):
+        run = self._read_run_with_properties([])
+        assert_equal(False, run.is_bold)
+    
+    @istest
+    def run_is_bold_if_bold_element_is_present(self):
+        run = self._read_run_with_properties([xml_element("w:b")])
+        assert_equal(True, run.is_bold)
+        
+    @istest
+    def run_is_not_italic_if_italic_element_is_not_present(self):
+        run = self._read_run_with_properties([])
+        assert_equal(False, run.is_italic)
+    
+    @istest
+    def run_is_italic_if_italic_element_is_present(self):
+        run = self._read_run_with_properties([xml_element("w:i")])
+        assert_equal(True, run.is_italic)
+        
+    @istest
+    def run_is_not_underlined_if_underline_element_is_not_present(self):
+        run = self._read_run_with_properties([])
+        assert_equal(False, run.is_underline)
+    
+    @istest
+    def run_is_underlined_if_underline_element_is_present(self):
+        run = self._read_run_with_properties([xml_element("w:u")])
+        assert_equal(True, run.is_underline)
+        
+    @istest
+    def run_is_not_struckthrough_if_strikethrough_element_is_not_present(self):
+        run = self._read_run_with_properties([])
+        assert_equal(False, run.is_strikethrough)
+    
+    @istest
+    def run_is_struckthrough_if_strikethrough_element_is_present(self):
+        run = self._read_run_with_properties([xml_element("w:strike")])
+        assert_equal(True, run.is_strikethrough)
+    
+    @istest
+    def run_has_baseline_vertical_alignment_if_vertical_alignment_element_is_not_present(self):
+        run = self._read_run_with_properties([])
+        assert_equal(documents.VerticalAlignment.baseline, run.vertical_alignment)
+        
+    @istest
+    def run_has_vertical_alignment_read_from_vertical_alignment_element(self):
+        run = self._read_run_with_properties([xml_element("w:vertAlign", {"w:val": "superscript"})])
+        assert_equal(documents.VerticalAlignment.superscript, run.vertical_alignment)
+    
+    def _read_run_with_properties(self, properties, styles=None):
+        properties_xml = xml_element("w:rPr", {}, properties)
+        run_xml = xml_element("w:r", {}, [properties_xml])
+        return _read_and_get_document_xml_element(run_xml, styles=styles)
+
+
+    @istest
+    def can_read_tab_element(self):
+        element = xml_element("w:tab")
+        tab = _read_and_get_document_xml_element(element)
+        assert_equal(documents.tab(), tab)
+    
+    
+    @istest
+    def word_table_is_read_as_document_table_element(self):
+        element = xml_element("w:tbl", {}, [
+            xml_element("w:tr", {}, [
+                xml_element("w:tc", {}, [
+                    xml_element("w:p", {}, [])
+                ]),
+            ]),
+        ])
+        table = _read_and_get_document_xml_element(element)
+        expected_result = documents.table([
+            documents.table_row([
+                documents.table_cell([
+                    documents.paragraph([])
+                ])
+            ])
+        ])
+        assert_equal(expected_result, table)
+
+
+    @istest
+    def children_of_w_ins_are_converted_normally(self):
+        element = xml_element("w:p", {}, [
+            xml_element("w:ins", {}, [
+                xml_element("w:r")
+            ])
+        ])
+        assert_equal(
+            documents.paragraph([documents.run([])]),
+            _read_and_get_document_xml_element(element)
+        )
+        
+    @istest
+    def children_of_w_smart_tag_are_converted_normally(self):
+        element = xml_element("w:p", {}, [
+            xml_element("w:smartTag", {}, [
+                xml_element("w:r")
+            ])
+        ])
+        assert_equal(
+            documents.paragraph([documents.run([])]),
+            _read_and_get_document_xml_element(element)
+        )
+        
+    @istest
+    def hyperlink_is_read_if_it_has_a_relationship_id(self):
+        relationships = Relationships({
+            "r42": Relationship(target="http://example.com")
+        })
+        run_element = xml_element("w:r")
+        element = xml_element("w:hyperlink", {"r:id": "r42"}, [run_element])
+        assert_equal(
+            documents.hyperlink(href="http://example.com", children=[documents.run([])]),
+            _read_and_get_document_xml_element(element, relationships=relationships)
+        )
+        
+    @istest
+    def hyperlink_is_read_if_it_has_an_anchor_attribute(self):
+        run_element = xml_element("w:r")
+        element = xml_element("w:hyperlink", {"w:anchor": "start"}, [run_element])
+        assert_equal(
+            documents.hyperlink(anchor="start", children=[documents.run([])]),
+            _read_and_get_document_xml_element(element)
+        )
+        
+    @istest
+    def hyperlink_is_ignored_if_it_does_not_have_a_relationship_id_nor_anchor(self):
+        run_element = xml_element("w:r")
+        element = xml_element("w:hyperlink", {}, [run_element])
+        assert_equal(
+            [documents.run([])],
+            _read_and_get_document_xml_element(element)
+        )
+        
+    @istest
+    def go_back_bookmark_is_ignored(self):
+        element = xml_element("w:bookmarkStart", {"w:name": "_GoBack"})
+        assert_equal(None, _read_and_get_document_xml_element(element))
+        
+    @istest
+    def bookmark_start_is_read_if_name_is_not_go_back(self):
+        element = xml_element("w:bookmarkStart", {"w:name": "start"})
+        assert_equal(
+            documents.bookmark("start"),
+            _read_and_get_document_xml_element(element)
+        )
+    
+    @istest
+    def br_is_read_as_line_break(self):
+        break_element = xml_element("w:br", {}, [])
+        result = _read_and_get_document_xml_element(break_element)
+        assert_equal(result, documents.line_break())
+    
+    
+    @istest
+    def warning_on_breaks_that_arent_line_breaks(self):
+        break_element = xml_element("w:br", {"w:type": "page"}, [])
+        result = _read_document_xml_element(break_element)
+        expected_warning = results.warning("Unsupported break type: page")
+        assert_equal([expected_warning], result.messages)
+        assert_equal(None, result.value)
+        
+        
+    @istest
+    @funk.with_context
+    def can_read_inline_pictures(self, context):
+        drawing_element = _create_inline_image(
+            relationship_id="rId5",
+            description="It's a hat",
+        )
+        
+        image_bytes = b"Not an image at all!"
+        
+        relationships = Relationships({
+            "rId5": Relationship(target="media/hat.png")
+        })
+        
+        docx_file = context.mock()
+        funk.allows(docx_file).open("word/media/hat.png").returns(io.BytesIO(image_bytes))
+        
+        content_types = context.mock()
+        funk.allows(content_types).find_content_type("word/media/hat.png").returns("image/png")
+        
+        image = _read_and_get_document_xml_element(
+            drawing_element,
+            content_types=content_types,
+            relationships=relationships,
+            docx_file=docx_file,
+        )[0]
+        assert_equal(documents.Image, type(image))
+        assert_equal("It's a hat", image.alt_text)
+        assert_equal("image/png", image.content_type)
+        with image.open() as image_file:
+            assert_equal(image_bytes, image_file.read())
+        
+    @istest
+    @funk.with_context
+    def can_read_anchored_pictures(self, context):
+        drawing_element = _create_anchored_image(
+            relationship_id="rId5",
+            description="It's a hat",
+        )
+        
+        image_bytes = b"Not an image at all!"
+        
+        relationships = Relationships({
+            "rId5": Relationship(target="media/hat.png")
+        })
+        
+        docx_file = context.mock()
+        funk.allows(docx_file).open("word/media/hat.png").returns(io.BytesIO(image_bytes))
+        
+        content_types = context.mock()
+        funk.allows(content_types).find_content_type("word/media/hat.png").returns("image/png")
+        
+        image = _read_and_get_document_xml_element(
+            drawing_element,
+            content_types=content_types,
+            relationships=relationships,
+            docx_file=docx_file,
+        )[0]
+        assert_equal(documents.Image, type(image))
+        assert_equal("It's a hat", image.alt_text)
+        assert_equal("image/png", image.content_type)
+        with image.open() as image_file:
+            assert_equal(image_bytes, image_file.read())
+        
+        
+    @istest
+    @funk.with_context
+    def warning_if_unsupported_image_type(self, context):
+        drawing_element = _create_inline_image(
+            relationship_id="rId5",
+            description="It's a hat",
+        )
+        
+        image_bytes = b"Not an image at all!"
+        
+        relationships = Relationships({
+            "rId5": Relationship(target="media/hat.emf")
+        })
+        
+        docx_file = context.mock()
+        funk.allows(docx_file).open("word/media/hat.emf").returns(io.BytesIO(image_bytes))
+        
+        content_types = context.mock()
+        funk.allows(content_types).find_content_type("word/media/hat.emf").returns("image/x-emf")
+        
+        result = _read_document_xml_element(
+            drawing_element,
+            content_types=content_types,
+            relationships=relationships,
+            docx_file=docx_file,
+        )
+        assert_equal("image/x-emf", result.value[0].content_type)
+        expected_warning = results.warning("Image of type image/x-emf is unlikely to display in web browsers")
+        assert_equal([expected_warning], result.messages)
+    
+    @istest
+    def footnote_reference_has_id_read(self):
+        footnote_xml = xml_element("w:footnoteReference", {"w:id": "4"})
+        footnote = _read_and_get_document_xml_element(footnote_xml)
+        assert_equal("4", footnote.note_id)
+    
+    @istest
+    def ignored_elements_are_ignored_without_message(self):
+        element = xml_element("w:bookmarkEnd")
+        result = _read_document_xml_element(element)
+        assert_equal(None, result.value)
+        assert_equal([], result.messages)
+    
+    @istest
+    def unrecognised_elements_emit_warning(self):
+        element = xml_element("w:huh", {}, [])
+        result = _read_document_xml_element(element)
+        expected_warning = results.warning("An unrecognised element was ignored: w:huh")
+        assert_equal([expected_warning], result.messages)
+    
+    @istest
+    def unrecognised_elements_are_ignored(self):
+        element = xml_element("w:huh", {}, [])
+        assert_equal(None, _read_document_xml_element(element).value)
+    
+    @istest
+    def unrecognised_children_are_ignored(self):
+        element = xml_element("w:r", {}, [_text_element("Hello!"), xml_element("w:huh", {}, [])])
+        assert_equal(
+            documents.run([documents.Text("Hello!")]),
+            _read_document_xml_element(element).value
+        )
+        
+    @istest
+    def text_boxes_have_content_appended_after_containing_paragraph(self):
+        text_box = xml_element("w:pict", {}, [
+            xml_element("v:shape", {}, [
+                xml_element("v:textbox", {}, [
+                    xml_element("w:txbxContent", {}, [
+                        _paragraph_with_style_id("textbox-content")
+                    ])
+                ])
+            ])
+        ])
+        paragraph = xml_element("w:p", {}, [
+            xml_element("w:r", {}, [text_box])
+        ])
+        result = _read_and_get_document_xml_element(paragraph)
+        assert_equal(result[1].style_id, "textbox-content")
+    
+    @istest
+    def alternate_content_is_read_using_fallback(self):
+        element = xml_element("mc:AlternateContent", {}, [
+            xml_element("mc:Choice", {"Requires": "wps"}, [
+                _paragraph_with_style_id("first")
+            ]),
+            xml_element("mc:Fallback", {}, [
+                _paragraph_with_style_id("second")
+            ])
+        ])
+        result = _read_and_get_document_xml_element(element)
+        assert_equal("second", result[0].style_id)
+
+
+def _read_and_get_document_xml_element(*args, **kwargs):
+    styles = kwargs.pop("styles", FakeStyles())
+    result = _read_document_xml_element(*args, styles=styles, **kwargs)
+    assert_equal([], result.messages)
+    return result.value
+
+
+def _read_document_xml_element(element, *args, **kwargs):
+    reader = body_xml.reader(*args, **kwargs)
+    return reader.read(element)
+
+
+class FakeStyles(object):
+    def find_paragraph_style_by_id(self, style_id):
+        return Style(style_id, style_id)
+
+def _document_element_with_text(text):
+    return xml_element("w:document", {}, [
+        xml_element("w:body", {}, [_paragraph_element_with_text(text)])
+    ])
+
+
+def _paragraph_element_with_text(text):
+    return xml_element("w:p", {}, [_run_element_with_text(text)])
+
+def _paragraph_with_style_id(style_id):
+    style_xml = xml_element("w:pStyle", {"w:val": style_id})
+    properties_xml = xml_element("w:pPr", {}, [style_xml])
+    return xml_element("w:p", {}, [properties_xml])
+
+def _run_element_with_text(text):
+    return xml_element("w:r", {}, [_text_element(text)])
+
+
+def _text_element(value):
+    return xml_element("w:t", {}, [xml_text(value)])
+    
+
+def _create_inline_image(description, relationship_id):
+    return xml_element("w:drawing", {}, [
+        xml_element("wp:inline", {}, _create_image_elements(description, relationship_id))
+    ])
+
+
+def _create_anchored_image(description, relationship_id):
+    return xml_element("w:drawing", {}, [
+        xml_element("wp:anchor", {}, _create_image_elements(description, relationship_id))
+    ])
+
+    
+def _create_image_elements(description, relationship_id):
+    return [
+        xml_element("wp:docPr", {"descr": description}),
+        xml_element("a:graphic", {}, [
+            xml_element("a:graphicData", {}, [
+                xml_element("pic:pic", {}, [
+                    xml_element("pic:blipFill", {}, [
+                        xml_element("a:blip", {"r:embed": relationship_id})
+                    ])
+                ])
+            ])
+        ])
+    ]
diff --git a/tests/docx/document_xml_tests.py b/tests/docx/document_xml_tests.py
index bc6fcfb..00c7770 100644
--- a/tests/docx/document_xml_tests.py
+++ b/tests/docx/document_xml_tests.py
@@ -1,41 +1,14 @@
-import io
-
 from nose.tools import istest, assert_equal
-import funk
 
-from mammoth import documents, results
+from mammoth import documents
 from mammoth.docx.xmlparser import element as xml_element, text as xml_text
 from mammoth.docx.document_xml import read_document_xml_element
-from mammoth.docx.numbering_xml import Numbering
-from mammoth.docx.relationships_xml import Relationships, Relationship
-from mammoth.docx.styles_xml import Styles, Style
 from mammoth.docx.notes_xml import NoteElement
 
 
 @istest
 class ReadXmlElementTests(object):
     @istest
-    def text_from_text_element_is_read(self):
-        element = _text_element("Hello!")
-        assert_equal(documents.Text("Hello!"), _read_and_get_document_xml_element(element))
-    
-    @istest
-    def can_read_text_within_run(self):
-        element = _run_element_with_text("Hello!")
-        assert_equal(
-            documents.run([documents.Text("Hello!")]),
-            _read_and_get_document_xml_element(element)
-        )
-    
-    @istest
-    def can_read_text_within_paragraph(self):
-        element = _paragraph_element_with_text("Hello!")
-        assert_equal(
-            documents.paragraph([documents.run([documents.Text("Hello!")])]),
-            _read_and_get_document_xml_element(element)
-        )
-    
-    @istest
     def can_read_text_within_document(self):
         element = _document_element_with_text("Hello!")
         assert_equal(
@@ -44,337 +17,6 @@ class ReadXmlElementTests(object):
         )
         
     @istest
-    def paragraph_has_no_style_if_it_has_no_properties(self):
-        element = xml_element("w:p")
-        assert_equal(None, _read_and_get_document_xml_element(element).style_id)
-        
-    @istest
-    def paragraph_has_style_id_read_from_paragraph_properties_if_present(self):
-        style_xml = xml_element("w:pStyle", {"w:val": "Heading1"})
-        properties_xml = xml_element("w:pPr", {}, [style_xml])
-        paragraph_xml = xml_element("w:p", {}, [properties_xml])
-        
-        styles = Styles({"Heading1": Style(style_id="Heading1", name="Heading 1")}, {})
-        
-        paragraph = _read_and_get_document_xml_element(paragraph_xml, styles=styles)
-        assert_equal("Heading1", paragraph.style_id)
-        
-    @istest
-    def paragraph_has_style_name_read_from_paragraph_properties_and_styles(self):
-        style_xml = xml_element("w:pStyle", {"w:val": "Heading1"})
-        properties_xml = xml_element("w:pPr", {}, [style_xml])
-        paragraph_xml = xml_element("w:p", {}, [properties_xml])
-        
-        styles = Styles({"Heading1": Style(style_id="Heading1", name="Heading 1")}, {})
-        
-        paragraph = _read_and_get_document_xml_element(paragraph_xml, styles=styles)
-        assert_equal("Heading 1", paragraph.style_name)
-        
-    @istest
-    def paragraph_has_no_numbering_if_it_has_no_numbering_properties(self):
-        element = xml_element("w:p")
-        assert_equal(None, _read_and_get_document_xml_element(element).numbering)
-        
-    @istest
-    def paragraph_has_numbering_properties_from_paragraph_properties_if_present(self):
-        numbering_properties_xml = xml_element("w:numPr", {}, [
-            xml_element("w:ilvl", {"w:val": "1"}),
-            xml_element("w:numId", {"w:val": "42"}),
-        ])
-        properties_xml = xml_element("w:pPr", {}, [numbering_properties_xml])
-        paragraph_xml = xml_element("w:p", {}, [properties_xml])
-        
-        numbering = Numbering({"42": {"1": documents.numbering_level("1", True)}})
-        paragraph = _read_and_get_document_xml_element(paragraph_xml, numbering=numbering)
-        
-        assert_equal("1", paragraph.numbering.level_index)
-        assert_equal(True, paragraph.numbering.is_ordered)
-    
-    @istest
-    def run_has_no_style_if_it_has_no_properties(self):
-        element = xml_element("w:r")
-        assert_equal(None, _read_and_get_document_xml_element(element).style_id)
-        
-    @istest
-    def run_has_style_id_read_from_run_properties_if_present(self):
-        style_xml = xml_element("w:rStyle", {"w:val": "Heading1Char"})
-        
-        styles = Styles({}, {"Heading1Char": Style(style_id="Heading1Char", name="Heading 1 Char")})
-        
-        run = self._read_run_with_properties([style_xml], styles=styles)
-        assert_equal("Heading1Char", run.style_id)
-        
-    @istest
-    def run_has_style_name_read_from_run_properties_and_styles(self):
-        style_xml = xml_element("w:rStyle", {"w:val": "Heading1Char"})
-        
-        styles = Styles({}, {"Heading1Char": Style(style_id="Heading1Char", name="Heading 1 Char")})
-        
-        run = self._read_run_with_properties([style_xml], styles=styles)
-        assert_equal("Heading 1 Char", run.style_name)
-        
-    @istest
-    def run_is_not_bold_if_bold_element_is_not_present(self):
-        run = self._read_run_with_properties([])
-        assert_equal(False, run.is_bold)
-    
-    @istest
-    def run_is_bold_if_bold_element_is_present(self):
-        run = self._read_run_with_properties([xml_element("w:b")])
-        assert_equal(True, run.is_bold)
-        
-    @istest
-    def run_is_not_italic_if_italic_element_is_not_present(self):
-        run = self._read_run_with_properties([])
-        assert_equal(False, run.is_italic)
-    
-    @istest
-    def run_is_italic_if_italic_element_is_present(self):
-        run = self._read_run_with_properties([xml_element("w:i")])
-        assert_equal(True, run.is_italic)
-        
-    @istest
-    def run_is_not_underlined_if_underline_element_is_not_present(self):
-        run = self._read_run_with_properties([])
-        assert_equal(False, run.is_underline)
-    
-    @istest
-    def run_is_underlined_if_underline_element_is_present(self):
-        run = self._read_run_with_properties([xml_element("w:u")])
-        assert_equal(True, run.is_underline)
-        
-    @istest
-    def run_is_not_struckthrough_if_strikethrough_element_is_not_present(self):
-        run = self._read_run_with_properties([])
-        assert_equal(False, run.is_strikethrough)
-    
-    @istest
-    def run_is_struckthrough_if_strikethrough_element_is_present(self):
-        run = self._read_run_with_properties([xml_element("w:strike")])
-        assert_equal(True, run.is_strikethrough)
-    
-    @istest
-    def run_has_baseline_vertical_alignment_if_vertical_alignment_element_is_not_present(self):
-        run = self._read_run_with_properties([])
-        assert_equal(documents.VerticalAlignment.baseline, run.vertical_alignment)
-        
-    @istest
-    def run_has_vertical_alignment_read_from_vertical_alignment_element(self):
-        run = self._read_run_with_properties([xml_element("w:vertAlign", {"w:val": "superscript"})])
-        assert_equal(documents.VerticalAlignment.superscript, run.vertical_alignment)
-    
-    def _read_run_with_properties(self, properties, styles=None):
-        properties_xml = xml_element("w:rPr", {}, properties)
-        run_xml = xml_element("w:r", {}, [properties_xml])
-        return _read_and_get_document_xml_element(run_xml, styles=styles)
-
-
-    @istest
-    def can_read_tab_element(self):
-        element = xml_element("w:tab")
-        tab = _read_and_get_document_xml_element(element)
-        assert_equal(documents.tab(), tab)
-    
-    
-    @istest
-    def word_table_is_read_as_document_table_element(self):
-        element = xml_element("w:tbl", {}, [
-            xml_element("w:tr", {}, [
-                xml_element("w:tc", {}, [
-                    xml_element("w:p", {}, [])
-                ]),
-            ]),
-        ])
-        table = _read_and_get_document_xml_element(element)
-        expected_result = documents.table([
-            documents.table_row([
-                documents.table_cell([
-                    documents.paragraph([])
-                ])
-            ])
-        ])
-        assert_equal(expected_result, table)
-
-
-    @istest
-    def children_of_w_ins_are_converted_normally(self):
-        element = xml_element("w:p", {}, [
-            xml_element("w:ins", {}, [
-                xml_element("w:r")
-            ])
-        ])
-        assert_equal(
-            documents.paragraph([documents.run([])]),
-            _read_and_get_document_xml_element(element)
-        )
-        
-    @istest
-    def children_of_w_smart_tag_are_converted_normally(self):
-        element = xml_element("w:p", {}, [
-            xml_element("w:smartTag", {}, [
-                xml_element("w:r")
-            ])
-        ])
-        assert_equal(
-            documents.paragraph([documents.run([])]),
-            _read_and_get_document_xml_element(element)
-        )
-        
-    @istest
-    def hyperlink_is_read_if_it_has_a_relationship_id(self):
-        relationships = Relationships({
-            "r42": Relationship(target="http://example.com")
-        })
-        run_element = xml_element("w:r")
-        element = xml_element("w:hyperlink", {"r:id": "r42"}, [run_element])
-        assert_equal(
-            documents.hyperlink(href="http://example.com", children=[documents.run([])]),
-            _read_and_get_document_xml_element(element, relationships=relationships)
-        )
-        
-    @istest
-    def hyperlink_is_read_if_it_has_an_anchor_attribute(self):
-        run_element = xml_element("w:r")
-        element = xml_element("w:hyperlink", {"w:anchor": "start"}, [run_element])
-        assert_equal(
-            documents.hyperlink(anchor="start", children=[documents.run([])]),
-            _read_and_get_document_xml_element(element)
-        )
-        
-    @istest
-    def hyperlink_is_ignored_if_it_does_not_have_a_relationship_id_nor_anchor(self):
-        run_element = xml_element("w:r")
-        element = xml_element("w:hyperlink", {}, [run_element])
-        assert_equal(
-            [documents.run([])],
-            _read_and_get_document_xml_element(element)
-        )
-        
-    @istest
-    def go_back_bookmark_is_ignored(self):
-        element = xml_element("w:bookmarkStart", {"w:name": "_GoBack"})
-        assert_equal(None, _read_and_get_document_xml_element(element))
-        
-    @istest
-    def bookmark_start_is_read_if_name_is_not_go_back(self):
-        element = xml_element("w:bookmarkStart", {"w:name": "start"})
-        assert_equal(
-            documents.bookmark("start"),
-            _read_and_get_document_xml_element(element)
-        )
-    
-    @istest
-    def br_is_read_as_line_break(self):
-        break_element = xml_element("w:br", {}, [])
-        result = _read_and_get_document_xml_element(break_element)
-        assert_equal(result, documents.line_break())
-    
-    
-    @istest
-    def warning_on_breaks_that_arent_line_breaks(self):
-        break_element = xml_element("w:br", {"w:type": "page"}, [])
-        result = read_document_xml_element(break_element)
-        expected_warning = results.warning("Unsupported break type: page")
-        assert_equal([expected_warning], result.messages)
-        assert_equal(None, result.value)
-        
-        
-    @istest
-    @funk.with_context
-    def can_read_inline_pictures(self, context):
-        drawing_element = _create_inline_image(
-            relationship_id="rId5",
-            description="It's a hat",
-        )
-        
-        image_bytes = b"Not an image at all!"
-        
-        relationships = Relationships({
-            "rId5": Relationship(target="media/hat.png")
-        })
-        
-        docx_file = context.mock()
-        funk.allows(docx_file).open("word/media/hat.png").returns(io.BytesIO(image_bytes))
-        
-        content_types = context.mock()
-        funk.allows(content_types).find_content_type("word/media/hat.png").returns("image/png")
-        
-        image = _read_and_get_document_xml_element(
-            drawing_element,
-            content_types=content_types,
-            relationships=relationships,
-            docx_file=docx_file,
-        )[0]
-        assert_equal(documents.Image, type(image))
-        assert_equal("It's a hat", image.alt_text)
-        assert_equal("image/png", image.content_type)
-        with image.open() as image_file:
-            assert_equal(image_bytes, image_file.read())
-        
-    @istest
-    @funk.with_context
-    def can_read_anchored_pictures(self, context):
-        drawing_element = _create_anchored_image(
-            relationship_id="rId5",
-            description="It's a hat",
-        )
-        
-        image_bytes = b"Not an image at all!"
-        
-        relationships = Relationships({
-            "rId5": Relationship(target="media/hat.png")
-        })
-        
-        docx_file = context.mock()
-        funk.allows(docx_file).open("word/media/hat.png").returns(io.BytesIO(image_bytes))
-        
-        content_types = context.mock()
-        funk.allows(content_types).find_content_type("word/media/hat.png").returns("image/png")
-        
-        image = _read_and_get_document_xml_element(
-            drawing_element,
-            content_types=content_types,
-            relationships=relationships,
-            docx_file=docx_file,
-        )[0]
-        assert_equal(documents.Image, type(image))
-        assert_equal("It's a hat", image.alt_text)
-        assert_equal("image/png", image.content_type)
-        with image.open() as image_file:
-            assert_equal(image_bytes, image_file.read())
-        
-        
-    @istest
-    @funk.with_context
-    def warning_if_unsupported_image_type(self, context):
-        drawing_element = _create_inline_image(
-            relationship_id="rId5",
-            description="It's a hat",
-        )
-        
-        image_bytes = b"Not an image at all!"
-        
-        relationships = Relationships({
-            "rId5": Relationship(target="media/hat.emf")
-        })
-        
-        docx_file = context.mock()
-        funk.allows(docx_file).open("word/media/hat.emf").returns(io.BytesIO(image_bytes))
-        
-        content_types = context.mock()
-        funk.allows(content_types).find_content_type("word/media/hat.emf").returns("image/x-emf")
-        
-        result = read_document_xml_element(
-            drawing_element,
-            content_types=content_types,
-            relationships=relationships,
-            docx_file=docx_file,
-        )
-        assert_equal("image/x-emf", result.value[0].content_type)
-        expected_warning = results.warning("Image of type image/x-emf is unlikely to display in web browsers")
-        assert_equal([expected_warning], result.messages)
-        
-    @istest
     def footnotes_of_document_are_read(self):
         paragraph_xml = xml_element("w:p")
         footnotes = [NoteElement("footnote", "4", [paragraph_xml])]
@@ -387,125 +29,24 @@ class ReadXmlElementTests(object):
         assert_equal("4", footnote.note_id)
         assert isinstance(footnote.body[0], documents.Paragraph)
     
-    @istest
-    def footnote_reference_has_id_read(self):
-        footnote_xml = xml_element("w:footnoteReference", {"w:id": "4"})
-        footnote = _read_and_get_document_xml_element(footnote_xml)
-        assert_equal("4", footnote.note_id)
-    
-    @istest
-    def ignored_elements_are_ignored_without_message(self):
-        element = xml_element("w:bookmarkEnd")
-        result = read_document_xml_element(element)
-        assert_equal(None, result.value)
-        assert_equal([], result.messages)
-    
-    @istest
-    def unrecognised_elements_emit_warning(self):
-        element = xml_element("w:huh", {}, [])
-        result = read_document_xml_element(element)
-        expected_warning = results.warning("An unrecognised element was ignored: w:huh")
-        assert_equal([expected_warning], result.messages)
-    
-    @istest
-    def unrecognised_elements_are_ignored(self):
-        element = xml_element("w:huh", {}, [])
-        assert_equal(None, read_document_xml_element(element).value)
-    
-    @istest
-    def unrecognised_children_are_ignored(self):
-        element = xml_element("w:r", {}, [_text_element("Hello!"), xml_element("w:huh", {}, [])])
-        assert_equal(
-            documents.run([documents.Text("Hello!")]),
-            read_document_xml_element(element).value
-        )
-        
-    @istest
-    def text_boxes_have_content_appended_after_containing_paragraph(self):
-        text_box = xml_element("w:pict", {}, [
-            xml_element("v:shape", {}, [
-                xml_element("v:textbox", {}, [
-                    xml_element("w:txbxContent", {}, [
-                        _paragraph_with_style_id("textbox-content")
-                    ])
-                ])
-            ])
-        ])
-        paragraph = xml_element("w:p", {}, [
-            xml_element("w:r", {}, [text_box])
-        ])
-        result = _read_and_get_document_xml_element(paragraph)
-        assert_equal(result[1].style_id, "textbox-content")
-    
-    @istest
-    def alternate_content_is_read_using_fallback(self):
-        element = xml_element("mc:AlternateContent", {}, [
-            xml_element("mc:Choice", {"Requires": "wps"}, [
-                _paragraph_with_style_id("first")
-            ]),
-            xml_element("mc:Fallback", {}, [
-                _paragraph_with_style_id("second")
-            ])
-        ])
-        result = _read_and_get_document_xml_element(element)
-        assert_equal("second", result[0].style_id)
-
 
 def _read_and_get_document_xml_element(*args, **kwargs):
-    styles = kwargs.pop("styles", FakeStyles())
-    result = read_document_xml_element(*args, styles=styles, **kwargs)
+    result = read_document_xml_element(*args, **kwargs)
     assert_equal([], result.messages)
     return result.value
 
 
-class FakeStyles(object):
-    def find_paragraph_style_by_id(self, style_id):
-        return Style(style_id, style_id)
-
 def _document_element_with_text(text):
     return xml_element("w:document", {}, [
         xml_element("w:body", {}, [_paragraph_element_with_text(text)])
     ])
 
-
 def _paragraph_element_with_text(text):
     return xml_element("w:p", {}, [_run_element_with_text(text)])
 
-def _paragraph_with_style_id(style_id):
-    style_xml = xml_element("w:pStyle", {"w:val": style_id})
-    properties_xml = xml_element("w:pPr", {}, [style_xml])
-    return xml_element("w:p", {}, [properties_xml])
-
 def _run_element_with_text(text):
     return xml_element("w:r", {}, [_text_element(text)])
 
 
 def _text_element(value):
     return xml_element("w:t", {}, [xml_text(value)])
-    
-
-def _create_inline_image(description, relationship_id):
-    return xml_element("w:drawing", {}, [
-        xml_element("wp:inline", {}, _create_image_elements(description, relationship_id))
-    ])
-
-
-def _create_anchored_image(description, relationship_id):
-    return xml_element("w:drawing", {}, [
-        xml_element("wp:anchor", {}, _create_image_elements(description, relationship_id))
-    ])
-
-    
-def _create_image_elements(description, relationship_id):
-    return [
-        xml_element("wp:docPr", {"descr": description}),
-        xml_element("a:graphic", {}, [
-            xml_element("a:graphicData", {}, [
-                xml_element("pic:pic", {}, [
-                    xml_element("pic:blipFill", {}, [
-                        xml_element("a:blip", {"r:embed": relationship_id})
-                    ])
-                ])
-            ])
-        ])
-    ]