mirror of
https://github.com/apple/swift-system
synced 2026-11-22 04:30:46 +00:00
431 lines
15 KiB
Swift
431 lines
15 KiB
Swift
/*
|
|
This source file is part of the Swift System open source project
|
|
|
|
Copyright (c) 2020 - 2026 Apple Inc. and the Swift System project authors
|
|
Licensed under Apache License v2.0 with Runtime Library Exception
|
|
|
|
See https://swift.org/LICENSE.txt for license information
|
|
*/
|
|
|
|
import XCTest
|
|
|
|
#if SYSTEM_PACKAGE
|
|
@testable import SystemPackage
|
|
#else
|
|
@testable import System
|
|
#endif
|
|
#if canImport(Android)
|
|
import Android
|
|
#elseif os(WASI)
|
|
import CSystem
|
|
#endif
|
|
|
|
@available(System 0.0.1, *)
|
|
final class FileOperationsTest: XCTestCase {
|
|
#if ENABLE_MOCKING && !os(WASI) // Would need to use _getConst funcs from CSystem
|
|
func testSyscalls() {
|
|
let fd = FileDescriptor(rawValue: 1)
|
|
|
|
let rawBuf = UnsafeMutableRawBufferPointer.allocate(byteCount: 100, alignment: 4)
|
|
defer { rawBuf.deallocate() }
|
|
let bufAddr = rawBuf.baseAddress
|
|
let rawFD = fd.rawValue
|
|
let bufCount = rawBuf.count
|
|
let writeBuf = UnsafeRawBufferPointer(rawBuf)
|
|
let writeBufAddr = writeBuf.baseAddress
|
|
|
|
let syscallTestCases: Array<MockTestCase> = [
|
|
MockTestCase(name: "open", .interruptable, "a path", O_RDWR | O_APPEND) {
|
|
retryOnInterrupt in
|
|
_ = try FileDescriptor.open(
|
|
"a path", .readWrite, options: [.append], retryOnInterrupt: retryOnInterrupt)
|
|
},
|
|
|
|
MockTestCase(name: "open", .interruptable, "a path", O_WRONLY | O_CREAT | O_APPEND, 0o777) {
|
|
retryOnInterrupt in
|
|
_ = try FileDescriptor.open(
|
|
"a path", .writeOnly, options: [.create, .append],
|
|
permissions: [.groupReadWriteExecute, .ownerReadWriteExecute, .otherReadWriteExecute],
|
|
retryOnInterrupt: retryOnInterrupt)
|
|
},
|
|
|
|
MockTestCase(name: "read", .interruptable, rawFD, bufAddr, bufCount) {
|
|
retryOnInterrupt in
|
|
_ = try fd.read(into: rawBuf, retryOnInterrupt: retryOnInterrupt)
|
|
},
|
|
|
|
MockTestCase(name: "pread", .interruptable, rawFD, bufAddr, bufCount, 5) {
|
|
retryOnInterrupt in
|
|
_ = try fd.read(fromAbsoluteOffset: 5, into: rawBuf, retryOnInterrupt: retryOnInterrupt)
|
|
},
|
|
|
|
MockTestCase(name: "lseek", .noInterrupt, rawFD, -2, SEEK_END) {
|
|
_ in
|
|
_ = try fd.seek(offset: -2, from: .end)
|
|
},
|
|
|
|
MockTestCase(name: "write", .interruptable, rawFD, writeBufAddr, bufCount) {
|
|
retryOnInterrupt in
|
|
_ = try fd.write(writeBuf, retryOnInterrupt: retryOnInterrupt)
|
|
},
|
|
|
|
MockTestCase(name: "pwrite", .interruptable, rawFD, writeBufAddr, bufCount, 7) {
|
|
retryOnInterrupt in
|
|
_ = try fd.write(toAbsoluteOffset: 7, writeBuf, retryOnInterrupt: retryOnInterrupt)
|
|
},
|
|
|
|
MockTestCase(name: "close", .noInterrupt, rawFD) {
|
|
_ in
|
|
_ = try fd.close()
|
|
},
|
|
|
|
MockTestCase(name: "dup", .interruptable, rawFD) { retryOnInterrupt in
|
|
_ = try fd.duplicate(retryOnInterrupt: retryOnInterrupt)
|
|
},
|
|
|
|
MockTestCase(name: "dup2", .interruptable, rawFD, 42) { retryOnInterrupt in
|
|
_ = try fd.duplicate(as: FileDescriptor(rawValue: 42),
|
|
retryOnInterrupt: retryOnInterrupt)
|
|
},
|
|
]
|
|
|
|
for test in syscallTestCases { test.runAllTests() }
|
|
}
|
|
#endif // ENABLE_MOCKING && !os(WASI)
|
|
|
|
func testWriteFromEmptyBuffer() throws {
|
|
#if os(Windows)
|
|
let fd = try FileDescriptor.open(FilePath("NUL"), .writeOnly)
|
|
#else
|
|
let fd = try FileDescriptor.open(FilePath("/dev/null"), .writeOnly)
|
|
#endif
|
|
let written1 = try fd.write(toAbsoluteOffset: 0, .init(start: nil, count: 0))
|
|
XCTAssertEqual(written1, 0)
|
|
|
|
let pointer = UnsafeMutableRawPointer.allocate(byteCount: 8, alignment: 8)
|
|
defer { pointer.deallocate() }
|
|
let empty = UnsafeRawBufferPointer(start: pointer, count: 0)
|
|
let written2 = try fd.write(toAbsoluteOffset: 0, empty)
|
|
XCTAssertEqual(written2, 0)
|
|
}
|
|
|
|
#if os(Windows)
|
|
// Generate a file containing random bytes; this should not be used
|
|
// for cryptography, it's just for testing.
|
|
func generateRandomData(at path: FilePath, count: Int) throws {
|
|
let fd = try FileDescriptor.open(path, .readWrite,
|
|
options: [.create, .truncate])
|
|
defer {
|
|
try! fd.close()
|
|
}
|
|
let data = [UInt8](
|
|
sequence(first: 0,
|
|
next: {
|
|
_ in UInt8.random(in: UInt8.min...UInt8.max)
|
|
}).dropFirst().prefix(count)
|
|
)
|
|
|
|
try data.withUnsafeBytes {
|
|
_ = try fd.write($0)
|
|
}
|
|
}
|
|
#endif
|
|
|
|
func testReadToEmptyBuffer() throws {
|
|
try withTemporaryFilePath(basename: "testReadToEmptyBuffer") { path in
|
|
#if os(Windows)
|
|
// Windows doesn't have an equivalent to /dev/random, so generate
|
|
// some random bytes and write them to a file for the next step.
|
|
let randomPath = path.appending("random.txt")
|
|
try generateRandomData(at: randomPath, count: 16)
|
|
let fd = try FileDescriptor.open(randomPath, .readOnly)
|
|
#else // !os(Windows)
|
|
let fd = try FileDescriptor.open(FilePath("/dev/random"), .readOnly)
|
|
#endif
|
|
let read1 = try fd.read(fromAbsoluteOffset: 0, into: .init(start: nil, count: 0))
|
|
XCTAssertEqual(read1, 0)
|
|
|
|
let pointer = UnsafeMutableRawPointer.allocate(byteCount: 8, alignment: 8)
|
|
defer { pointer.deallocate() }
|
|
let empty = UnsafeMutableRawBufferPointer(start: pointer, count: 0)
|
|
let read2 = try fd.read(fromAbsoluteOffset: 0, into: empty)
|
|
XCTAssertEqual(read2, 0)
|
|
}
|
|
}
|
|
|
|
func testHelpers() {
|
|
// TODO: Test writeAll, writeAll(toAbsoluteOffset), closeAfter
|
|
}
|
|
|
|
#if !os(WASI) // WASI has no pipe
|
|
@available(System 1.1.0, *)
|
|
func testAdHocPipe() throws {
|
|
// Ad-hoc test testing `Pipe` functionality.
|
|
// We cannot test `Pipe` using `MockTestCase` because it calls `pipe` with a pointer to an array local to the `Pipe`, the address of which we do not know prior to invoking `Pipe`.
|
|
let pipe = try FileDescriptor.pipe()
|
|
try pipe.readEnd.closeAfter {
|
|
try pipe.writeEnd.closeAfter {
|
|
var abc = "abc"
|
|
try abc.withUTF8 {
|
|
_ = try pipe.writeEnd.write(UnsafeRawBufferPointer($0))
|
|
}
|
|
let readLen = 3
|
|
let readBytes = try Array<UInt8>(unsafeUninitializedCapacity: readLen) { buf, count in
|
|
count = try pipe.readEnd.read(into: UnsafeMutableRawBufferPointer(buf))
|
|
}
|
|
XCTAssertEqual(readBytes, Array(abc.utf8))
|
|
}
|
|
}
|
|
}
|
|
|
|
func testAdHocPipeWithOptions() throws {
|
|
#if !SYSTEM_PACKAGE_DARWIN || canImport(Darwin, _version: 428)
|
|
guard #available(macOS 27.0, iOS 27.0, watchOS 27.0, tvOS 27.0, visionOS 27.0, *) else {
|
|
throw XCTSkip("pipe2 and PipeOptions require Darwin 27 or newer")
|
|
}
|
|
// Ad-hoc test: `MockTestCase` can't match the pointer to the local array
|
|
// that `pipe` receives, because its address isn't known in advance.
|
|
let options: FileDescriptor.PipeOptions = [.closeOnExec]
|
|
let pipe: (readEnd: FileDescriptor, writeEnd: FileDescriptor)
|
|
pipe = try FileDescriptor.pipe(options: options)
|
|
try pipe.readEnd.closeAfter {
|
|
try pipe.writeEnd.closeAfter {
|
|
var abc = "abc"
|
|
try abc.withUTF8 {
|
|
_ = try pipe.writeEnd.write(UnsafeRawBufferPointer($0))
|
|
}
|
|
let readLen = 3
|
|
let readBytes = try Array<UInt8>(unsafeUninitializedCapacity: readLen) {
|
|
buf, count in
|
|
count = try pipe.readEnd.read(into: UnsafeMutableRawBufferPointer(buf))
|
|
}
|
|
XCTAssertEqual(readBytes, Array(abc.utf8))
|
|
}
|
|
}
|
|
#else
|
|
throw XCTSkip("pipe2 requires a Darwin SDK for anyAppleOS 27 or newer")
|
|
#endif
|
|
}
|
|
|
|
func testAdHocPipeCloseOnFork() throws {
|
|
#if canImport(Darwin, _version: 428)
|
|
guard #available(macOS 27.0, iOS 27.0, watchOS 27.0, tvOS 27.0, visionOS 27.0, *) else {
|
|
throw XCTSkip("pipe2 and PipeOptions require anyAppleOS 27 or newer")
|
|
}
|
|
// System spells O_CLOFORK as a literal on Darwin.
|
|
XCTAssertEqual(FileDescriptor.PipeOptions.closeOnFork.rawValue, O_CLOFORK)
|
|
let pipe = try FileDescriptor.pipe(options: .closeOnFork)
|
|
try pipe.readEnd.closeAfter {
|
|
try pipe.writeEnd.closeAfter {
|
|
let flags = fcntl(pipe.readEnd.rawValue, F_GETFD)
|
|
XCTAssertEqual(flags & FD_CLOFORK, FD_CLOFORK)
|
|
}
|
|
}
|
|
#elseif os(FreeBSD)
|
|
let pipe: (readEnd: FileDescriptor, writeEnd: FileDescriptor)
|
|
do {
|
|
pipe = try FileDescriptor.pipe(options: .closeOnFork)
|
|
} catch {
|
|
if (error as? Errno) == .invalidArgument {
|
|
throw XCTSkip("pipe2 does not support O_CLOFORK before FreeBSD 15")
|
|
}
|
|
throw error
|
|
}
|
|
try pipe.readEnd.closeAfter {
|
|
try pipe.writeEnd.closeAfter {
|
|
let flags = fcntl(pipe.readEnd.rawValue, F_GETFD)
|
|
XCTAssertEqual(flags & FD_CLOEXEC, 0)
|
|
XCTAssertNotEqual(flags, 0)
|
|
}
|
|
}
|
|
#else
|
|
throw XCTSkip("O_CLOFORK requires a Darwin SDK for anyAppleOS 27 or newer")
|
|
#endif
|
|
}
|
|
#endif // !os(WASI)
|
|
|
|
#if !os(Windows)
|
|
func testAdHocDuplicate2() throws {
|
|
try withTemporaryFilePath(basename: "test") {
|
|
let path = $0.appending("foo2.txt")
|
|
let fd1 = try FileDescriptor.open(path, .readWrite,
|
|
options: [.create, .truncate],
|
|
permissions: .ownerReadWrite)
|
|
|
|
let fd2 = FileDescriptor(rawValue: 731)
|
|
let fd3 = try fd1.duplicate(as: fd2)
|
|
XCTAssertEqual(fd2, fd3)
|
|
|
|
try fd2.close()
|
|
do {
|
|
try fd3.close()
|
|
XCTFail("Should be unreachable")
|
|
} catch {
|
|
if let error = try? XCTUnwrap(error as? Errno) {
|
|
XCTAssertEqual(error, .badFileDescriptor)
|
|
}
|
|
}
|
|
|
|
// dup2() accepts two equal parameters.
|
|
let fd4 = try fd1.duplicate(as: fd1)
|
|
XCTAssertEqual(fd4, fd1)
|
|
|
|
try fd1.close()
|
|
do {
|
|
try fd4.close()
|
|
XCTFail("Should be unreachable")
|
|
} catch {
|
|
if let error = try? XCTUnwrap(error as? Errno) {
|
|
XCTAssertEqual(error, .badFileDescriptor)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func testAdHocDuplicate3() throws {
|
|
#if !SYSTEM_PACKAGE_DARWIN || canImport(Darwin, _version: 428)
|
|
guard #available(macOS 27.0, iOS 27.0, watchOS 27.0, tvOS 27.0, visionOS 27.0, *) else {
|
|
throw XCTSkip("dup3 and DuplicateOptions require Darwin 27 or newer")
|
|
}
|
|
|
|
try withTemporaryFilePath(basename: "test") {
|
|
let path = $0.appending("foo3.txt")
|
|
|
|
let fd1 = try FileDescriptor.open(path, .readWrite,
|
|
options: [.create, .truncate],
|
|
permissions: .ownerReadWrite)
|
|
|
|
let fd2 = FileDescriptor(rawValue: 731)
|
|
let fd3 = try fd1.duplicate(as: fd2, options: [.closeOnExec])
|
|
XCTAssertEqual(fd2, fd3)
|
|
|
|
try fd2.close()
|
|
do {
|
|
try fd3.close()
|
|
} catch {
|
|
if let error = try? XCTUnwrap(error as? Errno) {
|
|
XCTAssertEqual(error, .badFileDescriptor)
|
|
}
|
|
}
|
|
|
|
// dup3() does not accept two equal parameters.
|
|
do {
|
|
_ = try fd1.duplicate(as: fd1, options: [])
|
|
XCTFail("Should be unreachable")
|
|
} catch {
|
|
if let error = try? XCTUnwrap(error as? Errno) {
|
|
XCTAssertEqual(error, .invalidArgument)
|
|
}
|
|
}
|
|
}
|
|
#else
|
|
throw XCTSkip("dup3 requires a Darwin SDK for anyAppleOS 27 or newer")
|
|
#endif
|
|
}
|
|
#endif // !os(Windows)
|
|
|
|
func testAdHocOpen() {
|
|
// Ad-hoc test touching a file system.
|
|
do {
|
|
// TODO: Test this against a virtual in-memory file system
|
|
try withTemporaryFilePath(basename: "testAdhocOpen") { path in
|
|
let fd = try FileDescriptor.open(path.appending("b.txt"), .readWrite, options: [.create, .truncate], permissions: .ownerReadWrite)
|
|
try fd.closeAfter {
|
|
try fd.writeAll("abc".utf8)
|
|
var def = "def"
|
|
try def.withUTF8 {
|
|
_ = try fd.write(UnsafeRawBufferPointer($0))
|
|
}
|
|
try fd.seek(offset: 1, from: .start)
|
|
|
|
let readLen = 3
|
|
let readBytes = try Array<UInt8>(unsafeUninitializedCapacity: readLen) { (buf, count) in
|
|
count = try fd.read(into: UnsafeMutableRawBufferPointer(buf))
|
|
}
|
|
let preadBytes = try Array<UInt8>(unsafeUninitializedCapacity: readLen) { (buf, count) in
|
|
count = try fd.read(fromAbsoluteOffset: 1, into: UnsafeMutableRawBufferPointer(buf))
|
|
}
|
|
|
|
XCTAssertEqual(readBytes.first!, "b".utf8.first!)
|
|
XCTAssertEqual(readBytes, preadBytes)
|
|
|
|
// TODO: seek
|
|
}
|
|
}
|
|
} catch let err as Errno {
|
|
print("caught \(err))")
|
|
// Should we assert? I'd be interested in knowing if this happened
|
|
XCTAssert(false)
|
|
} catch {
|
|
fatalError("FATAL: `testAdHocOpen`")
|
|
}
|
|
}
|
|
|
|
#if ENABLE_MOCKING
|
|
func testGithubIssues() {
|
|
// https://github.com/apple/swift-system/issues/26
|
|
#if os(WASI)
|
|
let openOptions = _getConst_O_WRONLY() | _getConst_O_CREAT()
|
|
#else
|
|
let openOptions = O_WRONLY | O_CREAT
|
|
#endif
|
|
let issue26 = MockTestCase(
|
|
name: "open", .interruptable, "a path", openOptions, 0o020
|
|
) {
|
|
retryOnInterrupt in
|
|
_ = try FileDescriptor.open(
|
|
"a path", .writeOnly, options: [.create],
|
|
permissions: [.groupWrite],
|
|
retryOnInterrupt: retryOnInterrupt)
|
|
}
|
|
issue26.runAllTests()
|
|
}
|
|
#endif // ENABLE_MOCKING
|
|
|
|
@available(System 1.2.0, *)
|
|
func testResizeFile() throws {
|
|
try withTemporaryFilePath(basename: "testResizeFile") { path in
|
|
let fd = try FileDescriptor.open(path.appending("\(UUID().uuidString).txt"), .readWrite, options: [.create, .truncate], permissions: .ownerReadWrite)
|
|
try fd.closeAfter {
|
|
// File should be empty initially.
|
|
XCTAssertEqual(try fd.fileSize(), 0)
|
|
// Write 3 bytes.
|
|
try fd.writeAll("abc".utf8)
|
|
// File should now be 3 bytes.
|
|
XCTAssertEqual(try fd.fileSize(), 3)
|
|
// Resize to 6 bytes.
|
|
try fd.resize(to: 6)
|
|
// File should now be 6 bytes.
|
|
XCTAssertEqual(try fd.fileSize(), 6)
|
|
// Read in the 6 bytes.
|
|
let readBytes = try Array<UInt8>(unsafeUninitializedCapacity: 6) { (buf, count) in
|
|
try fd.seek(offset: 0, from: .start)
|
|
// Should have read all 6 bytes.
|
|
count = try fd.read(into: UnsafeMutableRawBufferPointer(buf))
|
|
XCTAssertEqual(count, 6)
|
|
}
|
|
// First 3 bytes should be unaffected by resize.
|
|
XCTAssertEqual(Array(readBytes[..<3]), Array("abc".utf8))
|
|
// Extension should be padded with zeros.
|
|
XCTAssertEqual(Array(readBytes[3...]), Array(repeating: 0, count: 3))
|
|
// File should still be 6 bytes.
|
|
XCTAssertEqual(try fd.fileSize(), 6)
|
|
// Resize to 2 bytes.
|
|
try fd.resize(to: 2)
|
|
// File should now be 2 bytes.
|
|
XCTAssertEqual(try fd.fileSize(), 2)
|
|
// Read in file with a buffer big enough for 6 bytes.
|
|
let readBytesAfterTruncation = try Array<UInt8>(unsafeUninitializedCapacity: 6) { (buf, count) in
|
|
try fd.seek(offset: 0, from: .start)
|
|
count = try fd.read(into: UnsafeMutableRawBufferPointer(buf))
|
|
// Should only have read 2 bytes.
|
|
XCTAssertEqual(count, 2)
|
|
}
|
|
// Written content was trunctated.
|
|
XCTAssertEqual(readBytesAfterTruncation, Array("ab".utf8))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|