             XCTAssert(item?.number == index + 1)
         }
     }
+
+
+    // Scenario 5:
+    // ===========
+    //
+    //  Line 1:       [Text]            1 [Text]
+    //  Line 2:       [Text]            2 [Text]
+    //  Line 3:     - [Text]    > > >   - [Text]
+    //  Line 4:       [Text]            1 [Text]
+    //  Line 5:       [Text]            2 [Text]
+    //
+    // Toggling "Ordered List" on lines 1-5 creates new lists on the selected paragraphs, skipping any lists
+    // that don't match the new style.
+    //
+    func testToggleOrderedListOnParagraphIntersectingUnorderedListEffectivelySkipsListWithNoMatchingStyle() {
+        let string = NSMutableAttributedString(string: plainText)
+        let formatter = TextListFormatter()
+
+        // Line 3 > Unordered List
+        let ranges = paragraphRanges(inString: string)
+        formatter.toggleList(ofStyle: .Unordered, inString: string, atRange: ranges[2])
+
+        // Entire Text > Ordered List
+        formatter.toggleList(ofStyle: .Ordered, inString: string, atRange: string.rangeOfEntireString)
+
+        // Verify
+        let paragraphs = paragraphRanges(inString: string)
+        for (index, range) in paragraphs.enumerate() {
+            guard let list = string.textListAttribute(spanningRange: range),
+                let item = string.textListItemAttribute(spanningRange: range) else
+            {
+                XCTFail()
+                return
+            }
+
+            if index == 2 {
+                XCTAssert(list.style == .Unordered)
+                continue
+            }
+
+            // Map (0, 1) > (1, 2) and (3, 4) > (1, 2)
+            let number = (index < 2) ? (index + 1) : (index - 2)
+            XCTAssert(item.number == number)
+            XCTAssert(list.style == .Ordered)
+        }
+    }
+
+
+    // Scenario 6:
+    // ===========
+    //
+    //  Line 1:     - [Text]              [Text]
+    //  Line 2:     1 [Text]              [Text]
+    //  Line 3:     - [Text]    > > >     [Text]
+    //  Line 4:     1 [Text]              [Text]
+    //  Line 5:     - [Text]              [Text]
+    //
+    // Toggling "Unordered List" on Lines 1-5 should remove all of the lists / items.
+    //
+    func testToggleListRemovesAllOfTheListAttributesWhenTheFirstParagraphListStyleMatchesTheSuppliedStyle() {
+        let list = listWithAlternatedStyle
+
+        // Toggle Ordered List on the full string's range
+        let formatter = TextListFormatter()
+        formatter.toggleList(ofStyle: .Unordered, inString: list, atRange: list.rangeOfEntireString)
+
+        // Verify we got a single big orderedList
+        let ranges = paragraphRanges(inString: list)
+        let lists = textListAttributes(inString: list, atRanges: ranges)
+        let items = textListItemAttributes(inString: list, atRanges: ranges)
+
+        XCTAssert(lists.count == 0)
+        XCTAssert(items.count == 0)
+    }
 }
 
 

        XCTAssert(items[3].number == 1)
    }

    // Scenario 4:
    // ===========
    //
    //  Line 1:     - [Text]              [Text]
    //  Line 2:     1 [Text]              [Text]
    //  Line 3:     - [Text]    > > >     [Text]
    //  Line 4:     1 [Text]              [Text]
    //  Line 5:     - [Text]              [Text]
    //
    // Toggling "Unordered List" on Lines 1-5 should remove all of the lists / items.
    //
    func testToggleListRemovesAllOfTheListAttributesWhenTheFirstRangeStyleMatchesTheSuppliedStyle() {
        let list = listWithAlternatedStyle

        // Toggle Ordered List on the full string's range
        let formatter = TextListFormatter()
        formatter.toggleList(ofStyle: .Unordered, inString: list, atRange: list.rangeOfEntireString)

        // Verify we got a single big orderedList
        let ranges = paragraphRanges(inString: list)
        let lists = textListAttributes(inString: list, atRanges: ranges)
        let items = textListItemAttributes(inString: list, atRanges: ranges)

        XCTAssert(lists.count == 0)
        XCTAssert(items.count == 0)
    }

    // Scenario 5:
    // ===========
    //
    //  Line 1:     1 [Text]              [Text]
    //  Line 2:     2 [Text]            1 [Text]
    //  Line 3:     3 [Text]    > > >   2 [Text]
    //  Line 4:     4 [Text]            3 [Text]
    //  Line 5:     5 [Text]            4 [Text]
    //
    // Toggling "Ordered List" on Line 1 should update Line 2-5.
    //
    func testToggleOrderedListOnFirstOrderedListItemUpdatesTheRemainingItemNumbers() {
        let list = listWithOrderedStyle
        let ranges = paragraphRanges(inString: list)

        let formatter = TextListFormatter()
        formatter.toggleList(ofStyle: .Ordered, inString: list, atRange: ranges[0])

        let lists = textListAttributes(inString: list, atRanges: ranges)
        let items = textListItemAttributes(inString: list, atRanges: ranges)

        XCTAssert(lists.count == 4)
        XCTAssert(items.count == 4)

        for list in lists {
            XCTAssert(list.style == .Ordered)
        }

        for (index, item) in items.enumerate() {
            XCTAssert(item.number == index + 1)
        }
    }

    // Scenario 6:
    // ===========
    //
    //  Line 1:     1 [Text]            - [Text]
    //  Line 2:     2 [Text]            - [Text]
    //  Line 3:     3 [Text]    > > >   - [Text]
    //  Line 4:     4 [Text]            - [Text]
    //  Line 5:     5 [Text]            - [Text]
    //
    // Toggling "Unordered List" on Line 1 should switch everything to an Unordered List
    //
    func testToggleUnorderedListOnFirstOrderedListItemUpdatesTheRemainingItemNumbers() {
        let list = listWithOrderedStyle
        let ranges = paragraphRanges(inString: list)

        let formatter = TextListFormatter()
        formatter.toggleList(ofStyle: .Unordered, inString: list, atRange: ranges[0])

        let lists = textListAttributes(inString: list, atRanges: ranges)
        let items = textListItemAttributes(inString: list, atRanges: ranges)

        XCTAssert(lists.count == 5)
        XCTAssert(items.count == 5)

        XCTAssert(lists[0].style == .Unordered)
        XCTAssert(lists[1].style == .Unordered)
        XCTAssert(lists[2].style == .Unordered)
        XCTAssert(lists[3].style == .Unordered)
        XCTAssert(lists[4].style == .Unordered)
    }

    // Scenario 7:
    // ===========
    //
    //  Line 1:       [Text]            1 [Text]

    //  Line 4:     1 [Text]            1 [Text]
    //  Line 5:     - [Text]            - [Text]
    //
    // Toggling "Ordered List" on Line 1 should switch the list to which it's associated. Since the
    // "lower" neighbor has the same type, they should be merged.
    //
    func testToggleOrderedListOnFirstItem() {
        let list = listWithAlternatedStyle
