diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile
index b29c593..aaf3fcc 100644
--- a/.devcontainer/Dockerfile
+++ b/.devcontainer/Dockerfile
@@ -3,5 +3,16 @@
 FROM mcr.microsoft.com/devcontainers/rust:1-1-bullseye
 
 # [Optional] Uncomment this section to install additional packages.
-# RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \
-#     && apt-get -y install --no-install-recommends <your-package-list-here>
+RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \
+    && apt-get -y install --no-install-recommends python3-lxml
+
+USER vscode
+
+# Install nightly rust
+RUN rustup toolchain install nightly
+
+# Install pip
+ENV PATH="${PATH}:/home/vscode/.local/bin"
+RUN curl https://bootstrap.pypa.io/get-pip.py -o /tmp/get-pip.py \
+    && python3 /tmp/get-pip.py \
+    && rm /tmp/get-pip.py
diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json
index 6c5728e..2d6e42d 100644
--- a/.devcontainer/devcontainer.json
+++ b/.devcontainer/devcontainer.json
@@ -5,32 +5,35 @@
 	"build": {
 		"dockerfile": "Dockerfile"
 	},
-	"runArgs": [ "--cap-add=SYS_PTRACE", "--security-opt", "seccomp=unconfined" ],
-
-	// Set *default* container specific settings.json values on container create.
-	"settings": { 
-		"lldb.executable": "/usr/bin/lldb",
-		// VS Code don't watch files under ./target
-		"files.watcherExclude": {
-			"**/target/**": true
+	"runArgs": [
+		"--cap-add=SYS_PTRACE",
+		"--security-opt",
+		"seccomp=unconfined"
+	],
+	"customizations": {
+		"vscode": {
+			// Set *default* container specific settings.json values on container create.
+			"settings": {
+				"lldb.executable": "/usr/bin/lldb",
+				// VS Code don't watch files under ./target
+				"files.watcherExclude": {
+					"**/target/**": true
+				}
+			},
+			// Add the IDs of extensions you want installed when the container is created.
+			"extensions": [
+				"matklad.rust-analyzer",
+				"bungcip.better-toml",
+				"vadimcn.vscode-lldb",
+				"mutantdino.resourcemonitor",
+				"ms-azuretools.vscode-docker"
+			]
 		}
 	},
-
-	// Add the IDs of extensions you want installed when the container is created.
-	"extensions": [
-		"matklad.rust-analyzer",
-		"bungcip.better-toml",
-		"vadimcn.vscode-lldb",
-		"mutantdino.resourcemonitor",
-		"ms-azuretools.vscode-docker"
-	],
-
 	// Use 'forwardPorts' to make a list of ports inside the container available locally.
 	// "forwardPorts": [],
-
 	// Use 'postCreateCommand' to run commands after the container is created.
-	// "postCreateCommand": "rustc --version",
-
+	"postCreateCommand": "pip install -r tests/lxml_tests/requirements.txt",
 	// Comment out connect as root instead. More info: https://aka.ms/vscode-remote/containers/non-root.
 	"remoteUser": "vscode"
-}
+}
\ No newline at end of file
diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
index 1d47d4c..e532d04 100644
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -11,14 +11,17 @@ env:
   CARGO_TERM_COLOR: always
 
 jobs:
-  build:
+  build:          
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v3
-    - name: Build
-      run: cargo build --verbose
-    - name: Run tests
-      run: cargo test --verbose
+      - name: Checkout (GitHub)
+        uses: actions/checkout@v3
+      - name: Run tests in devcontainer
+        uses: devcontainers/ci@v0.3
+        with:
+          push: never
+          runCmd: |
+            cargo test
   
   stack_overflow_tests:
     runs-on: windows-latest
diff --git a/Cargo.toml b/Cargo.toml
index d57b2ca..71038c3 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "skyscraper"
-version = "0.6.1"
+version = "0.6.2"
 authors = ["James La Novara-Gsell <james.lanovara.gsell@gmail.com>"]
 edition = "2021"
 description = "XPath for HTML web scraping"
@@ -29,6 +29,8 @@ mockall = "0.12.0"
 indoc = "2"
 proptest = "1.3.1"
 regex = "1.10.3"
+serde_json = "1.0.113"
+serde = "1.0.196"
 
 [[bench]]
 name = "benchmarks"
