Intial Implementation of Stream and NSOutputStream

Author: saiHemak

Foundation/NSStream.swift

@@ -6,6 +6,9 @@
 // See http://swift.org/LICENSE.txt for license information
 // See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
+#if os(Linux)
+    import CoreFoundation
+#endif
 
 extension Stream {
     public struct PropertyKey : RawRepresentable, Equatable, Hashable, Comparable {
@@ -66,11 +69,11 @@ public class Stream: NSObject {
     }
 
     public func open() {
-        NSUnimplemented()
+        streamOpen()
     }
 
     public func close() {
-        NSUnimplemented()
+        streamClose()
     }
 
     public weak var delegate: StreamDelegate?
@@ -95,12 +98,26 @@ public class Stream: NSObject {
     }
 
     public var streamStatus: Status {
-        NSUnimplemented()
+        return  getStreamStatus()
     }
 
     /*@NSCopying */public var streamError: NSError? {
         NSUnimplemented()
     }
+    
+    internal func streamOpen(){
+        preconditionFailure("This method must be overriden.")
+    }
+    
+    internal func streamClose(){
+        preconditionFailure("This method must be overriden.")
+    }
+    
+    internal func getStreamStatus() -> Status {
+        // Initial status of stream is 'notOpen'.
+        // Subsequent status is set in the subclass function.
+        return Status.notOpen
+    }
 }
 
 // NSInputStream is an abstract class representing the base functionality of a read stream.
@@ -138,35 +155,54 @@ 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()
+        if let outputStream = _stream {
+            return  CFWriteStreamWrite(outputStream, buffer, len)
+        } else {
+            return -1
+        }
     }
 
     // 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()
     }
 
     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)
     }
 
     public convenience init?(toFileAtPath path: String, append shouldAppend: Bool) {
-        NSUnimplemented()
+        self.init(url: URL(fileURLWithPath: path), append: true)
     }
 
     public class func outputStreamToMemory() -> Self {
         NSUnimplemented()
     }
+    
+    internal override func streamOpen() {
+        CFWriteStreamOpen(_stream)
+    }
+    
+    internal override func streamClose() {
+        CFWriteStreamClose(_stream)
+    }
+    
+    internal override func getStreamStatus() -> Stream.Status {
+        return Stream.Status(rawValue: UInt(CFWriteStreamGetStatus(_stream)))!
+    }
 }
 
 // Discussion of this API is ongoing for its usage of AutoreleasingUnsafeMutablePointer

TestFoundation/TestNSStream.swift

@@ -0,0 +1,123 @@
+// 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 TestNSStream : XCTestCase {
+    static var allTests: [(String, (TestNSStream) -> () throws -> Void)] {
+        return [
+            ("test_outputStreamCreationToFile", test_outputStreamCreationToFile),
+            ("test_outputStreamCreationToBuffer", test_outputStreamCreationToBuffer),
+            ("test_outputStreamCreationWithUrl", test_outputStreamCreationWithUrl),
+            ("test_outputStreamHasSpaceAvailable", test_outputStreamHasSpaceAvailable),
+            ("test_ouputStreamWithInvalidPath", test_ouputStreamWithInvalidPath),
+        ]
+    }
+    
+    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_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
+            } else {
+                return nil
+            }
+        } catch _ {
+            return nil
+        }
+    }
+    
+    private func removeTestFile(_ location: String) {
+        do {
+            try FileManager.default().removeItem(atPath: location)
+        } catch _ {
+            
+        }
+    }
+}
+

TestFoundation/main.swift

@@ -57,6 +57,7 @@ XCTMain([
     testCase(TestNSRunLoop.allTests),
     testCase(TestNSScanner.allTests),
     testCase(TestNSSet.allTests),
+    testCase(TestNSStream.allTests),
     testCase(TestNSString.allTests),
 //    testCase(TestNSThread.allTests),
     testCase(TestNSTask.allTests),