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

Sources/SWBCSupport/CLibclang.cpp

@@ -12,6 +12,17 @@
 
 #include "CLibclang.h"
 
+#define _GNU_SOURCE
+#include <unistd.h>
+
+int swb_pipe2(int pipefd[2], int flags) {
+    #if defined(_WIN32) || defined(__APPLE__)
+    return pipe(pipefd);
+    #else
+    return pipe2(pipefd, 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,8 @@
 extern "C" {
 #endif
 
+int swb_pipe2(int pipefd[2], 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/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,31 @@ 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(closeOnExec: true)
         self.readEnd = readEnd
         self.writeEnd = writeEnd
     }
 }
 
 extension FileDescriptor {
+    public static func _pipe2(closeOnExec: Bool) 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, closeOnExec ? O_CLOEXEC : Int32(0))
+                }.map { _ in (FileDescriptor(rawValue: fds[0]), FileDescriptor(rawValue: fds[1])) }
+            }
+        }.get()
+    }
+
     public func setBinaryMode() throws {
         #if os(Windows)
         if _setmode(rawValue, _O_BINARY) == -1 {
@@ -38,3 +51,22 @@ extension FileDescriptor {
         #endif
     }
 }
+
+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

Tests/SwiftBuildTests/ConsoleCommands/ServiceConsoleTests.swift

@@ -19,7 +19,7 @@ import SWBUtil
 import WinSDK
 #endif
 
-@Suite(.skipInGitHubActions("failing in the GitHub actions runner environment"), .skipHostOS(.windows))
+@Suite(.skipHostOS(.windows))
 fileprivate struct ServiceConsoleTests {
     @Test
     func emptyInput() async throws {
@@ -59,7 +59,7 @@ fileprivate struct ServiceConsoleTests {
     }
 
     /// Test that the build service shuts down if the host dies.
-    @Test(.skipHostOS(.windows, "PTY not supported on Windows"))
+    @Test(.skipHostOS(.windows, "PTY not supported on Windows")/*, .skipInGitHubActions("failing in the GitHub actions runner environment")*/)
     func serviceShutdown() async throws {
         try await withCLIConnection { cli in
             // Find the service pid.
@@ -92,7 +92,13 @@ fileprivate struct ServiceConsoleTests {
             await #expect(try cli.exitStatus.wasSignaled)
 
             // Now wait for the service subprocess to exit, without any further communication.
-            try await serviceExitPromise.value
+            try await withTimeout(timeout: .seconds(30), description: "Service process exit promise 30-second limit") {
+                try await withTaskCancellationHandler {
+                    try await serviceExitPromise.value
+                } onCancel: {
+                    serviceExitPromise.fail(throwing: CancellationError())
+                }
+            }
         }
     }
 
@@ -146,10 +152,13 @@ extension Processes {
             while true {
                 // We use getpgid() here to detect when the process has exited (it is not a child). Surprisingly, getpgid() is substantially faster than using kill(pid, 0) here because kill still returns success for zombies, and the service has been reparented to launchd. // ignore-unacceptable-language; POSIX API
                 do {
-                    if getpgid(pid) < 0 {
+                    let parent = getpgid(pid)
+                    let err = errno
+                    print("getpgid = \(parent), errno = \(err)")
+                    if parent < 0 {
                         // We expect the signal to eventually fail with "No such process".
-                        if errno != ESRCH {
-                            throw StubError.error("unexpected exit code: \(errno)")
+                        if err != ESRCH {
+                            throw StubError.error("unexpected exit code: \(err)")
                         }
                         break
                     }