diff --git a/src/html/mod.rs b/src/html/mod.rs
index c859c0a..e7fa9d1 100644
--- a/src/html/mod.rs
+++ b/src/html/mod.rs
@@ -139,21 +139,70 @@ pub struct HtmlText {
 impl HtmlText {
     /// Creates a new [HtmlText] from the given string.
     pub fn from_str(value: &str) -> HtmlText {
-        // If the text has non-whitespace characters, trim it.
-        let trimmed_text = value.trim();
-        let value = if trimmed_text.is_empty() {
-            value
-        } else {
-            trimmed_text
-        };
-
+        let text = unescape_characters(value);
         HtmlText {
-            value: value.to_string(),
-            only_whitespace: trimmed_text.is_empty(),
+            value: text.to_string(),
+            only_whitespace: text.trim().is_empty(),
         }
     }
 }
 
+/// Unescapes commonly escaped characters in HTML text.
+///
+/// - `&amp;` becomes `&`
+/// - `&lt;` becomes `<`
+/// - `&gt;` becomes `>`
+/// - `&quot;` becomes `"`
+/// - `&#39;` becomes `'`
+pub fn unescape_characters(text: &str) -> String {
+    text.replace("&amp;", "&")
+        .replace("&lt;", "<")
+        .replace("&gt;", ">")
+        .replace("&quot;", r#"""#)
+        .replace("&#39;", "'")
+}
+
+/// Escapes commonly escaped characters in HTML text.
+///
+/// - `&` becomes `&amp;`
+/// - `<` becomes `&lt;`
+/// - `>` becomes `&gt;`
+/// - `"` becomes `&quot;`
+/// - `'` becomes `&#39;`
+pub fn escape_characters(text: &str) -> String {
+    text.replace("&", "&amp;")
+        .replace("<", "&lt;")
+        .replace(">", "&gt;")
+        .replace(r#"""#, "&quot;")
+        .replace("'", "&#39;")
+}
+
+/// Trims internal whitespace from the given text such that only a single space separates words.
+/// This is used to emulate the behaviour of Chromium browsers.
+///
+/// # Example
+/// ```rust
+/// use skyscraper::html::trim_internal_whitespace;
+/// let text = "  hello  \n world  ";
+/// let result = trim_internal_whitespace(text);
+/// assert_eq!("hello world", result);
+/// ```
+pub fn trim_internal_whitespace(text: &str) -> String {
+    let mut result = String::new();
+    let mut last_char = ' ';
+    for c in text.chars() {
+        if c.is_whitespace() {
+            if !last_char.is_whitespace() {
+                result.push(' ');
+            }
+        } else {
+            result.push(c);
+        }
+        last_char = c;
+    }
+    result.trim_end().to_string()
+}
+
 /// An HTML node can be either a tag or raw text.
 #[derive(Clone, Debug, EnumExtract)]
 pub enum HtmlNode {
@@ -249,6 +298,14 @@ impl HtmlDocument {
             display_node(0, self, &self.root_node, format_type).expect("failed to display node");
         format!("{}", text)
     }
+
+    /// Get an iterator over all nodes in this document.
+    pub fn iter(&self) -> impl Iterator<Item = DocumentNode> + '_ {
+        self.arena.iter().map(|node| {
+            let id = self.arena.get_node_id(node).unwrap();
+            DocumentNode::new(id)
+        })
+    }
 }
 
 impl fmt::Display for HtmlDocument {
@@ -325,14 +382,15 @@ fn display_node(
             }
         }
         HtmlNode::Text(text) => {
+            let output_text = escape_characters(text.value.as_str());
             match format_type {
                 DocumentFormatType::Standard => {
-                    write!(&mut str, "{}", text.value)?;
+                    write!(&mut str, "{}", output_text)?;
                 }
                 DocumentFormatType::IgnoreWhitespace => {
                     // If ignoring whitespace texts, only display if this text is not solely whitespace.
                     if !text.only_whitespace {
-                        write!(&mut str, "{}", text.value)?;
+                        write!(&mut str, "{}", output_text)?;
                     }
                 }
                 DocumentFormatType::Indented => {
@@ -341,7 +399,7 @@ fn display_node(
                         display_indent(indent, &mut str)?;
 
                         // Trim the text incase there's leading or trailing whitespace.
-                        writeln!(&mut str, "{}", text.value.trim())?;
+                        writeln!(&mut str, "{}", output_text.trim())?;
                     }
                 }
             }
@@ -809,4 +867,30 @@ mod tests {
         // assert
         assert_eq!(html_output, text);
     }
+
+    #[test]
+    fn html_document_display_should_escape_text() {
+        // arrange
+        let text = indoc!(
+            r#"
+            <html>
+                &lt;
+            </html>
+            "#,
+        );
+
+        let document = parse(&text).unwrap();
+
+        // act
+        let html_output = document.to_formatted_string(DocumentFormatType::Indented);
+
+        // assert
+        // assert that the text retrieved from the tag was unescaped
+        let root_text = document.root_node.get_text(&document).unwrap();
+        let trimmed = root_text.trim();
+        assert_eq!("<", trimmed);
+
+        // asser that the display output was escaped
+        assert_eq!(html_output, text);
+    }
 }
diff --git a/src/html/parse/mod.rs b/src/html/parse/mod.rs
index 082bd2e..fb985b5 100644
--- a/src/html/parse/mod.rs
+++ b/src/html/parse/mod.rs
@@ -409,7 +409,7 @@ fn get_mut_tree_node(key: Option<NodeId>, arena: &mut Arena<HtmlNode>) -> &mut N
 pub mod test_helpers {
     use std::collections::HashMap;
 
-    use crate::html::{DocumentNode, HtmlDocument, HtmlNode, HtmlText};
+    use crate::html::{DocumentNode, HtmlDocument, HtmlNode};
 
     pub fn assert_tag(
         document: &HtmlDocument,
@@ -445,7 +445,7 @@ pub mod test_helpers {
         let html_node = document.get_html_node(&key).unwrap();
 
         let node_text = html_node.extract_as_text();
-        assert_eq!(&HtmlText::from_str(text), node_text);
+        assert_eq!(text, node_text.value.trim());
     }
 }
 
@@ -910,23 +910,12 @@ mod tests {
 
                                     // <html> -> <body> -> <main> -> <section> -> <div> -> <div> -> <section> -> <p> -> text()
                                     {
-                                        let key = children.next().unwrap();
-                                        assert_text(
-                                            &result,
-                                            key,
-                                            "Rust is blazingly fast and memory-efficient: with no runtime or");
-
-                                        let key = children.next().unwrap();
-                                        assert_text(
-                                            &result,
-                                            key,
-                                            "garbage collector, it can power performance-critical services, run on");
+                                        let mut t = String::from("Rust is blazingly fast and memory-efficient: with no runtime or");
+                                        t = format!("{}\n                                    garbage collector, it can power performance-critical services, run on", t);
+                                        t = format!("{}\n                                    embedded devices, and easily integrate with other languages.", t);
 
                                         let key = children.next().unwrap();
-                                        assert_text(
-                                            &result,
-                                            key,
-                                            "embedded devices, and easily integrate with other languages.");
+                                        assert_text(&result, key, &t);
                                     }
                                 }
                             }
diff --git a/src/html/tokenizer/helpers.rs b/src/html/tokenizer/helpers.rs
index f2a83e2..e39f881 100644
--- a/src/html/tokenizer/helpers.rs
+++ b/src/html/tokenizer/helpers.rs
@@ -275,10 +275,10 @@ pub fn is_text(
                         pointer.index = pointer_index;
                         buffer.push('<');
                     }
-                    Some('\n') => {
-                        // Text is allowed to start with a new line, but not allowed to contain one mid-sequence.
-                        break;
-                    }
+                    // Some('\n') => {
+                    //     // Text is allowed to start with a new line, but not allowed to contain one mid-sequence.
+                    //     break;
+                    // }
                     Some(c) => {
                         buffer.push(*c);
                     }
@@ -683,7 +683,7 @@ mod tests {
     }
 
     #[test]
-    fn is_text_should_terminate_on_newline() {
+    fn is_text_should_not_terminate_on_newline() {
         // arrange
         let chars: Vec<char> = "foo\nbar".chars().collect();
         let mut pointer = VecPointerRef::new(&chars);
@@ -692,8 +692,8 @@ mod tests {
         let result = is_text(&mut pointer, false, true).unwrap();
 
         // assert
-        assert_eq!(result, Token::Text(String::from("foo")));
-        assert_eq!(pointer.index, 3);
+        assert_eq!(result, Token::Text(String::from("foo\nbar")));
+        assert_eq!(pointer.index, 7);
     }
 
     #[test]
@@ -709,4 +709,18 @@ mod tests {
         assert_eq!(result, Token::Text(String::from("\n\t\t")));
         assert_eq!(pointer.index, 3);
     }
+
+    #[test]
+    fn is_text_should_capture_multiple_lines_of_whitespace() {
+        // arrange
+        let chars: Vec<char> = "\n\t\n\t".chars().collect();
+        let mut pointer = VecPointerRef::new(&chars);
+
+        // act
+        let result = is_text(&mut pointer, false, true).unwrap();
+
+        // assert
+        assert_eq!(result, Token::Text(String::from("\n\t\n\t")));
+        assert_eq!(pointer.index, 4);
+    }
 }
diff --git a/src/html/tokenizer/mod.rs b/src/html/tokenizer/mod.rs
index 23197de..9e68e3b 100644
--- a/src/html/tokenizer/mod.rs
+++ b/src/html/tokenizer/mod.rs
@@ -60,6 +60,9 @@ pub fn lex(text: &str) -> Result<Vec<Token>, LexError> {
             symbols.push(s);
         } else {
             if let Some(c) = pointer.current() {
+                if *c != ' ' {
+                    println!("Unknown symbol {}", c);
+                }
                 if !c.is_whitespace() {
                     // Unknown symbol, move on ¯\_(ツ)_/¯
                     error!("Unknown HTML symbol {}", c);
@@ -183,207 +186,4 @@ mod tests {
 
         assert_eq!(expected, result);
     }
-
-    #[test]
-    fn lex_should_work_with_html() {
-        // arrange
-        let html = r###"<!DOCTYPE html>
-        <!-- saved from url=(0026)https://www.rust-lang.org/ -->
-        <html lang="en-US">
-            <head>
-                <title>Rust Programming Language</title>
-                <meta name="viewport" content="width=device-width,initial-scale=1.0">
-        
-                <!-- Twitter card -->
-                <meta name="twitter:card" content="summary">
-            </head>
-            <body>
-                <main>
-                    <section id="language-values" class="green">
-                        <div class="w-100 mw-none ph3 mw8-m mw9-l center f3">
-                            <header class="pb0">
-                                <h2>
-                                Why Rust?
-                                </h2>
-                            </header>
-                            <div class="flex-none flex-l">
-                                <section class="w-100 pv2 pv0-l mt4">
-                                    <h3 class="f2 f1-l">Performance</h3>
-                                    <p class="f3 lh-copy">
-                                    Rust is blazingly fast and memory-efficient: with no runtime or
-                                    garbage collector, it can power performance-critical services, run on
-                                    embedded devices, and easily integrate with other languages.
-                                    </p>
-                                </section>
-                            </div>
-                        </div>
-                    </section>
-                </main>
-                <script src="./Rust Programming Language_files/languages.js.download"/>
-            </body>
-        </html>"###;
-
-        // act
-        let result = lex(html).unwrap();
-
-        // assert
-        let expected = vec![
-            Token::StartTag(String::from("!DOCTYPE")),
-            Token::Identifier(String::from("html")),
-            Token::TagClose,
-            Token::Text(String::from("\n        ")),
-            Token::Comment(String::from(
-                " saved from url=(0026)https://www.rust-lang.org/ ",
-            )),
-            Token::Text(String::from("\n        ")),
-            Token::StartTag(String::from("html")),
-            Token::Identifier(String::from("lang")),
-            Token::AssignmentSign,
-            Token::Literal(String::from("en-US")),
-            Token::TagClose,
-            Token::Text(String::from("\n            ")),
-            Token::StartTag(String::from("head")),
-            Token::TagClose,
-            Token::Text(String::from("\n                ")),
-            Token::StartTag(String::from("title")),
-            Token::TagClose,
-            Token::Text(String::from("Rust Programming Language")),
-            Token::EndTag(String::from("title")),
-            Token::TagClose,
-            Token::Text(String::from("\n                ")),
-            Token::StartTag(String::from("meta")),
-            Token::Identifier(String::from("name")),
-            Token::AssignmentSign,
-            Token::Literal(String::from("viewport")),
-            Token::Identifier(String::from("content")),
-            Token::AssignmentSign,
-            Token::Literal(String::from("width=device-width,initial-scale=1.0")),
-            Token::TagClose,
-            Token::Text(String::from("\n        ")),
-            Token::Text(String::from("\n                ")),
-            Token::Comment(String::from(" Twitter card ")),
-            Token::Text(String::from("\n                ")),
-            Token::StartTag(String::from("meta")),
-            Token::Identifier(String::from("name")),
-            Token::AssignmentSign,
-            Token::Literal(String::from("twitter:card")),
-            Token::Identifier(String::from("content")),
-            Token::AssignmentSign,
-            Token::Literal(String::from("summary")),
-            Token::TagClose,
-            Token::Text(String::from("\n            ")),
-            Token::EndTag(String::from("head")),
-            Token::TagClose,
-            Token::Text(String::from("\n            ")),
-            Token::StartTag(String::from("body")),
-            Token::TagClose,
-            Token::Text(String::from("\n                ")),
-            Token::StartTag(String::from("main")),
-            Token::TagClose,
-            Token::Text(String::from("\n                    ")),
-            Token::StartTag(String::from("section")),
-            Token::Identifier(String::from("id")),
-            Token::AssignmentSign,
-            Token::Literal(String::from("language-values")),
-            Token::Identifier(String::from("class")),
-            Token::AssignmentSign,
-            Token::Literal(String::from("green")),
-            Token::TagClose,
-            Token::Text(String::from("\n                        ")),
-            Token::StartTag(String::from("div")),
-            Token::Identifier(String::from("class")),
-            Token::AssignmentSign,
-            Token::Literal(String::from("w-100 mw-none ph3 mw8-m mw9-l center f3")),
-            Token::TagClose,
-            Token::Text(String::from("\n                            ")),
-            Token::StartTag(String::from("header")),
-            Token::Identifier(String::from("class")),
-            Token::AssignmentSign,
-            Token::Literal(String::from("pb0")),
-            Token::TagClose,
-            Token::Text(String::from("\n                                ")),
-            Token::StartTag(String::from("h2")),
-            Token::TagClose,
-            Token::Text(String::from("\n                                Why Rust?")),
-            Token::Text(String::from("\n                                ")),
-            Token::EndTag(String::from("h2")),
-            Token::TagClose,
-            Token::Text(String::from("\n                            ")),
-            Token::EndTag(String::from("header")),
-            Token::TagClose,
-            Token::Text(String::from("\n                            ")),
-            Token::StartTag(String::from("div")),
-            Token::Identifier(String::from("class")),
-            Token::AssignmentSign,
-            Token::Literal(String::from("flex-none flex-l")),
-            Token::TagClose,
-            Token::Text(String::from("\n                                ")),
-            Token::StartTag(String::from("section")),
-            Token::Identifier(String::from("class")),
-            Token::AssignmentSign,
-            Token::Literal(String::from("w-100 pv2 pv0-l mt4")),
-            Token::TagClose,
-            Token::Text(String::from("\n                                    ")),
-            Token::StartTag(String::from("h3")),
-            Token::Identifier(String::from("class")),
-            Token::AssignmentSign,
-            Token::Literal(String::from("f2 f1-l")),
-            Token::TagClose,
-            Token::Text(String::from("Performance")),
-            Token::EndTag(String::from("h3")),
-            Token::TagClose,
-            Token::Text(String::from("\n                                    ")),
-            Token::StartTag(String::from("p")),
-            Token::Identifier(String::from("class")),
-            Token::AssignmentSign,
-            Token::Literal(String::from("f3 lh-copy")),
-            Token::TagClose,
-            Token::Text(String::from(
-                "\n                                    Rust is blazingly fast and memory-efficient: with no runtime or",
-            )),
-            Token::Text(String::from(
-                "\n                                    garbage collector, it can power performance-critical services, run on",
-            )),
-            Token::Text(String::from(
-                "\n                                    embedded devices, and easily integrate with other languages.",
-            )),
-            Token::Text(String::from("\n                                    ")),
-            Token::EndTag(String::from("p")),
-            Token::TagClose,
-            Token::Text(String::from("\n                                ")),
-            Token::EndTag(String::from("section")),
-            Token::TagClose,
-            Token::Text(String::from("\n                            ")),
-            Token::EndTag(String::from("div")),
-            Token::TagClose,
-            Token::Text(String::from("\n                        ")),
-            Token::EndTag(String::from("div")),
-            Token::TagClose,
-            Token::Text(String::from("\n                    ")),
-            Token::EndTag(String::from("section")),
-            Token::TagClose,
-            Token::Text(String::from("\n                ")),
-            Token::EndTag(String::from("main")),
-            Token::TagClose,
-            Token::Text(String::from("\n                ")),
-            Token::StartTag(String::from("script")),
-            Token::Identifier(String::from("src")),
-            Token::AssignmentSign,
-            Token::Literal(String::from(
-                "./Rust Programming Language_files/languages.js.download",
-            )),
-            Token::TagCloseAndEnd,
-            Token::Text(String::from("\n            ")),
-            Token::EndTag(String::from("body")),
-            Token::TagClose,
-            Token::Text(String::from("\n        ")),
-            Token::EndTag(String::from("html")),
-            Token::TagClose,
-        ];
-
-        // looping makes debugging much easier than just asserting the entire vectors are equal
-        for (r, e) in result.into_iter().zip(expected) {
-            assert_eq!(r, e);
-        }
-    }
 }
diff --git a/src/lib.rs b/src/lib.rs
index 3e776bc..d7626e7 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -41,7 +41,7 @@
 //!
 //! // Compare the text of the first and only node returned by the XPath expression
 //! let node = items[0].extract_as_node().extract_as_tree_node();
-//! let text = node.text(&xpath_item_tree);
+//! let text = node.text(&xpath_item_tree).unwrap();
 //!
 //! assert_eq!(text, "Good info");
 //!
@@ -74,7 +74,7 @@
 //!
 //!     let items = result;
 //!     let node = items[0].extract_as_node().extract_as_tree_node();
-//!     Ok(node.text(&xpath_item_tree))
+//!     Ok(node.text(&xpath_item_tree).unwrap())
 //! }
 //!
 //! fn main() -> Result<(), Box<dyn Error>> {
diff --git a/src/xpath/grammar/expressions/comparison_expressions.rs b/src/xpath/grammar/expressions/comparison_expressions.rs
index e7e1c83..58a76b6 100644
--- a/src/xpath/grammar/expressions/comparison_expressions.rs
+++ b/src/xpath/grammar/expressions/comparison_expressions.rs
@@ -140,10 +140,10 @@ fn func_data<'tree>(
             XpathItem::Node(node) => match node {
                 Node::TreeNode(tree_node) => match tree_node.data {
                     XpathItemTreeNodeData::DocumentNode(_) => {
-                        AnyAtomicType::String(tree_node.text(item_tree))
+                        AnyAtomicType::String(tree_node.all_text(item_tree))
                     }
                     XpathItemTreeNodeData::ElementNode(_) => {
-                        AnyAtomicType::String(tree_node.text(item_tree))
+                        AnyAtomicType::String(tree_node.all_text(item_tree))
                     }
                     XpathItemTreeNodeData::PINode(_) => todo!("func_data PINode"),
                     XpathItemTreeNodeData::CommentNode(_) => todo!("func_data CommentNode"),
diff --git a/src/xpath/grammar/expressions/mod.rs b/src/xpath/grammar/expressions/mod.rs
index 8756c1b..77a3a00 100644
--- a/src/xpath/grammar/expressions/mod.rs
+++ b/src/xpath/grammar/expressions/mod.rs
@@ -125,7 +125,9 @@ impl Xpath {
             XpathItem::Node(Node::TreeNode(item_tree.root())),
             true,
         );
-        self.eval(&context)
+        let mut item_set = self.eval(&context)?;
+        item_set.sort();
+        Ok(item_set)
     }
 
     /// Apply the XPath expression to the given item.
@@ -143,7 +145,7 @@ impl Xpath {
     /// # Examples
     ///
     /// ```rust
-    /// use skyscraper::html;
+    /// use skyscraper::html::{self, trim_internal_whitespace};
     /// use skyscraper::xpath::{self, XpathItemTree, grammar::{XpathItemTreeNodeData, data_model::{Node, XpathItem}}};
     /// use std::error::Error;
     ///
@@ -178,7 +180,7 @@ impl Xpath {
     ///         .as_element_node()?;
     ///
     ///     assert_eq!(element.name, "span");
-    ///     assert_eq!(tree_node.text(&xpath_item_tree), "world");
+    ///     assert_eq!(trim_internal_whitespace(&tree_node.text(&xpath_item_tree).unwrap()), "world");
     ///     
     ///     Ok(())
     /// }
diff --git a/src/xpath/grammar/mod.rs b/src/xpath/grammar/mod.rs
index 6660f68..3d8e237 100644
--- a/src/xpath/grammar/mod.rs
+++ b/src/xpath/grammar/mod.rs
@@ -12,7 +12,7 @@ mod types;
 mod whitespace_recipes;
 mod xml_names;
 
-use std::fmt::Display;
+use std::{fmt::Display, iter};
 
 use enum_extract_macro::EnumExtract;
 pub(crate) use expressions::xpath;
@@ -130,7 +130,15 @@ impl<'a> XpathItemTreeNode<'a> {
     ///
     /// A string of all text contained in this node and its descendants.
     pub fn all_text(&self, tree: &'a XpathItemTree) -> String {
-        self.text_internal(tree, true)
+        let strings: Vec<String> =
+            // Get all children.
+            Self::get_all_text_nodes(tree, self, true)
+            .into_iter()
+            .map(|x| x.content)
+            .collect();
+
+        let text = strings.join("");
+        text
     }
 
     /// Get text directly contained in this node.
@@ -144,52 +152,103 @@ impl<'a> XpathItemTreeNode<'a> {
     /// # Returns
     ///
     /// A string of all text contained in this node.
-    pub fn text(&self, tree: &'a XpathItemTree) -> String {
-        self.text_internal(tree, false)
-    }
-
-    fn text_internal(&self, tree: &'a XpathItemTree, recurse: bool) -> String {
-        fn get_all_text_nodes(
-            tree: &XpathItemTree,
-            node: &XpathItemTreeNode,
-            recurse: bool,
-        ) -> Vec<TextNode> {
-            node
-                // Get all children of the given node.
-                .children(tree)
-                // Combine all the direct and indirect children into a Vec.
-                .fold(Vec::new(), |mut v, child| {
-                    // If this child is a text node, push it to the Vec.
-                    if let XpathItemTreeNodeData::TextNode(text) = child.data {
-                        v.push(text.clone());
-                    }
-                    // Otherwise, if this is a recursive search, get all the text nodes descending from this child.
-                    else if recurse {
-                        v.extend(get_all_text_nodes(tree, &child, recurse));
-                    }
-                    v
-                })
-        }
-
+    pub fn text(&self, tree: &XpathItemTree) -> Option<String> {
         let strings: Vec<String> =
             // Get all children.
-            get_all_text_nodes(tree, self, recurse)
+            Self::get_all_text_nodes(tree, self, false)
             .into_iter()
-            // Filter out all whitespace-only text nodes
-            .filter_map(|x| {
-                if x.only_whitespace {
-                    None
-                } else {
-                    Some(x.content)
+            .map(|x| x.content)
+            .collect();
+
+        strings.into_iter().next()
+    }
+
+    fn get_all_text_nodes(
+        tree: &XpathItemTree,
+        node: &XpathItemTreeNode,
+        recurse: bool,
+    ) -> Vec<TextNode> {
+        node
+            // Get all children of the given node.
+            .children(tree)
+            // Combine all the direct and indirect children into a Vec.
+            .fold(Vec::new(), |mut v, child| {
+                // If this child is a text node, push it to the Vec.
+                if let XpathItemTreeNodeData::TextNode(text) = child.data {
+                    v.push(text.clone());
+                }
+                // Otherwise, if this is a recursive search, get all the text nodes descending from this child.
+                else if recurse {
+                    v.extend(Self::get_all_text_nodes(tree, &child, recurse));
                 }
+                v
             })
-            .collect();
+    }
 
-        // Merge all text into a single string.
-        // Space delimited.
-        let text = strings.join(" ");
+    /// Get an iterator over all text contained in this node and its descendants.
+    ///
+    /// Includes whitespace text nodes.
+    /// Text nodes are split by opening and closing tags contained in the current node.
+    ///
+    /// ```rust
+    /// use skyscraper::{html, xpath};
+    ///
+    /// let html = r#"
+    ///     <div>
+    ///         <p>Good info</p>
+    ///         Ok info
+    ///         <p>Bad info</p>
+    ///    </div>"#;
+    ///
+    /// let document = html::parse(html).unwrap();
+    /// let xpath_item_tree = xpath::XpathItemTree::from(&document);
+    /// let xpath = xpath::parse("//div").unwrap();
+    ///
+    /// let nodes = xpath.apply(&xpath_item_tree).unwrap();
+    /// let mut nodes = nodes.into_iter();
+    /// let node = nodes.next().unwrap().extract_into_node().extract_into_tree_node();
+    ///
+    /// let text = node.itertext(&xpath_item_tree).collect::<Vec<String>>();
+    ///
+    /// assert_eq!(text, vec![
+    ///     "\n        ",                  // Whitespace between the opening div tag and the first p tag
+    ///     "Good info",                   // Text of the first p tag
+    ///     "\n        Ok info\n        ", // Text between the first and second p tags
+    ///     "Bad info",                    // Text of the second p tag
+    ///     "\n   "                        // Whitespace between the second p tag and the closing div tag
+    /// ]);
+    /// ```
+    pub fn itertext(self, tree: &'a XpathItemTree) -> TextIter<'a> {
+        TextIter::new(tree, self)
+    }
+}
 
-        text
+/// An iterator over all text contained in a node and its descendants.
+pub struct TextIter<'a> {
+    iter_chain: Box<dyn Iterator<Item = String> + 'a>,
+}
+
+impl<'a> TextIter<'a> {
+    pub(crate) fn new(tree: &'a XpathItemTree, node: XpathItemTreeNode<'a>) -> TextIter<'a> {
+        let mut iter_chain: Box<dyn Iterator<Item = String>> = Box::new(iter::empty());
+
+        for child in node.children(tree) {
+            if let XpathItemTreeNodeData::TextNode(text) = child.data {
+                iter_chain = Box::new(iter_chain.chain(iter::once(text.content.clone())));
+            } else {
+                iter_chain = Box::new(iter_chain.chain(TextIter::new(tree, child)));
+            }
+        }
+
+        TextIter { iter_chain }
+    }
+}
+
+impl<'a> Iterator for TextIter<'a> {
+    type Item = String;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.iter_chain.next()
     }
 }
 
@@ -219,6 +278,14 @@ impl XpathItemTree {
     fn root(&self) -> XpathItemTreeNode<'_> {
         self.get(self.root_node)
     }
+
+    /// Get an iterator over all nodes in the tree.
+    pub fn iter(&self) -> impl Iterator<Item = XpathItemTreeNode> {
+        self.arena.iter().map(|node| {
+            let id = self.arena.get_node_id(node).unwrap();
+            self.get(id)
+        })
+    }
 }
 
 impl From<&HtmlDocument> for XpathItemTree {
diff --git a/src/xpath/xpath_item_set.rs b/src/xpath/xpath_item_set.rs
index 57a6fcc..cc99f74 100644
--- a/src/xpath/xpath_item_set.rs
+++ b/src/xpath/xpath_item_set.rs
@@ -128,6 +128,10 @@ impl<'tree> XpathItemSet<'tree> {
             !self.index_set.is_empty()
         }
     }
+
+    pub(crate) fn sort(&mut self) {
+        self.index_set.sort();
+    }
 }
 
 impl<'tree> From<IndexSet<XpathItem<'tree>>> for XpathItemSet<'tree> {
diff --git a/tests/apply_to_item_tests.rs b/tests/apply_to_item_tests.rs
index 6f7b556..3f985a6 100644
--- a/tests/apply_to_item_tests.rs
+++ b/tests/apply_to_item_tests.rs
@@ -99,7 +99,7 @@ fn apply_to_item_slash_should_select_children() {
         let element = tree_node.data.extract_as_element_node();
         assert_eq!(element.name, "span");
 
-        assert_eq!(tree_node.text(&xpath_item_tree), "1");
+        assert_eq!(tree_node.text(&xpath_item_tree), Some("1".to_string()));
     }
 
     // assert node
@@ -113,7 +113,7 @@ fn apply_to_item_slash_should_select_children() {
         let element = tree_node.data.extract_as_element_node();
         assert_eq!(element.name, "span");
 
-        assert_eq!(tree_node.text(&xpath_item_tree), "2");
+        assert_eq!(tree_node.text(&xpath_item_tree), Some("2".to_string()));
     }
 
     // assert node
@@ -127,7 +127,7 @@ fn apply_to_item_slash_should_select_children() {
         let element = tree_node.data.extract_as_element_node();
         assert_eq!(element.name, "span");
 
-        assert_eq!(tree_node.text(&xpath_item_tree), "3");
+        assert_eq!(tree_node.text(&xpath_item_tree), Some("3".to_string()));
     }
 }
 
@@ -182,7 +182,7 @@ fn apply_to_item_double_slash_should_select_self_or_descendents() {
         let element = tree_node.data.extract_as_element_node();
         assert_eq!(element.name, "span");
 
-        assert_eq!(tree_node.text(&xpath_item_tree), "1");
+        assert_eq!(tree_node.text(&xpath_item_tree), Some("1".to_string()));
     }
 
     // assert node
@@ -196,7 +196,7 @@ fn apply_to_item_double_slash_should_select_self_or_descendents() {
         let element = tree_node.data.extract_as_element_node();
         assert_eq!(element.name, "span");
 
-        assert_eq!(tree_node.text(&xpath_item_tree), "2");
+        assert_eq!(tree_node.text(&xpath_item_tree), Some("2".to_string()));
     }
 
     // assert node
@@ -210,6 +210,6 @@ fn apply_to_item_double_slash_should_select_self_or_descendents() {
         let element = tree_node.data.extract_as_element_node();
         assert_eq!(element.name, "span");
 
-        assert_eq!(tree_node.text(&xpath_item_tree), "3");
+        assert_eq!(tree_node.text(&xpath_item_tree), Some("3".to_string()));
     }
 }
diff --git a/tests/github_sample_tests.rs b/tests/github_sample_tests.rs
index aa853e3..06df9f7 100644
--- a/tests/github_sample_tests.rs
+++ b/tests/github_sample_tests.rs
@@ -1,3 +1,4 @@
+use skyscraper::html::trim_internal_whitespace;
 use skyscraper::xpath::grammar::XpathItemTreeNode;
 use skyscraper::{html, xpath};
 
@@ -135,8 +136,9 @@ fn xpath_github_get_text_sample() {
         .extract_into_tree_node();
 
     let text = element.all_text(&xpath_item_tree).trim().to_string();
+    let trimmed_text = trim_internal_whitespace(&text);
 
-    assert_eq!(text, "James-LG / Skyscraper Public");
+    assert_eq!(trimmed_text, "James-LG / Skyscraper Public");
 }
 
 #[test]
diff --git a/tests/html_tests.rs b/tests/html_tests.rs
new file mode 100644
index 0000000..f34a465
--- /dev/null
+++ b/tests/html_tests.rs
@@ -0,0 +1,51 @@
+use skyscraper::html;
+
+#[test]
+fn text_should_include_text_before_between_and_after_child_element() {
+    // arrange
+    let text = r##"
+        <div>
+            hello
+            <span>my</span>
+            friend
+        </div>"##;
+
+    // act
+    let document = html::parse(text).unwrap();
+
+    // assert
+    let root_node = document.root_node;
+    let mut children = root_node.children(&document);
+
+    let child = children.next().unwrap();
+    let html_text = document.get_html_node(&child).unwrap().extract_as_text();
+    assert_eq!(html_text.value, "\n            hello\n            ");
+
+    let child = children.next().unwrap();
+    let html_text = document
+        .get_html_node(&child.children(&document).next().unwrap())
+        .unwrap()
+        .extract_as_text();
+    assert_eq!(html_text.value, "my");
+
+    let child = children.next().unwrap();
+    let html_text = document.get_html_node(&child).unwrap().extract_as_text();
+    assert_eq!(html_text.value, "\n            friend\n        ");
+}
+
+#[test]
+fn text_should_unescape_characters() {
+    // arrange
+    let text = r##"<div>&amp;&quot;&#39;&lt;&gt;</div>"##;
+
+    // act
+    let document = html::parse(text).unwrap();
+
+    // assert
+    let root_node = document.root_node;
+    let mut children = root_node.children(&document);
+
+    let child = children.next().unwrap();
+    let html_text = document.get_html_node(&child).unwrap().extract_as_text();
+    assert_eq!(html_text.value, r##"&"'<>"##);
+}
diff --git a/tests/lxml_tests.rs b/tests/lxml_tests.rs
new file mode 100644
index 0000000..3773b0e
--- /dev/null
+++ b/tests/lxml_tests.rs
@@ -0,0 +1,231 @@
+use std::{
+    collections::HashMap,
+    io::Write,
+    path::PathBuf,
+    process::{Command, Stdio},
+};
+
+use serde::Deserialize;
+use skyscraper::{
+    html::{self, HtmlNode},
+    xpath::{self, xpath_item_set::XpathItemSet, XpathItemTree},
+};
+
+#[derive(Deserialize, Debug, PartialEq)]
+struct LxmlElement {
+    pub tag: String,
+    pub text: Option<String>,
+    pub attrib: HashMap<String, String>,
+    pub itertext: Vec<String>,
+}
+
+fn get_lxml_elements(xpath: &str, html_text: String) -> Vec<LxmlElement> {
+    let mut lxml_python_path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    lxml_python_path.push("tests/lxml_tests/xpath.py");
+
+    let mut cmd = Command::new("python3")
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .arg(
+            lxml_python_path
+                .clone()
+                .into_os_string()
+                .into_string()
+                .unwrap(),
+        )
+        .arg(xpath)
+        .spawn()
+        .expect("failed to spawn process");
+
+    let mut stdin = cmd.stdin.take().expect("Failed to open stdin");
+    std::thread::spawn(move || {
+        stdin
+            .write_all(html_text.as_bytes())
+            .expect("Failed to write to stdin");
+    });
+
+    let output = cmd
+        .wait_with_output()
+        .expect("failed to execute stack overflow tests");
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    assert!(
+        output.status.success(),
+        "{}\n{}",
+        stdout,
+        String::from_utf8_lossy(&output.stderr)
+    );
+
+    let lxml_elements: Vec<LxmlElement> = serde_json::from_str(&stdout).unwrap();
+    return lxml_elements;
+}
+
+fn skyscraper_to_lxml_elements(
+    xpath_tree: &XpathItemTree,
+    item_set: XpathItemSet,
+) -> Vec<LxmlElement> {
+    let mut lxml_elements = Vec::new();
+    for item in item_set.into_iter() {
+        let node = item.extract_into_node();
+        let tree_node = node.extract_into_tree_node();
+        let element = tree_node.data.extract_as_element_node();
+        let text = tree_node.text(&xpath_tree);
+        let itertext = tree_node.itertext(&xpath_tree).collect();
+
+        lxml_elements.push(LxmlElement {
+            tag: element.name.to_string(),
+            text,
+            attrib: element
+                .attributes
+                .iter()
+                .map(|x| (x.name.clone(), x.value.clone()))
+                .collect(),
+            itertext,
+        });
+    }
+    return lxml_elements;
+}
+
+fn compare_skyscraper_to_lxml(
+    lxml_elements: Vec<LxmlElement>,
+    converted_skyscraper_elems: Vec<LxmlElement>,
+) {
+    for (i, (lxml_elem, skyscraper_elem)) in lxml_elements
+        .iter()
+        .zip(converted_skyscraper_elems.iter())
+        .enumerate()
+    {
+        assert_eq!(
+            lxml_elem.tag, skyscraper_elem.tag,
+            "Tag mismatch at index {}",
+            i
+        );
+        assert_eq!(
+            lxml_elem.text, skyscraper_elem.text,
+            "Text mismatch at index {}",
+            i
+        );
+        assert_eq!(
+            lxml_elem.attrib, skyscraper_elem.attrib,
+            "Attribute mismatch at index {}",
+            i
+        );
+        assert_eq!(
+            lxml_elem.itertext, skyscraper_elem.itertext,
+            "Itertext mismatch at index {}",
+            i
+        );
+    }
+    assert_eq!(converted_skyscraper_elems.len(), lxml_elements.len());
+}
+
+static GITHUB_HTML: &'static str = include_str!("samples/James-LG_Skyscraper.html");
+
+/// This test is a sanity check of the lxml output.
+#[test]
+fn test_lxml_output() {
+    // arrange
+    let html_text = GITHUB_HTML.to_string();
+    let xpath = r#"//a[@rel='author']"#;
+
+    // act
+    let lxml_elements = get_lxml_elements(xpath, html_text);
+
+    // assert
+    assert_eq!(lxml_elements.len(), 1);
+
+    let mut lxml_elements = lxml_elements.into_iter();
+    let lxml_element = lxml_elements.next().unwrap();
+    assert_eq!(lxml_element.tag, "a");
+    assert_eq!(lxml_element.text, Some("James-LG".to_string()));
+    assert_eq!(lxml_element.attrib["rel"], "author");
+}
+
+/// Selects a large block of text and checks that Skyscraper handles text the same as lxml.
+#[test]
+fn test_text_handling() {
+    // arrange
+    let html_text = GITHUB_HTML.to_string();
+    let xpath = r#"//div[@role='tabpanel']"#;
+
+    let html_document = html::parse(&html_text).unwrap();
+    let xpath_item_tree = XpathItemTree::from(&html_document);
+    let xpath_expr = xpath::parse(xpath).unwrap();
+
+    // act
+    let lxml_elements = get_lxml_elements(xpath, html_text);
+    let skyscraper_elements = xpath_expr.apply(&xpath_item_tree).unwrap();
+
+    // assert
+    let converted_skyscraper_elems =
+        skyscraper_to_lxml_elements(&xpath_item_tree, skyscraper_elements);
+
+    compare_skyscraper_to_lxml(lxml_elements, converted_skyscraper_elems);
+}
+
+#[test]
+fn test_text_handling2() {
+    // arrange
+    let html_text = GITHUB_HTML.to_string();
+    let xpath = r#"//h2"#;
+
+    let html_document = html::parse(&html_text).unwrap();
+    let xpath_item_tree = XpathItemTree::from(&html_document);
+    let xpath_expr = xpath::parse(xpath).unwrap();
+
+    // act
+    let lxml_elements = get_lxml_elements(xpath, html_text);
+    let skyscraper_elements = xpath_expr.apply(&xpath_item_tree).unwrap();
+
+    // assert
+    let converted_skyscraper_elems =
+        skyscraper_to_lxml_elements(&xpath_item_tree, skyscraper_elements);
+
+    compare_skyscraper_to_lxml(lxml_elements, converted_skyscraper_elems);
+}
+
+#[test]
+fn test_text_handling3() {
+    // arrange
+    let html_text = GITHUB_HTML.to_string();
+    let xpath = r#"//div"#;
+
+    let html_document = html::parse(&html_text).unwrap();
+    let xpath_item_tree = XpathItemTree::from(&html_document);
+    let xpath_expr = xpath::parse(xpath).unwrap();
+
+    // act
+    let lxml_elements = get_lxml_elements(xpath, html_text);
+    let skyscraper_elements = xpath_expr.apply(&xpath_item_tree).unwrap();
+
+    // assert
+    let converted_skyscraper_elems =
+        skyscraper_to_lxml_elements(&xpath_item_tree, skyscraper_elements);
+
+    compare_skyscraper_to_lxml(lxml_elements, converted_skyscraper_elems);
+}
+
+#[allow(dead_code)]
+fn debug_xpath_tree(xpath_item_tree: &XpathItemTree) {
+    let xpath_iter = xpath_item_tree.iter();
+    for node in xpath_iter {
+        if let Ok(element) = node.data.as_element_node() {
+            if element.name == "h2" {
+                println!("{:?}", node.itertext(&xpath_item_tree).collect::<Vec<_>>());
+            }
+        }
+    }
+}
+
+#[allow(dead_code)]
+fn debug_html(html_document: html::HtmlDocument) {
+    let html_iter = html_document.iter();
+    for node in html_iter {
+        let html_node = html_document.get_html_node(&node).unwrap();
+        if let HtmlNode::Tag(tag) = html_node {
+            if tag.name == "h2" {
+                println!("{:?}", tag.get_all_text(&node, &html_document));
+            }
+        }
+    }
+}
diff --git a/tests/lxml_tests/requirements.txt b/tests/lxml_tests/requirements.txt
new file mode 100644
index 0000000..74447b7
--- /dev/null
+++ b/tests/lxml_tests/requirements.txt
@@ -0,0 +1,7 @@
+jsons==1.6.3
+lxml==4.6.3
+mercurial==5.6.1
+Pygments==2.7.1
+PyYAML==5.3.1
+six==1.16.0
+typish==1.9.3
diff --git a/tests/lxml_tests/xpath.py b/tests/lxml_tests/xpath.py
new file mode 100644
index 0000000..cb64818
--- /dev/null
+++ b/tests/lxml_tests/xpath.py
@@ -0,0 +1,45 @@
+import jsons
+import argparse
+import sys
+import lxml.html
+
+class OutputElement:
+    def __init__(self, tag: str, text: str, attrib: dict[str, str], itertext: list[str]):
+        self.tag = tag
+        self.text = text
+        self.attrib = attrib
+        self.itertext = itertext
+    
+    def from_lxml_element(element: lxml.html.HtmlElement):
+        attributes = {}
+        for key, value in element.attrib.items():
+            attributes[key] = value
+
+        itertext = list(element.itertext())
+
+        return OutputElement(
+            tag=element.tag,
+            text=element.text,
+            attrib=attributes,
+            itertext=itertext
+        )
+
+def test_xpath():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("xpath", help="XPath to search for")
+
+    args = parser.parse_args()
+
+    html = ""
+    for line in sys.stdin:
+        html += line
+
+    tree = lxml.html.fromstring(html)
+    results = tree.xpath(args.xpath)
+
+    output_list = [OutputElement.from_lxml_element(result) for result in results]
+    output = jsons.dumps(output_list, jdkwargs={'indent':4})
+    print(output)
+
+if __name__ == "__main__":
+    test_xpath()
diff --git a/tests/path_tests.rs b/tests/path_tests.rs
index 73a62d5..17b66be 100644
--- a/tests/path_tests.rs
+++ b/tests/path_tests.rs
@@ -1,4 +1,7 @@
-use skyscraper::{html, xpath};
+use skyscraper::{
+    html::{self, trim_internal_whitespace},
+    xpath,
+};
 
 #[test]
 fn leading_slash_should_select_html_node() {
@@ -74,7 +77,7 @@ fn leading_double_slash_should_select_all() {
         let element = tree_node.data.extract_as_element_node();
         assert_eq!(element.name, "p");
 
-        assert_eq!(tree_node.text(&xpath_item_tree), "1");
+        assert_eq!(tree_node.text(&xpath_item_tree), Some("1".to_string()));
     }
 
     // assert node
@@ -88,7 +91,7 @@ fn leading_double_slash_should_select_all() {
         let element = tree_node.data.extract_as_element_node();
         assert_eq!(element.name, "p");
 
-        assert_eq!(tree_node.text(&xpath_item_tree), "2");
+        assert_eq!(tree_node.text(&xpath_item_tree), Some("2".to_string()));
     }
 
     // assert node
@@ -102,7 +105,7 @@ fn leading_double_slash_should_select_all() {
         let element = tree_node.data.extract_as_element_node();
         assert_eq!(element.name, "p");
 
-        assert_eq!(tree_node.text(&xpath_item_tree), "3");
+        assert_eq!(tree_node.text(&xpath_item_tree), Some("3".to_string()));
     }
 
     // assert node
@@ -116,7 +119,7 @@ fn leading_double_slash_should_select_all() {
         let element = tree_node.data.extract_as_element_node();
         assert_eq!(element.name, "p");
 
-        assert_eq!(tree_node.text(&xpath_item_tree), "4");
+        assert_eq!(tree_node.text(&xpath_item_tree), Some("4".to_string()));
     }
 
     // assert node
@@ -130,7 +133,7 @@ fn leading_double_slash_should_select_all() {
         let element = tree_node.data.extract_as_element_node();
         assert_eq!(element.name, "p");
 
-        assert_eq!(tree_node.text(&xpath_item_tree), "5");
+        assert_eq!(tree_node.text(&xpath_item_tree), Some("5".to_string()));
     }
 
     // assert node
@@ -144,7 +147,7 @@ fn leading_double_slash_should_select_all() {
         let element = tree_node.data.extract_as_element_node();
         assert_eq!(element.name, "p");
 
-        assert_eq!(tree_node.text(&xpath_item_tree), "6");
+        assert_eq!(tree_node.text(&xpath_item_tree), Some("6".to_string()));
     }
 }
 
@@ -193,7 +196,7 @@ fn double_slash_should_select_all() {
         let element = tree_node.data.extract_as_element_node();
         assert_eq!(element.name, "p");
 
-        assert_eq!(tree_node.text(&xpath_item_tree), "4");
+        assert_eq!(tree_node.text(&xpath_item_tree), Some("4".to_string()));
     }
 
     // assert node
@@ -207,7 +210,7 @@ fn double_slash_should_select_all() {
         let element = tree_node.data.extract_as_element_node();
         assert_eq!(element.name, "p");
 
-        assert_eq!(tree_node.text(&xpath_item_tree), "5");
+        assert_eq!(tree_node.text(&xpath_item_tree), Some("5".to_string()));
     }
 
     // assert node
@@ -221,7 +224,7 @@ fn double_slash_should_select_all() {
         let element = tree_node.data.extract_as_element_node();
         assert_eq!(element.name, "p");
 
-        assert_eq!(tree_node.text(&xpath_item_tree), "6");
+        assert_eq!(tree_node.text(&xpath_item_tree), Some("6".to_string()));
     }
 }
 
@@ -262,7 +265,7 @@ fn document_order_preserved_in_results() {
 
         assert_eq!(element_node.name, "span");
 
-        assert_eq!(tree_node.text(&xpath_item_tree), "1");
+        assert_eq!(tree_node.text(&xpath_item_tree), Some("1".to_string()));
     }
 
     // assert node
@@ -277,7 +280,10 @@ fn document_order_preserved_in_results() {
 
         assert_eq!(element_node.name, "span");
 
-        assert_eq!(tree_node.text(&xpath_item_tree), "2");
+        assert_eq!(
+            trim_internal_whitespace(&tree_node.text(&xpath_item_tree).unwrap()),
+            "2"
+        );
     }
 
     // assert node
@@ -292,6 +298,9 @@ fn document_order_preserved_in_results() {
 
         assert_eq!(element_node.name, "span");
 
-        assert_eq!(tree_node.text(&xpath_item_tree), "3");
+        assert_eq!(
+            trim_internal_whitespace(&tree_node.text(&xpath_item_tree).unwrap()),
+            "3"
+        );
     }
 }
diff --git a/tests/predicate_tests.rs b/tests/predicate_tests.rs
index 5732d64..3c3cc37 100644
--- a/tests/predicate_tests.rs
+++ b/tests/predicate_tests.rs
@@ -1,4 +1,7 @@
-use skyscraper::{html, xpath};
+use skyscraper::{
+    html::{self, trim_internal_whitespace},
+    xpath,
+};
 
 #[test]
 fn class_equals_predicate_should_select_nodes_with_that_match() {
@@ -35,7 +38,10 @@ fn class_equals_predicate_should_select_nodes_with_that_match() {
         let element = tree_node.data.extract_as_element_node();
         assert_eq!(element.name, "div");
 
-        assert_eq!(tree_node.text(&xpath_item_tree).trim(), "good");
+        assert_eq!(
+            trim_internal_whitespace(&tree_node.text(&xpath_item_tree).unwrap()),
+            "good"
+        );
     }
 }
 
@@ -74,7 +80,10 @@ fn predicate_on_double_leading_slash_should_select_nodes_with_that_match() {
         let element = tree_node.data.extract_as_element_node();
         assert_eq!(element.name, "div");
 
-        assert_eq!(tree_node.text(&xpath_item_tree).trim(), "good");
+        assert_eq!(
+            trim_internal_whitespace(&tree_node.text(&xpath_item_tree).unwrap()),
+            "good"
+        );
     }
 }
 
@@ -117,7 +126,10 @@ fn index_should_select_indexed_child_for_all_selected_parents() {
         let element = tree_node.data.extract_as_element_node();
         assert_eq!(element.name, "p");
 
-        assert_eq!(tree_node.text(&xpath_item_tree).trim(), "2");
+        assert_eq!(
+            trim_internal_whitespace(&tree_node.text(&xpath_item_tree).unwrap()),
+            "2"
+        );
     }
 
     // assert node
@@ -131,7 +143,10 @@ fn index_should_select_indexed_child_for_all_selected_parents() {
         let element = tree_node.data.extract_as_element_node();
         assert_eq!(element.name, "p");
 
-        assert_eq!(tree_node.text(&xpath_item_tree).trim(), "5");
+        assert_eq!(
+            trim_internal_whitespace(&tree_node.text(&xpath_item_tree).unwrap()),
+            "5"
+        );
     }
 }
 
@@ -174,6 +189,9 @@ fn index_out_of_bounds_should_select_nothing_for_parent() {
         let element = tree_node.data.extract_as_element_node();
         assert_eq!(element.name, "p");
 
-        assert_eq!(tree_node.text(&xpath_item_tree).trim(), "2");
+        assert_eq!(
+            trim_internal_whitespace(&tree_node.text(&xpath_item_tree).unwrap()),
+            "2"
+        );
     }
 }