|
|
@@ -13,64 +13,64 @@ import XCTest
|
|
|
@testable import XML
|
|
|
|
|
|
class XMLTests: XCTestCase {
|
|
|
-
|
|
|
+
|
|
|
// MARK: - Properties
|
|
|
-
|
|
|
+
|
|
|
var exampleDocument = Document()
|
|
|
var plantsDocument = Document()
|
|
|
-
|
|
|
+
|
|
|
// MARK: - Helpers
|
|
|
-
|
|
|
+
|
|
|
func URLForResource(fileName: String, withExtension ext: String) -> URL {
|
|
|
guard let url = Bundle.module.url(forResource: fileName, withExtension: ext) else {
|
|
|
fatalError("can't find resource named: '\(fileName)'")
|
|
|
}
|
|
|
return url
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
func xmlDocumentFromURL(url: URL) -> Document {
|
|
|
var xmlDocument = Document()
|
|
|
-
|
|
|
+
|
|
|
do {
|
|
|
- let data = try Data.init(contentsOf: url)
|
|
|
+ let data = try Data(contentsOf: url)
|
|
|
xmlDocument = try Document(xml: data)
|
|
|
} catch {
|
|
|
print(error)
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
return xmlDocument
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
func readXMLFromFile(filename: String) -> Document {
|
|
|
let url = URLForResource(fileName: filename, withExtension: "xml")
|
|
|
return xmlDocumentFromURL(url: url)
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
// MARK: - Setup & Teardown
|
|
|
-
|
|
|
+
|
|
|
override func setUp() {
|
|
|
super.setUp()
|
|
|
-
|
|
|
+
|
|
|
// create some sample xml documents
|
|
|
exampleDocument = readXMLFromFile(filename: "example")
|
|
|
plantsDocument = readXMLFromFile(filename: "plant_catalog")
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
override func tearDown() {
|
|
|
// reset sample xml document
|
|
|
exampleDocument = Document()
|
|
|
plantsDocument = Document()
|
|
|
-
|
|
|
+
|
|
|
super.tearDown()
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
// MARK: - XML Document
|
|
|
-
|
|
|
+
|
|
|
func testXMLDocumentManualDataLoading() {
|
|
|
do {
|
|
|
let url = URLForResource(fileName: "example", withExtension: "xml")
|
|
|
- let data = try Data.init(contentsOf: url)
|
|
|
-
|
|
|
+ let data = try Data(contentsOf: url)
|
|
|
+
|
|
|
let testDocument = Document()
|
|
|
try testDocument.load(data)
|
|
|
XCTAssertEqual(testDocument.root.name, "animals", "Should be able to find root element.")
|
|
|
@@ -78,7 +78,7 @@ class XMLTests: XCTestCase {
|
|
|
XCTFail("Should be able to load XML Document with given Data.")
|
|
|
}
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
func testXMLDocumentInitFromString() {
|
|
|
do {
|
|
|
let testDocument = try Document(xml: exampleDocument.xml)
|
|
|
@@ -87,66 +87,69 @@ class XMLTests: XCTestCase {
|
|
|
XCTFail("Should be able to initialize XML Document from XML String.")
|
|
|
}
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
func testXMLOptions() {
|
|
|
do {
|
|
|
var options = Options()
|
|
|
options.documentHeader.version = 2.0
|
|
|
options.documentHeader.encoding = "utf-16"
|
|
|
options.documentHeader.standalone = "yes"
|
|
|
-
|
|
|
+
|
|
|
let testDocument = try Document(xml: "<foo><bar>hello</bar></foo>", options: options)
|
|
|
- XCTAssertEqual(testDocument.xml, "<?xml version=\"2.0\" encoding=\"utf-16\" standalone=\"yes\"?>\n<foo>\n\t<bar>hello</bar>\n</foo>")
|
|
|
+ XCTAssertEqual(
|
|
|
+ testDocument.xml,
|
|
|
+ "<?xml version=\"2.0\" encoding=\"utf-16\" standalone=\"yes\"?>\n<foo>\n\t<bar>hello</bar>\n</foo>"
|
|
|
+ )
|
|
|
XCTAssertEqual(try testDocument.root.bar.first?.get(), "hello")
|
|
|
} catch {
|
|
|
XCTFail("Should be able to initialize XML Document with custom Options.")
|
|
|
}
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
func testXMLParser() {
|
|
|
do {
|
|
|
let testDocument = Document()
|
|
|
let url = URLForResource(fileName: "example", withExtension: "xml")
|
|
|
- let data = try Data.init(contentsOf: url)
|
|
|
-
|
|
|
+ let data = try Data(contentsOf: url)
|
|
|
+
|
|
|
let parser = Parser(document: testDocument, data: data)
|
|
|
try parser.parse()
|
|
|
-
|
|
|
+
|
|
|
XCTAssertEqual(testDocument.root.name, "animals", "Should be able to find root element.")
|
|
|
} catch {
|
|
|
XCTFail("Should be able to parse XML Data into XML Document without throwing error.")
|
|
|
}
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
func testXMLParserTrimsWhitespace() {
|
|
|
let result = whitespaceResult(shouldTrimWhitespace: true)
|
|
|
XCTAssertEqual(result, "Hello,")
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
func testXMLParserWithoutTrimmingWhitespace() {
|
|
|
let result = whitespaceResult(shouldTrimWhitespace: false)
|
|
|
XCTAssertEqual(result, "Hello, ")
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
private func whitespaceResult(shouldTrimWhitespace: Bool) -> String? {
|
|
|
do {
|
|
|
var options = Options()
|
|
|
options.parserSettings.shouldTrimWhitespace = shouldTrimWhitespace
|
|
|
-
|
|
|
+
|
|
|
let testDocument = Document(options: options)
|
|
|
let url = URLForResource(fileName: "whitespace_examples", withExtension: "xml")
|
|
|
- let data = try Data.init(contentsOf: url)
|
|
|
-
|
|
|
+ let data = try Data(contentsOf: url)
|
|
|
+
|
|
|
let parser = Parser(document: testDocument, data: data)
|
|
|
try parser.parse()
|
|
|
-
|
|
|
+
|
|
|
return testDocument.root.text.first?.value
|
|
|
} catch {
|
|
|
XCTFail("Should be able to parse XML without throwing an error")
|
|
|
}
|
|
|
return nil
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
func testXMLParserError() {
|
|
|
do {
|
|
|
let testDocument = Document()
|
|
|
@@ -157,21 +160,21 @@ class XMLTests: XCTestCase {
|
|
|
XCTAssertEqual(error.localizedDescription, XMLError.parsingFailed.localizedDescription)
|
|
|
}
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
// MARK: - XML Read
|
|
|
-
|
|
|
+
|
|
|
func testRootElement() {
|
|
|
XCTAssertEqual(exampleDocument.root.name, "animals", "Should be able to find root element.")
|
|
|
-
|
|
|
+
|
|
|
let documentWithoutRootElement = Document()
|
|
|
let rootElement = documentWithoutRootElement.root
|
|
|
XCTAssertEqual(rootElement.error, XMLError.rootElementMissing, "Should have RootElementMissing error.")
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
func testParentElement() {
|
|
|
XCTAssertEqual(exampleDocument.root.cats.parent?.name, "animals", "Should be able to find parent element.")
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
func testChildrenElements() {
|
|
|
var count = 0
|
|
|
for _ in exampleDocument.root.cats.children {
|
|
|
@@ -179,31 +182,31 @@ class XMLTests: XCTestCase {
|
|
|
}
|
|
|
XCTAssertEqual(count, 4, "Should be able to iterate children elements")
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
func testName() {
|
|
|
let secondChildElementName = exampleDocument.root.children[1].name
|
|
|
XCTAssertEqual(secondChildElementName, "dogs", "Should be able to return element name.")
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
func testAttributes() {
|
|
|
let firstCatAttributes = exampleDocument.root.cats.cat.attributes
|
|
|
XCTAssertEqual(firstCatAttributes["breed"], "Siberian", "Should be able to return attribute value.")
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
func testValue() {
|
|
|
let firstPlant = plantsDocument.root.PLANT
|
|
|
XCTAssertEqual(firstPlant.COMMON, "Bloodroot", "Should be able to return element value as optional string.")
|
|
|
XCTAssertNil(firstPlant.ELEMENTWITHOUTVALUE.value, "Should be able to have nil value.")
|
|
|
XCTAssertNil(firstPlant.EMPTYELEMENT.value, "Should be able to have nil value.")
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
func testStringValue() {
|
|
|
let firstPlant = plantsDocument.root.PLANT
|
|
|
XCTAssertEqual(firstPlant.COMMON.value, "Bloodroot", "Should be able to return element value as string.")
|
|
|
XCTAssertNil(firstPlant.ELEMENTWITHOUTVALUE.value, "Should be able to return nil if element has no value.")
|
|
|
XCTAssertNil(firstPlant.EMPTYELEMENT.value, "Should be able to return nil if element has no value.")
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
func testBoolValue() {
|
|
|
XCTAssertEqual(plantsDocument.root.PLANT.TRUESTRING, true, "Should be able to cast element value as Bool.")
|
|
|
XCTAssertEqual(plantsDocument.root.PLANT.FALSESTRING, false, "Should be able to cast element value as Bool.")
|
|
|
@@ -211,23 +214,39 @@ class XMLTests: XCTestCase {
|
|
|
// XCTAssertEqual(plantsDocument.root.PLANT.FALSESTRING2, false, "Should be able to cast element value as Bool.")
|
|
|
// XCTAssertEqual(plantsDocument.root.PLANT.TRUEINT, true, "Should be able to cast element value as Bool.")
|
|
|
// XCTAssertEqual(plantsDocument.root.PLANT.FALSEINT, false, "Should be able to cast element value as Bool.")
|
|
|
- XCTAssertNil(plantsDocument.root.ELEMENTWITHOUTVALUE as Bool?, "Should be able to return nil if value can't be represented as Bool.")
|
|
|
+ XCTAssertNil(
|
|
|
+ plantsDocument.root.ELEMENTWITHOUTVALUE as Bool?,
|
|
|
+ "Should be able to return nil if value can't be represented as Bool."
|
|
|
+ )
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
func testIntValue() throws {
|
|
|
XCTAssertEqual(plantsDocument.root.PLANT.ZONE, 4, "Should be able to cast element value as Integer.")
|
|
|
- XCTAssertNil(plantsDocument.root.PLANT.ELEMENTWITHOUTVALUE as Int?, "Should be able to return nil if value can't be represented as Integer.")
|
|
|
+ XCTAssertNil(
|
|
|
+ plantsDocument.root.PLANT.ELEMENTWITHOUTVALUE as Int?,
|
|
|
+ "Should be able to return nil if value can't be represented as Integer."
|
|
|
+ )
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
func testDoubleValue() throws {
|
|
|
XCTAssertEqual(plantsDocument.root.PLANT.PRICE, 2.44, "Should be able to cast element value as Double.")
|
|
|
- XCTAssertNil(plantsDocument.root.PLANT.ELEMENTWITHOUTVALUE as Double?, "Should be able to return nil if value can't be represented as Double.")
|
|
|
+ XCTAssertNil(
|
|
|
+ plantsDocument.root.PLANT.ELEMENTWITHOUTVALUE as Double?,
|
|
|
+ "Should be able to return nil if value can't be represented as Double."
|
|
|
+ )
|
|
|
}
|
|
|
|
|
|
func testNotExistingElement() throws {
|
|
|
// non-optional
|
|
|
- XCTAssertNotNil(exampleDocument.root.ducks.duck.error, "Should contain error inside element which does not exist.")
|
|
|
- XCTAssertEqual(exampleDocument.root.ducks.duck.error, XMLError.elementNotFound, "Should have ElementNotFound error.")
|
|
|
+ XCTAssertNotNil(
|
|
|
+ exampleDocument.root.ducks.duck.error,
|
|
|
+ "Should contain error inside element which does not exist."
|
|
|
+ )
|
|
|
+ XCTAssertEqual(
|
|
|
+ exampleDocument.root.ducks.duck.error,
|
|
|
+ XMLError.elementNotFound,
|
|
|
+ "Should have ElementNotFound error."
|
|
|
+ )
|
|
|
XCTAssertNil(exampleDocument.root.ducks.duck.value, "Should have empty value.")
|
|
|
XCTAssertNil(exampleDocument.root.ducks.duck.first, "Should not be able to find ducks here.")
|
|
|
}
|
|
|
@@ -242,22 +261,30 @@ class XMLTests: XCTestCase {
|
|
|
}
|
|
|
XCTAssertEqual(count, 4, "Should be able to iterate all elements")
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
func testFirstElement() throws {
|
|
|
let catElement = exampleDocument.root.cats.cat
|
|
|
let firstCatExpectedValue = "Tinna"
|
|
|
-
|
|
|
+
|
|
|
// non-optional
|
|
|
- XCTAssertEqual(try catElement.get(), firstCatExpectedValue, "Should be able to find the first element as non-optional.")
|
|
|
-
|
|
|
+ XCTAssertEqual(
|
|
|
+ try catElement.get(),
|
|
|
+ firstCatExpectedValue,
|
|
|
+ "Should be able to find the first element as non-optional."
|
|
|
+ )
|
|
|
+
|
|
|
// optional
|
|
|
if let cat = catElement.first {
|
|
|
- XCTAssertEqual(try cat.get(), firstCatExpectedValue, "Should be able to find the first element as optional.")
|
|
|
+ XCTAssertEqual(
|
|
|
+ try cat.get(),
|
|
|
+ firstCatExpectedValue,
|
|
|
+ "Should be able to find the first element as optional."
|
|
|
+ )
|
|
|
} else {
|
|
|
XCTFail("Should be able to find the first element.")
|
|
|
}
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
func testLastElement() throws {
|
|
|
if let dog = exampleDocument.root.dogs.dog.last {
|
|
|
XCTAssertEqual(try dog.get(), "Kika", "Should be able to find the last element.")
|
|
|
@@ -265,16 +292,16 @@ class XMLTests: XCTestCase {
|
|
|
XCTFail("Should be able to find the last element.")
|
|
|
}
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
func testCountElements() {
|
|
|
let dogsCount = exampleDocument.root.dogs.dog.count
|
|
|
XCTAssertEqual(dogsCount, 4, "Should be able to count elements.")
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
func testAllWithValue() {
|
|
|
let cats = exampleDocument.root.cats
|
|
|
cats.addChild(name: "cat", value: "Tinna")
|
|
|
-
|
|
|
+
|
|
|
var count = 0
|
|
|
if let tinnas = cats["cat"].all(withValue: "Tinna") {
|
|
|
for _ in tinnas {
|
|
|
@@ -283,17 +310,17 @@ class XMLTests: XCTestCase {
|
|
|
}
|
|
|
XCTAssertEqual(count, 2, "Should be able to return elements with given value.")
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
func testAllWithAttributes() {
|
|
|
var count = 0
|
|
|
- if let bulls = exampleDocument.root.dogs.dog.all(withAttributes: ["color" : "white"]) {
|
|
|
+ if let bulls = exampleDocument.root.dogs.dog.all(withAttributes: ["color": "white"]) {
|
|
|
for _ in bulls {
|
|
|
count += 1
|
|
|
}
|
|
|
}
|
|
|
XCTAssertEqual(count, 2, "Should be able to return elements with given attributes.")
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
func testAllContainingAttributes() {
|
|
|
var count = 0
|
|
|
if let bulls = exampleDocument.root.dogs.dog.all(containingAttributeKeys: ["gender"]) {
|
|
|
@@ -303,66 +330,80 @@ class XMLTests: XCTestCase {
|
|
|
}
|
|
|
XCTAssertEqual(count, 2, "Should be able to return elements with given attribute keys.")
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
func testAllDescendantsWherePredicate() {
|
|
|
let children = exampleDocument.allDescendants { $0.attributes["color"] == "yellow" }
|
|
|
-
|
|
|
+
|
|
|
XCTAssertEqual(children.count, 2, "Should be able to return elements matching predicate.")
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
func testFirstDescendantWherePredicate() {
|
|
|
- let descendant = plantsDocument.root.firstDescendant { $0.hasDescendant { $0.name == "LIGHT" && $0.value == "Sunny" } }
|
|
|
+ let descendant = plantsDocument.root
|
|
|
+ .firstDescendant { $0.hasDescendant { $0.name == "LIGHT" && $0.value == "Sunny" } }
|
|
|
let plantName = descendant?["COMMON"].value
|
|
|
-
|
|
|
+
|
|
|
XCTAssertEqual(plantName, "Black-Eyed Susan", "Should be able to find first child satisfying predicate.")
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
func testHasDescendantWherePredicate() throws {
|
|
|
let hasDescendant = plantsDocument.hasDescendant { $0.name == "AVAILABILITY" && $0.value == "030699" }
|
|
|
XCTAssert(hasDescendant, "Should be able to determine that document has a child satisfying predicate.")
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
func testSpecialCharacterTrimRead() {
|
|
|
- let expected = "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?>\n<elements>\n\t<string name=\"this_and_that\">This & that</string>\n</elements>"
|
|
|
-
|
|
|
+ let expected =
|
|
|
+ "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?>\n<elements>\n\t<string name=\"this_and_that\">This & that</string>\n</elements>"
|
|
|
+
|
|
|
let readerDocument = try! Document(xml: expected)
|
|
|
let readerXml = readerDocument.xml
|
|
|
XCTAssertEqual(readerXml, expected, "Should be able to print XML formatted string.")
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
// MARK: - XML Write
|
|
|
-
|
|
|
+
|
|
|
func testAddChild() throws {
|
|
|
let ducks = exampleDocument.root.addChild(name: "ducks")
|
|
|
ducks.addChild(name: "duck", value: "Donald")
|
|
|
ducks.addChild(name: "duck", value: "Daisy")
|
|
|
ducks.addChild(name: "duck", value: "Scrooge")
|
|
|
-
|
|
|
+
|
|
|
let animalsCount = exampleDocument.root.children.count
|
|
|
XCTAssertEqual(animalsCount, 3, "Should be able to add child elements to an element.")
|
|
|
- XCTAssertEqual(try exampleDocument.root["ducks"]["duck"].last?.get(), "Scrooge", "Should be able to iterate ducks now.")
|
|
|
+ XCTAssertEqual(
|
|
|
+ try exampleDocument.root["ducks"]["duck"].last?.get(),
|
|
|
+ "Scrooge",
|
|
|
+ "Should be able to iterate ducks now."
|
|
|
+ )
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
func testAddChildWithAttributes() throws {
|
|
|
let cats = exampleDocument.root.cats
|
|
|
let dogs = exampleDocument.root.dogs
|
|
|
-
|
|
|
- cats.addChild(name: "cat", value: "Garfield", attributes: ["breed" : "tabby", "color" : "orange"])
|
|
|
- dogs.addChild(name: "dog", value: "Snoopy", attributes: ["breed" : "beagle", "color" : "white"])
|
|
|
-
|
|
|
+
|
|
|
+ cats.addChild(name: "cat", value: "Garfield", attributes: ["breed": "tabby", "color": "orange"])
|
|
|
+ dogs.addChild(name: "dog", value: "Snoopy", attributes: ["breed": "beagle", "color": "white"])
|
|
|
+
|
|
|
let catsCount = cats["cat"].count
|
|
|
let dogsCount = dogs["dog"].count
|
|
|
-
|
|
|
+
|
|
|
let lastCat = cats["cat"].last!
|
|
|
let penultDog = dogs.children[3]
|
|
|
-
|
|
|
+
|
|
|
XCTAssertEqual(catsCount, 5, "Should be able to add child element with attributes to an element.")
|
|
|
XCTAssertEqual(dogsCount, 5, "Should be able to add child element with attributes to an element.")
|
|
|
-
|
|
|
- XCTAssertEqual(lastCat.attributes["color"], "orange", "Should be able to get attribute value from added element.")
|
|
|
- XCTAssertEqual(try penultDog.get(), "Kika", "Should be able to add child with attributes without overwrites existing elements. (Github Issue #28)")
|
|
|
+
|
|
|
+ XCTAssertEqual(
|
|
|
+ lastCat.attributes["color"],
|
|
|
+ "orange",
|
|
|
+ "Should be able to get attribute value from added element."
|
|
|
+ )
|
|
|
+ XCTAssertEqual(
|
|
|
+ try penultDog.get(),
|
|
|
+ "Kika",
|
|
|
+ "Should be able to add child with attributes without overwrites existing elements. (Github Issue #28)"
|
|
|
+ )
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
func testAddChildren() {
|
|
|
let animals: [Element] = [
|
|
|
Element(name: "dinosaurs"),
|
|
|
@@ -370,68 +411,83 @@ class XMLTests: XCTestCase {
|
|
|
Element(name: "bugs"),
|
|
|
]
|
|
|
exampleDocument.root.addChildren(animals)
|
|
|
-
|
|
|
+
|
|
|
let animalsCount = exampleDocument.root.children.count
|
|
|
XCTAssertEqual(animalsCount, 5, "Should be able to add children elements to an element.")
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
func testAddAttributes() {
|
|
|
let firstCat = exampleDocument.root.cats.cat
|
|
|
|
|
|
firstCat.attributes["funny"] = "true"
|
|
|
firstCat.attributes["speed"] = "fast"
|
|
|
firstCat.attributes["years"] = "7"
|
|
|
-
|
|
|
+
|
|
|
XCTAssertEqual(firstCat.attributes.count, 5, "Should be able to add attributes to an element.")
|
|
|
XCTAssertEqual(Int(firstCat.attributes["years"]!), 7, "Should be able to get any attribute value now.")
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
func testRemoveChild() throws {
|
|
|
let cats = exampleDocument.root.cats
|
|
|
let lastCat = cats["cat"].last!
|
|
|
- let duplicateCat = cats.addChild(name: "cat", value: "Tinna", attributes: ["breed" : "Siberian", "color" : "lightgray"])
|
|
|
-
|
|
|
+ let duplicateCat = cats.addChild(
|
|
|
+ name: "cat",
|
|
|
+ value: "Tinna",
|
|
|
+ attributes: ["breed": "Siberian", "color": "lightgray"]
|
|
|
+ )
|
|
|
+
|
|
|
lastCat.removeFromParent()
|
|
|
duplicateCat.removeFromParent()
|
|
|
-
|
|
|
+
|
|
|
let catsCount = cats["cat"].count
|
|
|
let firstCat = cats["cat"]
|
|
|
XCTAssertEqual(catsCount, 3, "Should be able to remove element from parent.")
|
|
|
XCTAssertEqual(try firstCat.get(), "Tinna", "Should be able to remove the exact element from parent.")
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
func testXMLEscapedString() {
|
|
|
let string = "&<>'\""
|
|
|
let escapedString = string.xmlEscaped
|
|
|
XCTAssertEqual(escapedString, "&<>'"")
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
func testXMLString() {
|
|
|
let testDocument = Document()
|
|
|
let children = testDocument.addChild(name: "children")
|
|
|
- children.addChild(name: "child", value: "value", attributes: ["attribute" : "attributeValue<&>"])
|
|
|
+ children.addChild(name: "child", value: "value", attributes: ["attribute": "attributeValue<&>"])
|
|
|
children.addChild(name: "child")
|
|
|
children.addChild(name: "child", value: "&<>'\"")
|
|
|
-
|
|
|
- XCTAssertEqual(testDocument.xml, "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?>\n<children>\n\t<child attribute=\"attributeValue<&>\">value</child>\n\t<child />\n\t<child>&<>'"</child>\n</children>", "Should be able to print XML formatted string.")
|
|
|
-
|
|
|
- XCTAssertEqual(testDocument.xmlCompact, "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?><children><child attribute=\"attributeValue<&>\">value</child><child /><child>&<>'"</child></children>", "Should be able to print compact XML string.")
|
|
|
-
|
|
|
- XCTAssertEqual(testDocument.xmlSpaces, "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?>\n<children>\n <child attribute=\"attributeValue<&>\">value</child>\n <child />\n <child>&<>'"</child>\n</children>", "Should be able to print XML formatted string.")
|
|
|
- }
|
|
|
-
|
|
|
+
|
|
|
+ XCTAssertEqual(
|
|
|
+ testDocument.xml,
|
|
|
+ "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?>\n<children>\n\t<child attribute=\"attributeValue<&>\">value</child>\n\t<child />\n\t<child>&<>'"</child>\n</children>",
|
|
|
+ "Should be able to print XML formatted string."
|
|
|
+ )
|
|
|
+
|
|
|
+ XCTAssertEqual(
|
|
|
+ testDocument.xmlCompact,
|
|
|
+ "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?><children><child attribute=\"attributeValue<&>\">value</child><child /><child>&<>'"</child></children>",
|
|
|
+ "Should be able to print compact XML string."
|
|
|
+ )
|
|
|
+
|
|
|
+ XCTAssertEqual(
|
|
|
+ testDocument.xmlSpaces,
|
|
|
+ "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?>\n<children>\n <child attribute=\"attributeValue<&>\">value</child>\n <child />\n <child>&<>'"</child>\n</children>",
|
|
|
+ "Should be able to print XML formatted string."
|
|
|
+ )
|
|
|
+ }
|
|
|
+
|
|
|
// MARK: - XML Parse Performance
|
|
|
-
|
|
|
+
|
|
|
func testReadXMLPerformance() {
|
|
|
- self.measure() {
|
|
|
+ self.measure {
|
|
|
_ = self.readXMLFromFile(filename: "plant_catalog")
|
|
|
}
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
func testWriteXMLPerformance() {
|
|
|
- self.measure() {
|
|
|
+ self.measure {
|
|
|
_ = self.plantsDocument.xml
|
|
|
}
|
|
|
}
|
|
|
-
|
|
|
}
|
