Experiment: disable hanging tests

Author: jakepetroules

.github/workflows/pull_request.yml

@@ -13,9 +13,9 @@ jobs:
     name: Test
     uses: swiftlang/github-workflows/.github/workflows/swift_package_test.yml@main
     with:
-      linux_os_versions: '["noble", "jammy", "focal", "rhel-ubi9"]'
+      linux_os_versions: '["noble", "jammy", "rhel-ubi9"]'
       linux_pre_build_command: |
-        if command -v apt-get >/dev/null 2>&1 ; then # bookworm, noble, jammy, focal
+        if command -v apt-get >/dev/null 2>&1 ; then # bookworm, noble, jammy
           apt-get update -y
 
           # Build dependencies
@@ -41,7 +41,7 @@ jobs:
           yum install -y yum-utils
           debuginfo-install -y glibc
         fi
-      linux_build_command: 'swift test --no-parallel'
+      linux_build_command: 'swift test --no-parallel --filter serviceShutdown'
       linux_swift_versions: '["nightly-main", "nightly-6.2"]'
       windows_swift_versions: '["nightly-main"]'
       windows_build_command: 'swift test --no-parallel'

Sources/SWBCSupport/CLibclang.cpp

@@ -12,6 +12,39 @@
 
 #include "CLibclang.h"
 
+#define _GNU_SOURCE
+#include <unistd.h>
+#include <fcntl.h>
+
+int swb_pipe2(int pipefd[2], int flags) {
+    #if defined(_WIN32) || defined(__APPLE__)
+    int ret = pipe(pipefd);
+    #ifndef _WIN32
+    if (ret != -1) {
+        fcntl(pipefd[0], F_SETFD, FD_CLOEXEC);
+        fcntl(pipefd[1], F_SETFD, FD_CLOEXEC);
+    }
+    #endif
+    return ret;
+    #else
+    return pipe2(pipefd, flags);
+    #endif
+}
+
+int swb_dup3(int oldfd, int newfd, int flags) {
+    #if defined(_WIN32) || defined(__APPLE__)
+    int ret = dup2(oldfd, newfd);
+    #ifndef _WIN32
+    if (ret != -1) {
+        fcntl(newfd, F_SETFD, FD_CLOEXEC);
+    }
+    #endif
+    return ret;
+    #else
+    return dup3(oldfd, newfd, flags);
+    #endif
+}
+
 // FIXME: Horrible workaround for ::gets not being found by cstdio, on Ubuntu
 // 14.04 in C++14 mode.
 #if defined(__linux) && (defined __cplusplus && __cplusplus > 201103L)

Sources/SWBCSupport/CLibclang.h

