Implementation for NSDictionary.write(toFile:)

Foundation/NSDictionary.swift

@@ -433,8 +433,20 @@ open class NSDictionary : NSObject, NSCopying, NSMutableCopying, NSSecureCoding,
         return objects
     }
 
-    open func write(toFile path: String, atomically useAuxiliaryFile: Bool) -> Bool { NSUnimplemented() }
-    open func write(to url: URL, atomically: Bool) -> Bool { NSUnimplemented() } // the atomically flag is ignored if url of a type that cannot be written atomically.
+    open func write(toFile path: String, atomically useAuxiliaryFile: Bool) -> Bool {
+        return write(to: URL(fileURLWithPath: path), atomically: useAuxiliaryFile)
+    }
+
+    // the atomically flag is ignored if url of a type that cannot be written atomically.
+    open func write(to url: URL, atomically: Bool) -> Bool {
+        do {
+            let pListData = try PropertyListSerialization.data(fromPropertyList: self, format: PropertyListSerialization.PropertyListFormat.xml, options: 0)
+            try pListData.write(to: url, options: atomically ? .atomic : [])
+            return true
+        } catch {
+            return false
+        }
+    }
 
     open func enumerateKeysAndObjects(_ block: (Any, Any, UnsafeMutablePointer<ObjCBool>) -> Swift.Void) {
         enumerateKeysAndObjects(options: [], using: block)

TestFoundation/TestNSDictionary.swift

@@ -30,6 +30,7 @@ class TestNSDictionary : XCTestCase {
             ("test_equality", test_equality),
             ("test_copying", test_copying),
             ("test_mutableCopying", test_mutableCopying),
+            ("test_writeToFile", test_writeToFile),
         ]
     }
 
@@ -161,4 +162,52 @@ class TestNSDictionary : XCTestCase {
         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: [])
+                    try plistDoc.validate()
+                    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("XMLDocument failes to read / validate contenets")
+                }
+            } else {
+                XCTFail("Write to file failed")
+            }
+            removeTestFile(testFilePath!)
+        } else {
+            XCTFail("Temporary file creation failed")
+        }
+    }
+
+    private func createTestFile(_ path: String, _contents: Data) -> String? {
+        let tempDir = "/tmp/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 _ {
+
+        }
+    }
+
 }