Raise TLE, RE error when run fail test case

Author: ShotaKashihara

Sources/AtCoderLibrary/Command/New/Generator/Test.swift

@@ -8,7 +8,9 @@ struct Test: Generator {
         import XCTest
         import TestLibrary
 
-        final class \(className): XCTestCase {
+        final class \(className): XCTestCase, TimeLimit {
+            let timeLimit: TimeInterval = \(Double(problem.timeLimit)/1000)
+
             func testExample() throws {
                 let cases: [TestCase] = [
         \(problem.tests.map { """

Sources/AtCoderLibrary/Command/New/Generator/TestLibrary.swift

@@ -6,44 +6,72 @@ struct TestLibrary: Generator {
         import XCTest
         import class Foundation.Bundle
 
+        public protocol TimeLimit {
+            var timeLimit: TimeInterval { get }
+        }
+
         public typealias TestCase = (file: StaticString, line: UInt, input: String, expected: String)
 
-        public extension XCTestCase {
+        public extension TimeLimit where Self: XCTestCase {
             func solve(file: StaticString, line: UInt, input: String, expected: String) throws {
                 // Some of the APIs that we use below are available in macOS 10.13 and above.
                 guard #available(macOS 10.13, *) else {
                     return
                 }
-
-                let testTarget = String(describing: type(of: self)).replacingOccurrences(of: \"Tests\", with: \"\")
+                var error = ""
+                let exp = expectation(description: "")
+                let testTarget = String(describing: type(of: self)).replacingOccurrences(of: "Tests", with: "")
                 let binary = productsDirectory.appendingPathComponent(testTarget)
                 let process = Process()
+                
+                addTeardownBlock {
+                    if process.isRunning {
+                        process.terminate()
+                    }
+                }
+                
                 process.executableURL = binary
                 let pipeInput = Pipe()
                 process.standardInput = pipeInput
                 let pipeOutput = Pipe()
                 process.standardOutput = pipeOutput
                 let pipeError = Pipe()
                 process.standardError = pipeError
-                try process.run()
-                pipeInput.fileHandleForWriting.write(input.data(using: .utf8)!)
-                pipeInput.fileHandleForWriting.closeFile()
-                process.waitUntilExit()
-                let error = String(data: pipeError.fileHandleForReading.readDataToEndOfFile(), encoding: .utf8)!
-                if !error.isEmpty {
-                    XCTFail(error, file: file, line: line)
-                    return
+                
+                DispatchQueue.global().async {
+                    do {
+                        try process.run()
+                        pipeInput.fileHandleForWriting.write(input.data(using: .utf8)!)
+                        pipeInput.fileHandleForWriting.closeFile()
+                        process.waitUntilExit()
+                        exp.fulfill()
+                        error = String(data: pipeError.fileHandleForReading.readDataToEndOfFile(), encoding: .utf8)!
+                    } catch (let e) {
+                        error = e.localizedDescription
+                    }
+                }
+                let result = XCTWaiter.wait(for: [exp], timeout: timeLimit)
+                switch result {
+                case .completed:
+                    if error.isEmpty {
+                        let data = pipeOutput.fileHandleForReading.readDataToEndOfFile()
+                        let output = String(data: data, encoding: .utf8)!
+                        XCTAssertEqual(output, expected, file: file, line: line)
+                    } else {
+                        XCTFail("RE: \\(error)", file: file, line: line)
+                    }
+                case .timedOut:
+                    XCTFail("TLE: Exceeded timeout of \\(timeLimit) seconds", file: file, line: line)
+                default:
+                    XCTFail("Unrecognized error.", file: file, line: line)
                 }
-                let data = pipeOutput.fileHandleForReading.readDataToEndOfFile()
-                let output = String(data: data, encoding: .utf8)!
-                XCTAssertEqual(output, expected, file: file, line: line)
             }
 
             private var productsDirectory: URL {
-                for bundle in Bundle.allBundles where bundle.bundlePath.hasSuffix(\".xctest\") {
+                for bundle in Bundle.allBundles where bundle.bundlePath.hasSuffix(".xctest") {
                     return bundle.bundleURL.deletingLastPathComponent()
                 }
-                fatalError(\"couldn't find the products directory\")
+                fatalError("couldn't find the products directory")
             }
         }
         """

Tests/AtCoderLibraryTests/Command/New/Generator/TestTests.swift

@@ -14,14 +14,16 @@ final class TestTests: XCTestCase {
             name: "",
             context: .init(contest: .empty, alphabet: "A"),
             memoryLimit: 1000,
-            timeLimit: 1000
+            timeLimit: 2000
         )
         let test = Test(problem: problem)
         let expected = """
         import XCTest
         import TestLibrary
 
-        final class ATests: XCTestCase {
+        final class ATests: XCTestCase, TimeLimit {
+            let timeLimit: TimeInterval = 2.0
+
             func testExample() throws {
                 let cases: [TestCase] = [
                     (#filePath, #line, "input1", "output1"),