Implementing (initial) of Stream and InputStream.

mamabusi · mamabusi · commit bc23b9493f47 · 2016-07-13T18:43:50.000+05:30
diff --git a/CoreFoundation/Stream.subproj/CFStream.h b/CoreFoundation/Stream.subproj/CFStream.h
@@ -78,6 +78,8 @@ const CFStringRef kCFStreamPropertyDataWritten;
 CF_EXPORT
 CFReadStreamRef CFReadStreamCreateWithBytesNoCopy(CFAllocatorRef alloc, const UInt8 *bytes, CFIndex length, CFAllocatorRef bytesDeallocator);
 
+CF_EXPORT CFReadStreamRef CFReadStreamCreateWithData(CFAllocatorRef alloc, CFDataRef data);
+
 /* The stream writes into the buffer given; when bufferCapacity is exhausted, the stream is exhausted (status becomes kCFStreamStatusAtEnd) */
 CF_EXPORT
 CFWriteStreamRef CFWriteStreamCreateWithBuffer(CFAllocatorRef alloc, UInt8 *buffer, CFIndex bufferCapacity);
diff --git a/Foundation/NSStream.swift b/Foundation/NSStream.swift
@@ -7,6 +7,10 @@
 // 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 {
         public private(set) var rawValue: String
@@ -60,17 +64,17 @@ public func <(lhs: Stream.PropertyKey, rhs: Stream.PropertyKey) -> Bool {
 // NSStream is an abstract class encapsulating the common API to NSInputStream and NSOutputStream.
 // Subclassers of NSInputStream and NSOutputStream must also implement these methods.
 public class Stream: NSObject {
-    
+
     public override init() {
-        
+
     }
     
     public func open() {
-        NSUnimplemented()
+        streamOpen()
     }
     
     public func close() {
-        NSUnimplemented()
+        streamClose()
     }
     
     public weak var delegate: StreamDelegate?
@@ -95,20 +99,37 @@ 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 steam 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.
 // Subclassers are required to implement these methods.
 public class InputStream: Stream {
+
+    private var _stream: CFReadStream!
+
     // reads up to length bytes into the supplied buffer, which must be at least of size len. Returns the actual number of bytes read.
     public func read(_ buffer: UnsafeMutablePointer<UInt8>, maxLength len: Int) -> Int {
-        NSUnimplemented()
+        return CFReadStreamRead(_stream, buffer, CFIndex(len._bridgeToObject()))
     }
     
     // returns in O(1) a pointer to the buffer in 'buffer' and by reference in 'len' how many bytes are available. This buffer is only valid until the next stream operation. Subclassers may return NO for this if it is not appropriate for the stream type. This may return NO if the buffer is not available.
@@ -118,19 +139,34 @@ public class InputStream: Stream {
     
     // returns YES if the stream has bytes available or if it impossible to tell without actually doing the read.
     public var hasBytesAvailable: Bool {
-        NSUnimplemented()
+        return CFReadStreamHasBytesAvailable(_stream)
     }
     
     public init(data: Data) {
-        NSUnimplemented()
+        let nsData = data._bridgeToObjectiveC()
+        let _data: CFData = CFDataCreate(kCFAllocatorDefault,
+                                         UnsafePointer<UInt8>(nsData.bytes), nsData.length)
+        _stream = CFReadStreamCreateWithData(kCFAllocatorSystemDefault, _data)
     }
     
     public init?(url: URL) {
-        NSUnimplemented()
+        _stream = CFReadStreamCreateWithFile(kCFAllocatorDefault, url._cfObject)
     }
 
     public convenience init?(fileAtPath path: String) {
-        NSUnimplemented()
+        self.init(url: URL(fileURLWithPath: path))
+    }
+
+    internal override func streamOpen() {
+        CFReadStreamOpen(_stream)
+    }
+    
+    internal override func streamClose() {
+        CFReadStreamClose(_stream)
+    }
+    
+    internal override func getStreamStatus() -> Stream.Status {
+        return Stream.Status(rawValue: UInt(CFReadStreamGetStatus(_stream)))!
     }
 }
 
diff --git a/TestFoundation/TestNSStream.swift b/TestFoundation/TestNSStream.swift
@@ -0,0 +1,145 @@
+// 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_InputStreamWithData", test_InputStreamWithData),
+            ("test_InputStreamWithUrl", test_InputStreamWithUrl),
+            ("test_InputStreamWithFile", test_InputStreamWithFile),
+            ("test_InputStreamHasBytesAvailable", test_InputStreamHasBytesAvailable),
+            ("test_InputStreamInvalidPath", test_InputStreamInvalidPath),
+        ]
+    }
+    
+    func test_InputStreamWithData(){
+        let message: NSString = "Hello, playground"
+        let messageData: Data = message.data(using: String.Encoding.utf8.rawValue)!
+        let dataStream: InputStream = InputStream(data: messageData)
+        XCTAssertEqual(Stream.Status.notOpen, dataStream.streamStatus)
+        dataStream.open()
+        XCTAssertEqual(Stream.Status.open, dataStream.streamStatus)
+        var buffer = [UInt8](repeating: 0, count: 20)
+        if dataStream.hasBytesAvailable {
+            let result: Int = dataStream.read(&buffer, maxLength: buffer.count)
+            dataStream.close()
+            XCTAssertEqual(Stream.Status.closed, dataStream.streamStatus)
+            if(result > 0){
+                let output = NSString(bytes: &buffer, length: buffer.count, encoding: String.Encoding.utf8.rawValue)
+                XCTAssertEqual(message, output!)
+            }
+        }
+    }
+    
+    func test_InputStreamWithUrl() {
+        let message: NSString = "Hello, playground"
+        let messageData: Data  = message.data(using: String.Encoding.utf8.rawValue)!
+        //Initialiser with url
+        let testFile = createTestFile("testFile_in.txt", _contents: messageData)
+        if testFile != nil {
+            let url = URL(fileURLWithPath: testFile!)
+            let urlStream: InputStream = InputStream(url: url)!
+            XCTAssertEqual(Stream.Status.notOpen, urlStream.streamStatus)
+            urlStream.open()
+            XCTAssertEqual(Stream.Status.open, urlStream.streamStatus)
+            var buffer = [UInt8](repeating: 0, count: 20)
+            if urlStream.hasBytesAvailable {
+                let result :Int = urlStream.read(&buffer, maxLength: buffer.count)
+                urlStream.close()
+                XCTAssertEqual(Stream.Status.closed, urlStream.streamStatus)
+                XCTAssertEqual(messageData.count, result)
+                if(result > 0) {
+                    let output = NSString(bytes: &buffer, length: buffer.count, encoding: String.Encoding.utf8.rawValue)
+                    XCTAssertEqual(message, output!)
+                }
+            }
+            removeTestFile(testFile!)
+        } else {
+            XCTFail("Unable to create temp file")
+        }
+    }
+    
+    func test_InputStreamWithFile() {
+        let message: NSString = "Hello, playground"
+        let messageData: Data  = message.data(using: String.Encoding.utf8.rawValue)!
+        //Initialiser with file
+        let testFile = createTestFile("testFile_in.txt", _contents: messageData)
+        if testFile != nil {
+            let fileStream: InputStream = InputStream(fileAtPath: testFile!)!
+            XCTAssertEqual(Stream.Status.notOpen, fileStream.streamStatus)
+            fileStream.open()
+            XCTAssertEqual(Stream.Status.open, fileStream.streamStatus)
+            var buffer = [UInt8](repeating: 0, count: 20)
+            if fileStream.hasBytesAvailable {
+                let result: Int = fileStream.read(&buffer, maxLength: buffer.count)
+                fileStream.close()
+                XCTAssertEqual(Stream.Status.closed, fileStream.streamStatus)
+                XCTAssertEqual(messageData.count, result)
+                if(result > 0){
+                    let output = NSString(bytes: &buffer, length: buffer.count, encoding: String.Encoding.utf8.rawValue)
+                    XCTAssertEqual(message, output!)
+                }
+            }
+            removeTestFile(testFile!)
+        } else {
+            XCTFail("Unable to create temp file")
+        }
+    }
+    
+    func test_InputStreamHasBytesAvailable() {
+        let message: NSString = "Hello, playground"
+        let messageData: Data  = message.data(using: String.Encoding.utf8.rawValue)!
+        let stream: InputStream = InputStream(data: messageData)
+        var buffer = [UInt8](repeating: 0, count: 20)
+        stream.open()
+        XCTAssertTrue(stream.hasBytesAvailable)
+        _ = stream.read(&buffer, maxLength: buffer.count)
+        XCTAssertFalse(stream.hasBytesAvailable)
+    }
+    
+    func test_InputStreamInvalidPath() {
+        let fileStream: InputStream = InputStream(fileAtPath: "/tmp/file.txt")!
+        XCTAssertEqual(Stream.Status.notOpen, fileStream.streamStatus)
+        fileStream.open()
+        XCTAssertEqual(Stream.Status.error, fileStream.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 _ {
+            
+        }
+    }
+}
+
+
diff --git a/TestFoundation/main.swift b/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),
