Intial Implementation of Stream and NSOutputStream

Author: saiHemak

Foundation/NSStream.swift

@@ -163,34 +163,58 @@ public class InputStream: Stream {
 // Subclassers are required to implement these methods.
 // Currently this is left as named NSOutputStream due to conflicts with the standard library's text streaming target protocol named OutputStream (which ideally should be renamed)
 public class NSOutputStream : Stream {
+    
+    private  var _stream: CFWriteStream!
+    
     // writes the bytes from the specified buffer to the stream up to len bytes. Returns the number of bytes actually written.
     public func write(_ buffer: UnsafePointer<UInt8>, maxLength len: Int) -> Int {
-        NSUnimplemented()
+        return  CFWriteStreamWrite(_stream, buffer, len)
     }
 
     // returns YES if the stream can be written to or if it is impossible to tell without actually doing the write.
     public var hasSpaceAvailable: Bool {
-        NSUnimplemented()
+        return CFWriteStreamCanAcceptBytes(_stream)
     }
 
-    public init(toMemory: ()) {
-        NSUnimplemented()
+    required public init(toMemory: ()) {
+        _stream = CFWriteStreamCreateWithAllocatedBuffers(kCFAllocatorDefault, kCFAllocatorDefault)
     }
 
     public init(toBuffer buffer: UnsafeMutablePointer<UInt8>, capacity: Int) {
-        NSUnimplemented()
+        _stream = CFWriteStreamCreateWithBuffer(kCFAllocatorSystemDefault, buffer, capacity)
     }
-
+    
     public init?(url: URL, append shouldAppend: Bool) {
-        NSUnimplemented()
+        _stream = CFWriteStreamCreateWithFile(kCFAllocatorSystemDefault, url._cfObject)
+        CFWriteStreamSetProperty(_stream, kCFStreamPropertyAppendToFile, shouldAppend._cfObject)
     }
 
     public convenience init?(toFileAtPath path: String, append shouldAppend: Bool) {
-        NSUnimplemented()
+        self.init(url: URL(fileURLWithPath: path), append: shouldAppend)
+    }
+    
+    public override func open() {
+        CFWriteStreamOpen(_stream)
+    }
+    
+    public override func close() {
+        CFWriteStreamClose(_stream)
+    }
+    
+    public override var streamStatus: Status {
+        return Stream.Status(rawValue: UInt(CFWriteStreamGetStatus(_stream)))!
     }
 
     public class func outputStreamToMemory() -> Self {
-        NSUnimplemented()
+        return self.init(toMemory: ())
+    }
+    
+    public override func propertyForKey(_ key: String) -> AnyObject? {
+        return CFWriteStreamCopyProperty(_stream, key._cfObject)
+    }
+    
+    public  override func setProperty(_ property: AnyObject?, forKey key: String) -> Bool {
+        return CFWriteStreamSetProperty(_stream, key._cfObject, property)
     }
 }
 

TestFoundation/TestNSStream.swift

@@ -23,6 +23,12 @@ class TestNSStream : XCTestCase {
             ("test_InputStreamWithFile", test_InputStreamWithFile),
             ("test_InputStreamHasBytesAvailable", test_InputStreamHasBytesAvailable),
             ("test_InputStreamInvalidPath", test_InputStreamInvalidPath),
+            ("test_outputStreamCreationToFile", test_outputStreamCreationToFile),
+            ("test_outputStreamCreationToBuffer", test_outputStreamCreationToBuffer),
+            ("test_outputStreamCreationWithUrl", test_outputStreamCreationWithUrl),
+            ("test_outputStreamCreationToMemory", test_outputStreamCreationToMemory),
+            ("test_outputStreamHasSpaceAvailable", test_outputStreamHasSpaceAvailable),
+            ("test_ouputStreamWithInvalidPath", test_ouputStreamWithInvalidPath),
         ]
     }
 
@@ -118,19 +124,111 @@ class TestNSStream : XCTestCase {
         XCTAssertEqual(Stream.Status.error, fileStream.streamStatus)
     }
 
-    private func createTestFile(_ path: String,_contents: Data) -> String? {
+    func test_outputStreamCreationToFile() {
+        let filePath = createTestFile("TestFileOut.txt", _contents: Data(capacity: 256)!)
+        if filePath != nil {
+            let outputStream = NSOutputStream(toFileAtPath: filePath!, append: true)
+            XCTAssertEqual(Stream.Status.notOpen, outputStream!.streamStatus)
+            var myString = "Hello world!"
+            let encodedData = [UInt8](myString.utf8)
+            outputStream?.open()
+            XCTAssertEqual(Stream.Status.open, outputStream!.streamStatus)
+            let result: Int? = outputStream?.write(encodedData, maxLength: encodedData.count)
+            outputStream?.close()
+            XCTAssertEqual(myString.characters.count, result)
+            XCTAssertEqual(Stream.Status.closed, outputStream!.streamStatus)
+            removeTestFile(filePath!)
+        } else {
+            XCTFail("Unable to create temp file");
+        }
+    }
+    
+    func  test_outputStreamCreationToBuffer() {
+        var buffer = Array<UInt8>(repeating: 0, count: 12)
+        var myString = "Hello world!"
+        let encodedData = [UInt8](myString.utf8)
+        let outputStream = NSOutputStream(toBuffer: UnsafeMutablePointer<UInt8>(buffer), capacity: 12)
+        XCTAssertEqual(Stream.Status.notOpen, outputStream.streamStatus)
+        outputStream.open()
+        XCTAssertEqual(Stream.Status.open, outputStream.streamStatus)
+        let result: Int? = outputStream.write(encodedData, maxLength: encodedData.count)
+        outputStream.close()
+        XCTAssertEqual(Stream.Status.closed, outputStream.streamStatus)
+        XCTAssertEqual(myString.characters.count, result)
+        XCTAssertEqual(NSString(bytes: &buffer, length: buffer.count, encoding: String.Encoding.utf8.rawValue),myString._bridgeToObject())
+    }
+    
+    func test_outputStreamCreationWithUrl() {
+        let filePath = createTestFile("TestFileOut.txt", _contents: Data(capacity: 256)!)
+        if filePath != nil {
+            let outputStream = NSOutputStream(url: URL(fileURLWithPath: filePath!), append: true)
+            XCTAssertEqual(Stream.Status.notOpen, outputStream!.streamStatus)
+            var myString = "Hello world!"
+            let encodedData = [UInt8](myString.utf8)
+            outputStream!.open()
+            XCTAssertEqual(Stream.Status.open, outputStream!.streamStatus)
+            let result: Int? = outputStream?.write(encodedData, maxLength: encodedData.count)
+            outputStream?.close()
+            XCTAssertEqual(myString.characters.count, result)
+            XCTAssertEqual(Stream.Status.closed, outputStream!.streamStatus)
+            removeTestFile(filePath!)
+        } else {
+            XCTFail("Unable to create temp file");
+        }
+    }
+    
+    func test_outputStreamCreationToMemory(){
+        var buffer = Array<UInt8>(repeating: 0, count: 12)
+        var myString = "Hello world!"
+        let encodedData = [UInt8](myString.utf8)
+        let outputStream = NSOutputStream.outputStreamToMemory()
+        XCTAssertEqual(Stream.Status.notOpen, outputStream.streamStatus)
+        outputStream.open()
+        XCTAssertEqual(Stream.Status.open, outputStream.streamStatus)
+        let result: Int? = outputStream.write(encodedData, maxLength: encodedData.count)
+        XCTAssertEqual(myString.characters.count, result)
+        //verify the data written
+        let dataWritten  = outputStream.propertyForKey(NSStreamDataWrittenToMemoryStreamKey)
+        if let nsdataWritten = dataWritten as? NSData {
+            nsdataWritten.getBytes(UnsafeMutablePointer<UInt8>(buffer), length: result!)
+            XCTAssertEqual(NSString(bytes: &buffer, length: buffer.count, encoding: String.Encoding.utf8.rawValue), myString._bridgeToObject())
+            outputStream.close()
+        } else {
+            XCTFail("Unable to get data from memeory.")
+        }
+    }
+
+    func test_outputStreamHasSpaceAvailable() {
+        let buffer = Array<UInt8>(repeating: 0, count: 12)
+        var myString = "Welcome To Hello world  !"
+        let encodedData = [UInt8](myString.utf8)
+        let outputStream = NSOutputStream(toBuffer: UnsafeMutablePointer<UInt8>(buffer), capacity: 12)
+        outputStream.open()
+        XCTAssertTrue(outputStream.hasSpaceAvailable)
+        _ = outputStream.write(encodedData, maxLength: encodedData.count)
+        XCTAssertFalse(outputStream.hasSpaceAvailable)
+    }
+    
+    func test_ouputStreamWithInvalidPath(){
+        let outputStream = NSOutputStream(toFileAtPath: "http:///home/sdsfsdfd", append: true)
+        XCTAssertEqual(Stream.Status.notOpen, outputStream!.streamStatus)
+        outputStream?.open()
+        XCTAssertEqual(Stream.Status.error, outputStream!.streamStatus)
+    }
+    
+    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
+            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) {
@@ -142,4 +240,3 @@ class TestNSStream : XCTestCase {
     }
 }
 
-