Implementation for NSDictionary.write(toFile:)

Author: saiHemak

Foundation/NSDictionary.swift

@@ -400,7 +400,18 @@ open class NSDictionary : NSObject, NSCopying, NSMutableCopying, NSSecureCoding,
         return objects
     }
 
-    open func write(toFile path: String, atomically useAuxiliaryFile: Bool) -> Bool { NSUnimplemented() }
+    open func write(toFile path: String, atomically useAuxiliaryFile: Bool) -> Bool {
+        var returnVal = false
+        do {
+            let pListData = try PropertyListSerialization.data(fromPropertyList: self, format: PropertyListSerialization.PropertyListFormat.xml, options: 0)
+            let xmlDocument = try XMLDocument.init(data: pListData, options: XMLNode.Options.documentValidate)
+            let xmlData = xmlDocument.xmlData(withOptions: XMLNode.Options.nodePrettyPrint)
+            try xmlData.write(to: URL(fileURLWithPath: path), options: useAuxiliaryFile ? .atomic : [])
+            returnVal = true
+        } catch {
+        }
+        return returnVal
+    }
     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 enumerateKeysAndObjects(_ block: (Any, Any, UnsafeMutablePointer<ObjCBool>) -> Swift.Void) {

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),
         ]
     }
 
@@ -162,4 +163,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 _ {
+            
+        }
+    }
+
 }