@@ -25,6 +25,9 @@
 extern "C" {
 #endif
 
+int swb_pipe2(int pipefd[2], int flags);
+int swb_dup3(int oldfd, int newfd, int flags);
+
 typedef struct libclang_source_range_t_* libclang_source_range_t;
 typedef struct libclang_diagnostic_set_t_* libclang_diagnostic_set_t;
 typedef struct libclang_diagnostic_t_* libclang_diagnostic_t;

Sources/SWBServiceCore/ServiceEntryPoint.swift

@@ -60,22 +60,22 @@ extension Service {
         let nullPath = Path.null
         let nullFd: FileDescriptor
         do {
-            nullFd = try FileDescriptor.open(FilePath(nullPath.str), .readOnly)
+            nullFd = try FileDescriptor.open(FilePath(nullPath.str), .readOnly, options: .closeOnExec)
         } catch {
             throw StubError.error("unable to open \(nullPath.str): \(error)")
         }
 
         // (dup2 closes its 2nd parameter)
         do {
-            _ = try nullFd.duplicate(as: .standardInput)
+            _ = try nullFd._duplicate3(as: .standardInput, options: .closeOnExec)
         } catch {
             throw StubError.error("unable to dup \(nullPath.str) to stdin: \(error)")
         }
 
         // Now remap stdout to stderr, so normal print statements go to the console output stream.
         // (dup2 closes its 2nd parameter)
         do {
-            _ = try FileDescriptor.standardError.duplicate(as: .standardOutput)
+            _ = try FileDescriptor.standardError._duplicate3(as: .standardOutput, options: .closeOnExec)
         } catch {
             throw StubError.error("unable to dup stderr to stdout: \(error)")
         }

Sources/SWBTestSupport/SkippedTestSupport.swift

@@ -172,6 +172,7 @@ extension Trait where Self == Testing.ConditionTrait {
     }
 
     package static func skipInGitHubActions(_ comment: Comment? = nil) -> Self {
+        return disabled("its broke")
         return .skipIfEnvironmentVariableSet(key: "GITHUB_ACTIONS")
     }
 

Sources/SWBUtil/IO.swift

@@ -18,18 +18,37 @@ public import System
 public import SystemPackage
 #endif
 
+private import SWBCSupport
+
 public struct IOPipe: Sendable {
     public let readEnd: FileDescriptor
     public let writeEnd: FileDescriptor
 
     public init() throws {
-        let (readEnd, writeEnd) = try FileDescriptor.pipe()
+        let (readEnd, writeEnd) = try FileDescriptor._pipe2(options: .closeOnExec)
         self.readEnd = readEnd
         self.writeEnd = writeEnd
     }
 }
 
 extension FileDescriptor {
+    public static func _pipe2(options: _PipeOptions) throws -> (readEnd: FileDescriptor, writeEnd: FileDescriptor) {
+        var fds: (Int32, Int32) = (-1, -1)
+        return try withUnsafeMutablePointer(to: &fds) { pointer in
+            pointer.withMemoryRebound(to: Int32.self, capacity: 2) { fds in
+                valueOrErrno(retryOnInterrupt: false) {
+                    swb_pipe2(fds, options.rawValue)
+                }.map { _ in (FileDescriptor(rawValue: fds[0]), FileDescriptor(rawValue: fds[1])) }
+            }
+        }.get()
+    }
+
+    public func _duplicate3(as target: FileDescriptor, retryOnInterrupt: Bool = true, options: _DuplicateOptions) throws -> FileDescriptor {
+        try valueOrErrno(retryOnInterrupt: retryOnInterrupt) {
+            return swb_dup3(self.rawValue, target.rawValue, options.rawValue)
+        }.map(FileDescriptor.init(rawValue:)).get()
+    }
+
     public func setBinaryMode() throws {
         #if os(Windows)
         if _setmode(rawValue, _O_BINARY) == -1 {
@@ -38,3 +57,52 @@ extension FileDescriptor {
         #endif
     }
 }
+
+#if os(Windows)
+fileprivate let O_CLOEXEC: CInt = 0
+
+extension FileDescriptor.OpenOptions {
+    public static var closeOnExec: FileDescriptor.OpenOptions { .init(rawValue: O_CLOEXEC) }
+}
+#endif
+
+extension FileDescriptor {
+    public struct _PipeOptions: OptionSet, Sendable, Hashable, Codable {
+        public var rawValue: CInt
+
+        public init(rawValue: CInt) {
+            self.rawValue = rawValue
+        }
+
+        public static var closeOnExec: Self { .init(rawValue: O_CLOEXEC) }
+    }
+
+    public struct _DuplicateOptions: OptionSet, Sendable, Hashable, Codable {
+        public var rawValue: CInt
+
+        public init(rawValue: CInt) {
+            self.rawValue = rawValue
+        }
+
+        public static var closeOnExec: Self { .init(rawValue: O_CLOEXEC) }
+    }
+}
+
+fileprivate func valueOrErrno<I: FixedWidthInteger>(
+    _ i: I
+) -> Result<I, Errno> {
+    i == -1 ? .failure(Errno(rawValue: errno)) : .success(i)
+}
+
+fileprivate func valueOrErrno<I: FixedWidthInteger>(
+    retryOnInterrupt: Bool, _ f: () -> I
+) -> Result<I, Errno> {
+    repeat {
+        switch valueOrErrno(f()) {
+        case .success(let r): return .success(r)
+        case .failure(let err):
+            guard retryOnInterrupt && err == .interrupted else { return .failure(err) }
+            break
+        }
+    } while true
+}

Tests/SWBTaskExecutionTests/PBXCpTests.swift

@@ -442,21 +442,32 @@ fileprivate struct PBXCpTests: CoreBasedTests {
     fileprivate let buffer0 = [UInt8](repeating: 0xAA, count: 1024 * 513)
     fileprivate let buffer1 = [UInt8](repeating: 0x55, count: 1024 * 513)
 
-    @Test(.skipHostOS(.windows, "LocalFS needs to use stat64 on windows...."),
-          .skipInGitHubActions("GitHub action runners do not have enough storage space for this test"))
+    @Test
     func largerFile() async throws {
-        try await withTemporaryDirectory { tmp in
+        let iterationCount = 4096
+        let buffers = buffer0 + buffer1
+        let requiredSpace = ByteCount(Int64(buffers.count * (iterationCount + 1) * 2 * 2))
+        let fs = localFS
+        try await withTemporaryDirectory(fs: fs) { tmp in
+            // If the available free disk space on this filesystem is less than twice the amount of data the test is expected to write (2 copies of the file times 2), skip it
+            if let freeSpace = try fs.getFreeDiskSpace(tmp), freeSpace < requiredSpace {
+                withKnownIssue {
+                    Issue.record("There is not enough free disk space to run this test (required: \(requiredSpace), free: \(freeSpace))")
+                    return
+                }
+            }
+
             // Test copying a large file.
             let src = tmp.join("src")
             let sName = src.join("file")
             let dst = tmp.join("dst")
             let dName = dst.join("file")
-            let fs = localFS
+
 
             try fs.createDirectory(src, recursive: true)
             var size = 0
             try await fs.write(sName) { fd in
-                for _ in 0...4096 {
+                for _ in 0...iterationCount {
                     size += try fd.writeAll(buffer0)
                     size += try fd.writeAll(buffer1)
                 }
@@ -470,8 +481,10 @@ fileprivate struct PBXCpTests: CoreBasedTests {
                     "copying src/...\n   copying file...\n    \(size) bytes\n"
                 ))
                 // Check permissions
-                let dstPerm = try fs.getFilePermissions(dName)
-                #expect(dstPerm == 0o644) // files are created with u+rw, g+wr, o+rw (and +x if src is executable) permissions and umask will adjust
+                if try ProcessInfo.processInfo.hostOperatingSystem() != .windows {
+                    let dstPerm = try fs.getFilePermissions(dName)
+                    #expect(dstPerm == 0o644) // files are created with u+rw, g+wr, o+rw (and +x if src is executable) permissions and umask will adjust
+                }
                 #expect(FileManager.default.contentsEqual(atPath: sName.str, andPath: dName.str))
             }
         }

Tests/SwiftBuildTests/ConsoleCommands/BuildCommandTests.swift

@@ -17,7 +17,7 @@ import SWBUtil
 import Testing
 import SwiftBuildTestSupport
 
-@Suite(.skipHostOS(.windows), .skipInGitHubActions("failing in the GitHub actions runner environment"))
+@Suite(.skipHostOS(.windows))
 fileprivate struct BuildCommandTests {
     private let commandSequenceCodec: any CommandSequenceEncodable = LLVMStyleCommandCodec()
 

Tests/SwiftBuildTests/ConsoleCommands/CreateXCFrameworkCommandTests.swift

@@ -17,7 +17,7 @@ import SWBTestSupport
 
 // Note: The functionality of this class is heavily unit tested in `XCFrameworkTests.swift`. These tests are only to ensure that the command is indeed hooked up and registered properly.
 
-@Suite(.skipInGitHubActions("failing in the GitHub actions runner environment"), .skipHostOS(.windows))
+@Suite(.skipHostOS(.windows))
 fileprivate struct CreateXCFrameworkCommandTests {
     @Test
     func commandInvocation() async throws {

Tests/SwiftBuildTests/ConsoleCommands/GeneralCommandsTests.swift

@@ -15,7 +15,7 @@ import SwiftBuild
 import SWBTestSupport
 import SWBUtil
 
-@Suite(.skipInGitHubActions("failing in the GitHub actions runner environment"), .skipHostOS(.windows))
+@Suite(.skipHostOS(.windows))
 fileprivate struct GeneralCommandsTests {
     @Test(.skipHostOS(.windows), // PTY not supported on Windows
         .requireHostOS(.macOS)) // something with terminal echo is different on macOS vs Linux