blob: 096f0a68927ae783d79cbcab1a8e9bf9a221e54c [file] [log] [blame]
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See http://swift.org/LICENSE.txt for license information
// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
#if DEPLOYMENT_RUNTIME_OBJC || os(Linux)
import Foundation
import XCTest
#else
import SwiftFoundation
import SwiftXCTest
#endif
class TestNSDictionary : XCTestCase {
static var allTests: [(String, (TestNSDictionary) -> () throws -> Void)] {
return [
("test_BasicConstruction", test_BasicConstruction),
// ("test_ArrayConstruction", test_ArrayConstruction),
("test_description", test_description),
("test_enumeration", test_enumeration),
("test_equality", test_equality),
("test_copying", test_copying),
("test_mutableCopying", test_mutableCopying),
("test_writeToFile", test_writeToFile),
("test_initWithContentsOfFile", test_initWithContentsOfFile),
]
}
func test_BasicConstruction() {
let dict = NSDictionary()
let dict2: NSDictionary = ["foo": "bar"]
XCTAssertEqual(dict.count, 0)
XCTAssertEqual(dict2.count, 1)
}
func test_description() {
let d1: NSDictionary = [ "foo": "bar", "baz": "qux"]
XCTAssertEqual(d1.description, "{\n baz = qux;\n foo = bar;\n}")
let d2: NSDictionary = ["1" : ["1" : ["1" : "1"]]]
XCTAssertEqual(d2.description, "{\n 1 = {\n 1 = {\n 1 = 1;\n };\n };\n}")
}
func test_HeterogeneousConstruction() {
let dict2: NSDictionary = [
"foo": "bar",
1 : 2
]
XCTAssertEqual(dict2.count, 2)
XCTAssertEqual(dict2["foo"] as? String, "bar")
XCTAssertEqual(dict2[1] as? NSNumber, NSNumber(value: 2))
}
// func test_ArrayConstruction() {
// let objects = ["foo", "bar", "baz"]
// let keys = ["foo", "bar", "baz"]
// let dict = NSDictionary(objects: objects, forKeys: keys)
// XCTAssertEqual(dict.count, 3)
// }
func test_enumeration() {
let dict : NSDictionary = ["foo" : "bar", "whiz" : "bang", "toil" : "trouble"]
let e = dict.keyEnumerator()
var keys = Set<String>()
keys.insert((e.nextObject()! as! String))
keys.insert((e.nextObject()! as! String))
keys.insert((e.nextObject()! as! String))
XCTAssertNil(e.nextObject())
XCTAssertNil(e.nextObject())
XCTAssertEqual(keys, ["foo", "whiz", "toil"])
let o = dict.objectEnumerator()
var objs = Set<String>()
objs.insert((o.nextObject()! as! String))
objs.insert((o.nextObject()! as! String))
objs.insert((o.nextObject()! as! String))
XCTAssertNil(o.nextObject())
XCTAssertNil(o.nextObject())
XCTAssertEqual(objs, ["bar", "bang", "trouble"])
}
func test_sequenceType() {
let dict : NSDictionary = ["foo" : "bar", "whiz" : "bang", "toil" : "trouble"]
var result = [String:String]()
for (key, value) in dict {
result[key as! String] = (value as! String)
}
XCTAssertEqual(result, ["foo" : "bar", "whiz" : "bang", "toil" : "trouble"])
}
func test_equality() {
let dict1 = NSDictionary(dictionary: [
"foo":"bar",
"whiz":"bang",
"toil":"trouble",
])
let dict2 = NSDictionary(dictionary: [
"foo":"bar",
"whiz":"bang",
"toil":"trouble",
])
let dict3 = NSDictionary(dictionary: [
"foo":"bar",
"whiz":"bang",
"toil":"troubl",
])
XCTAssertTrue(dict1 == dict2)
XCTAssertTrue(dict1.isEqual(dict2))
XCTAssertTrue(dict1.isEqual(to: [
"foo":"bar",
"whiz":"bang",
"toil":"trouble",
]))
XCTAssertEqual(dict1.hash, dict2.hash)
XCTAssertEqual(dict1.hashValue, dict2.hashValue)
XCTAssertFalse(dict1 == dict3)
XCTAssertFalse(dict1.isEqual(dict3))
XCTAssertFalse(dict1.isEqual(to:[
"foo":"bar",
"whiz":"bang",
"toil":"troubl",
]))
XCTAssertFalse(dict1.isEqual(nil))
XCTAssertFalse(dict1.isEqual(NSObject()))
let nestedDict1 = NSDictionary(dictionary: [
"key.entities": [
["key": 0]
]
])
let nestedDict2 = NSDictionary(dictionary: [
"key.entities": [
["key": 1]
]
])
XCTAssertFalse(nestedDict1 == nestedDict2)
XCTAssertFalse(nestedDict1.isEqual(nestedDict2))
XCTAssertFalse(nestedDict1.isEqual(to: [
"key.entities": [
["key": 1]
]
]))
}
func test_copying() {
let inputDictionary : NSDictionary = ["foo" : "bar", "whiz" : "bang", "toil" : "trouble"]
let copy: NSDictionary = inputDictionary.copy() as! NSDictionary
XCTAssertTrue(inputDictionary === copy)
let dictMutableCopy = inputDictionary.mutableCopy() as! NSMutableDictionary
let dictCopy2 = dictMutableCopy.copy() as! NSDictionary
XCTAssertTrue(type(of: dictCopy2) === NSDictionary.self)
XCTAssertFalse(dictMutableCopy === dictCopy2)
XCTAssertTrue(dictMutableCopy == dictCopy2)
}
func test_mutableCopying() {
let inputDictionary : NSDictionary = ["foo" : "bar", "whiz" : "bang", "toil" : "trouble"]
let dictMutableCopy1 = inputDictionary.mutableCopy() as! NSMutableDictionary
XCTAssertTrue(type(of: dictMutableCopy1) === NSMutableDictionary.self)
XCTAssertFalse(inputDictionary === dictMutableCopy1)
XCTAssertTrue(inputDictionary == dictMutableCopy1)
let dictMutableCopy2 = dictMutableCopy1.mutableCopy() as! NSMutableDictionary
XCTAssertTrue(type(of: dictMutableCopy2) === NSMutableDictionary.self)
XCTAssertFalse(dictMutableCopy2 === dictMutableCopy1)
XCTAssertTrue(dictMutableCopy2 == dictMutableCopy1)
}
func test_writeToFile() {
let testFilePath = createTestFile("TestFileOut.txt", _contents: Data(capacity: 256))
if let _ = testFilePath {
let d1: NSDictionary = [ "foo": "bar", "baz": "qux"]
let isWritten = d1.write(toFile: testFilePath!, atomically: true)
if isWritten {
do {
let plistDoc = try XMLDocument(contentsOf: URL(fileURLWithPath: testFilePath!, isDirectory: false), options: [])
XCTAssert(plistDoc.rootElement()?.name == "plist")
let plist = try PropertyListSerialization.propertyList(from: plistDoc.xmlData, options: [], format: nil) as! [String: Any]
XCTAssert((plist["foo"] as? String) == d1["foo"] as? String)
XCTAssert((plist["baz"] as? String) == d1["baz"] as? String)
} catch {
XCTFail("Failed to read and parse XMLDocument")
}
} else {
XCTFail("Write to file failed")
}
removeTestFile(testFilePath!)
} else {
XCTFail("Temporary file creation failed")
}
}
func test_initWithContentsOfFile() {
let testFilePath = createTestFile("TestFileOut.txt", _contents: Data(capacity: 256))
if let _ = testFilePath {
let d1: NSDictionary = ["Hello":["world":"again"]]
let isWritten = d1.write(toFile: testFilePath!, atomically: true)
if(isWritten) {
let dict = NSMutableDictionary.init(contentsOfFile: testFilePath!)
XCTAssert(dict == d1)
} else {
XCTFail("Write to file failed")
}
removeTestFile(testFilePath!)
} else {
XCTFail("Temporary file creation failed")
}
}
private func createTestFile(_ path: String, _contents: Data) -> String? {
let tempDir = NSTemporaryDirectory() + "TestFoundation_Playground_" + NSUUID().uuidString + "/"
do {
try FileManager.default.createDirectory(atPath: tempDir, withIntermediateDirectories: false, attributes: nil)
if FileManager.default.createFile(atPath: tempDir + "/" + path, contents: _contents,
attributes: nil) {
return tempDir + path
} else {
return nil
}
} catch _ {
return nil
}
}
private func removeTestFile(_ location: String) {
do {
try FileManager.default.removeItem(atPath: location)
} catch _ {
}
}
}