Files
xtool-mirror/Tests/XToolTests/CommandOutputTests.swift

132 lines
5.3 KiB
Swift

import ConcurrencyExtras
import Dependencies
import Foundation
import Testing
import XUtils
struct CommandOutputTests {
@Test
func dependencyOutputSupportsStringAndVariadicPrinting() {
struct Output: Equatable, Sendable {
var message: String
var stream: CommandOutput.Stream
var flush: Bool
}
let received = LockIsolated<[Output]>([])
withDependencies {
$0.out.write = { data, stream, flush in
received.withValue {
$0.append(Output(message: String(decoding: data, as: UTF8.self), stream: stream, flush: flush))
}
}
} operation: {
d.out.print()
d.out.print("message")
d.out.print("progress", 42, separator: ": ", terminator: "", stream: .stderr, flush: true)
}
#expect(received.value == [
Output(message: "\n", stream: .stdout, flush: false),
Output(message: "message\n", stream: .stdout, flush: false),
Output(message: "progress: 42", stream: .stderr, flush: true),
])
}
@Test(.timeLimit(.minutes(1)))
func fullNonblockingPipePreservesAllBytes() async throws {
let pipe = Pipe()
let writer = FileDescriptor(rawValue: pipe.fileHandleForWriting.fileDescriptor)
let reader = FileDescriptor(rawValue: pipe.fileHandleForReading.fileDescriptor)
let flags = fcntl(writer.rawValue, F_GETFL)
try #require(flags != -1)
try #require(fcntl(writer.rawValue, F_SETFL, flags | O_NONBLOCK) == 0)
// Fill the pipe before invoking the output writer, forcing EAGAIN.
let padding = Data(repeating: 255, count: 4096)
var prefix = Data()
while true {
do {
let count = try padding.withUnsafeBytes { try writer.write($0) }
prefix.append(padding.prefix(count))
} catch let error as Errno where error.rawValue == EAGAIN || error.rawValue == EWOULDBLOCK {
break
}
}
let message = Data([0, 255, 128]) + Data(String(repeating: "output é 🌍\n", count: 100_000).utf8)
let writing = Task.detached {
defer { try? pipe.fileHandleForWriting.close() }
try message.withUnsafeBytes { try writer.writeAllWaiting($0) }
}
// Let the writer encounter the full pipe before draining it.
try await Task.sleep(for: .milliseconds(20))
let received = try await Task.detached {
var received = Data()
var buffer = [UInt8](repeating: 0, count: 1024)
while true {
let count = try buffer.withUnsafeMutableBytes { try reader.read(into: $0) }
if count == 0 { return received }
received.append(contentsOf: buffer.prefix(count))
}
}.value
try await writing.value
#expect(received == prefix + message)
#expect(fcntl(reader.rawValue, F_GETFL) != -1)
}
@Test(.timeLimit(.minutes(1)))
func fullNonblockingPipeWriteCanBeCancelled() async throws {
let pipe = Pipe()
let writer = FileDescriptor(rawValue: pipe.fileHandleForWriting.fileDescriptor)
let flags = fcntl(writer.rawValue, F_GETFL)
try #require(flags != -1)
try #require(fcntl(writer.rawValue, F_SETFL, flags | O_NONBLOCK) == 0)
let padding = Data(repeating: 255, count: 4096)
while true {
do {
_ = try padding.withUnsafeBytes { try writer.write($0) }
} catch let error as Errno where error.rawValue == EAGAIN || error.rawValue == EWOULDBLOCK {
break
}
}
let (started, continuation) = AsyncStream.makeStream(of: Never.self)
let finished = LockIsolated(false)
let writing = Task.detached {
defer {
try? pipe.fileHandleForWriting.close()
finished.setValue(true)
}
continuation.finish()
try padding.withUnsafeBytes { try writer.writeAllWaiting($0) }
}
for await _ in started {}
// Give the writer time to enter poll before cancelling, without draining the pipe.
try await Task.sleep(for: .milliseconds(20))
writing.cancel()
let deadline = ContinuousClock.now.advanced(by: .seconds(30))
while !finished.value && ContinuousClock.now < deadline {
try await Task.sleep(for: .milliseconds(10))
}
if !finished.value {
Issue.record("Cancelled writer did not stop while the pipe remained full")
// Unblock a regressed writer so the test fails instead of hanging.
_ = try pipe.fileHandleForReading.readToEnd()
}
await #expect(throws: CancellationError.self) {
try await writing.value
}
}
@Test
func invalidDescriptorThrowsInsteadOfRaisingAnException() {
let descriptor = FileDescriptor(rawValue: -1)
#expect(throws: Errno.badFileDescriptor) {
try Data("output".utf8).withUnsafeBytes { try descriptor.writeAllWaiting($0) }
}
// Empty output does not attempt a system call.
#expect(throws: Never.self) {
try Data().withUnsafeBytes { try descriptor.writeAllWaiting($0) }
}
}
}