CommandLineToolkit

1
import Foundation
2
import JSONStream
3
import XCTest
4

5
class BlockingArrayBasedJSONStreamTests: XCTestCase {
6
    func testReadBlocksUntilNewDataComes() {
7
        let readQueue = OperationQueue()
8
        let writeQeuue = OperationQueue()
9
        let stream = BlockingArrayBasedJSONStream()
10
        stream.append(string: "1")
11
        
12
        var byte: UInt8?
13
        readQueue.addOperation {
14
            byte = stream.read()
15
            // next call will block until writeQueue updates the stream with new data
16
            byte = stream.read()
17
        }
18
        
19
        writeQeuue.addOperation {
20
            Thread.sleep(forTimeInterval: 0.3)
21
            stream.append(string: "2")
22
        }
23
        
24
        readQueue.waitUntilAllOperationsAreFinished()
25
        writeQeuue.waitUntilAllOperationsAreFinished()
26
        
27
        XCTAssertEqual(byte, 0x32)
28
    }
29
    
30
    func testReadBlocksUntilFlagFlips() {
31
        let readQueue = OperationQueue()
32
        let writeQeuue = OperationQueue()
33
        let stream = BlockingArrayBasedJSONStream()
34
        stream.append(string: "1")
35
        
36
        var byte: UInt8?
37
        readQueue.addOperation {
38
            byte = stream.read()  // == 1
39
            // next call will block until writeQueue flips the flag that data is over
40
            byte = stream.read()
41
        }
42
        
43
        writeQeuue.addOperation {
44
            Thread.sleep(forTimeInterval: 0.3)
45
            stream.close()
46
        }
47
        
48
        readQueue.waitUntilAllOperationsAreFinished()
49
        writeQeuue.waitUntilAllOperationsAreFinished()
50
        
51
        XCTAssertNil(byte)
52
    }
53
    
54
    func testReadBlocksMultipleThreadsUntilNewDataComes() {
55
        let readQueue1 = OperationQueue()
56
        let readQueue2 = OperationQueue()
57
        let writeQeuue = OperationQueue()
58
        let stream = BlockingArrayBasedJSONStream()
59
        
60
        var byte1: UInt8?
61
        var byte2: UInt8?
62
        
63
        readQueue1.addOperation { byte1 = stream.read() }
64
        readQueue2.addOperation { byte2 = stream.read() }
65
        
66
        writeQeuue.addOperation {
67
            Thread.sleep(forTimeInterval: 0.3)
68
            stream.append(string: "12")
69
        }
70
        
71
        readQueue1.waitUntilAllOperationsAreFinished()
72
        readQueue2.waitUntilAllOperationsAreFinished()
73
        writeQeuue.waitUntilAllOperationsAreFinished()
74
        
75
        // both byte1 and byte2 might have "1" or "2" values depending on the order of execution of the operations
76
        XCTAssertNotNil(byte1)
77
        XCTAssertNotNil(byte2)
78
        XCTAssertNotEqual(byte1, byte2)
79
    }
80
}
81