stats/Tests/RAM.swift at ac66b1a03b90c98bf2be416e44622be83752ef92 · exelban/stats · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
//
//  RAM.swift
//  Tests
//
//  Created by Serhiy Mytrovtsiy on 16/04/2022.
//  Using Swift 5.0.
//  Running on macOS 10.15.
//
//  Copyright © 2022 Serhiy Mytrovtsiy. All rights reserved.
//

import XCTest
import RAM
import Kit

class RAM: XCTestCase {
    func testProcessReader_parseProcess() throws {
        var process = ProcessReader.parseProcess("3127  lldb-rpc-server  611M")
        XCTAssertEqual(process.pid, 3127)
        XCTAssertEqual(process.name, "lldb-rpc-server")
        XCTAssertEqual(process.usage, 611 * Double(1000 * 1000))

        process = ProcessReader.parseProcess("257   WindowServer     210M")
        XCTAssertEqual(process.pid, 257)
        XCTAssertEqual(process.name, "WindowServer")
        XCTAssertEqual(process.usage, 210 * Double(1000 * 1000))

        process = ProcessReader.parseProcess("7752  phpstorm         1819M")
        XCTAssertEqual(process.pid, 7752)
        XCTAssertEqual(process.name, "phpstorm")
        XCTAssertEqual(process.usage, 1819.0 / 1024 * 1000 * Double(1000 * 1000))

        process = ProcessReader.parseProcess("359   NotificationCent 62M")
        XCTAssertEqual(process.pid, 359)
        XCTAssertEqual(process.name, "NotificationCent")
        XCTAssertEqual(process.usage, 62 * Double(1000 * 1000))

        process = ProcessReader.parseProcess("623    SafariCloudHisto 1608K")
        XCTAssertEqual(process.pid, 623)
        XCTAssertEqual(process.name, "SafariCloudHisto")
        XCTAssertEqual(process.usage, (1608/1024) * Double(1000 * 1000))

        process = ProcessReader.parseProcess("174    WindowServer     1442M+ ")
        XCTAssertEqual(process.pid, 174)
        XCTAssertEqual(process.name, "WindowServer")
        XCTAssertEqual(process.usage, 1442 * Double(1000 * 1000))

        process = ProcessReader.parseProcess("329    Finder           488M+ ")
        XCTAssertEqual(process.pid, 329)
        XCTAssertEqual(process.name, "Finder")
        XCTAssertEqual(process.usage, 488 * Double(1000 * 1000))

        process = ProcessReader.parseProcess("7163* AutoCAD LT 2023  11G  ")
        XCTAssertEqual(process.pid, 7163)
        XCTAssertEqual(process.name, "AutoCAD LT 2023")
        XCTAssertEqual(process.usage, 11 * Double(1024 * 1000 * 1000))
    }

    func testKernelTask() throws {
        var process = ProcessReader.parseProcess("0      kernel_task      270M ")
        XCTAssertEqual(process.pid, 0)
        XCTAssertEqual(process.name, "kernel_task")
        XCTAssertEqual(process.usage, 270 * Double(1000 * 1000))

        process = ProcessReader.parseProcess("0     kernel_task      280M")
        XCTAssertEqual(process.pid, 0)
        XCTAssertEqual(process.name, "kernel_task")
        XCTAssertEqual(process.usage, 280 * Double(1000 * 1000))
    }

    func testSizes() throws {
        var process = ProcessReader.parseProcess("0  com.apple.Virtua 8463M")
        XCTAssertEqual(process.pid, 0)
        XCTAssertEqual(process.name, "com.apple.Virtua")
        XCTAssertEqual(process.usage, 8463.0 / 1024 * 1000 * 1000 * 1000)

        process = ProcessReader.parseProcess("0  Safari           658M")
        XCTAssertEqual(process.pid, 0)
        XCTAssertEqual(process.name, "Safari")
        XCTAssertEqual(process.usage, 658 * Double(1000 * 1000))
    }
}

final class ReaderLifecycleTests: XCTestCase {
    private final class ProbeReader: Reader<Int> {
        private let queue = DispatchQueue(label: "io.serhiy.Stats.Tests.ProbeReader")
        private var _readCount: Int = 0
        var onRead: ((Int) -> Void)?

        var readCount: Int {
            self.queue.sync { self._readCount }
        }

        override func read() {
            self.queue.sync {
                self._readCount += 1
                let current = self._readCount
                self.onRead?(current)
            }
            self.callback(self.readCount)
        }
    }

    func testPopupReaderForcesReadWhenReopened() {
        let reader = ProbeReader(.CPU, popup: true)
        reader.unlock()

        let firstRead = expectation(description: "first read")
        reader.onRead = { count in
            if count == 1 {
                firstRead.fulfill()
            }
        }

        reader.start()
        wait(for: [firstRead], timeout: 5)

        reader.pause()

        let secondRead = expectation(description: "second read after reopen")
        reader.onRead = { count in
            if count == 2 {
                secondRead.fulfill()
            }
        }

        reader.start()
        wait(for: [secondRead], timeout: 5)

        reader.stop()
    }

    func testReplayEmitsCachedValueWithoutNewRead() {
        var callbackValues: [Int] = []
        let reader = ProbeReader(.CPU) { value in
            if let value {
                callbackValues.append(value)
            }
        }
        let firstRead = expectation(description: "initial read")
        reader.onRead = { count in
            if count == 1 {
                firstRead.fulfill()
            }
        }

        reader.start()
        wait(for: [firstRead], timeout: 5)

        XCTAssertEqual(reader.readCount, 1)
        let callbacksBeforeReplay = callbackValues.count

        reader.replay()

        XCTAssertEqual(reader.readCount, 1)
        XCTAssertEqual(callbackValues.count, callbacksBeforeReplay + 1)
        XCTAssertEqual(callbackValues.last, 1)

        reader.stop()
    }
}