Tests: cover testing multiple async executable targets (#6986)

Test [swiftlang/swift#69113: \[Concurrency\] Hide async_Main from other
object files](swiftlang/swift#69113)

Merge after the above fix will be merged 

### Motivation:

To verify that multiple executable targets with async entrypoints can be
linked within a single test executable

Resolves rdar://114231968

### Modifications:

Added a new test case

Author: kateinoigakukun

Fixtures/Miscellaneous/TestableAsyncExe/Package.swift

@@ -0,0 +1,29 @@
+// swift-tools-version: 5.5
+import PackageDescription
+
+let package = Package(
+    name: "TestableAsyncExe",
+    targets: [
+        .executableTarget(
+            name: "TestableAsyncExe1"
+        ),
+        .executableTarget(
+            name: "TestableAsyncExe2"
+        ),
+        .executableTarget(
+            name: "TestableAsyncExe3"
+        ),
+        .executableTarget(
+            name: "TestableAsyncExe4"
+        ),
+        .testTarget(
+            name: "TestableAsyncExeTests",
+            dependencies: [
+                "TestableAsyncExe1",
+                "TestableAsyncExe2",
+                "TestableAsyncExe3",
+                "TestableAsyncExe4",
+            ]
+        ),
+    ]
+)

Fixtures/Miscellaneous/TestableAsyncExe/Sources/TestableAsyncExe1/main.swift

@@ -0,0 +1,5 @@
+public func GetAsyncGreeting1() async -> String {
+    return "Hello, async world"
+}
+
+await print("\(GetAsyncGreeting1())!")

Fixtures/Miscellaneous/TestableAsyncExe/Sources/TestableAsyncExe2/main.swift

@@ -0,0 +1,5 @@
+public func GetAsyncGreeting2() async -> String {
+    return "Hello, async planet"
+}
+
+await print("\(GetAsyncGreeting2())!")

Fixtures/Miscellaneous/TestableAsyncExe/Sources/TestableAsyncExe3/NonMain.swift

@@ -0,0 +1,10 @@
+@main
+struct AsyncMain3 {
+  static func main() async {
+    print(await getGreeting3())
+  }
+
+  static func getGreeting3() async -> String {
+      return "Hello, async galaxy"
+  }
+}

Fixtures/Miscellaneous/TestableAsyncExe/Sources/TestableAsyncExe4/NonMain.swift

@@ -0,0 +1,10 @@
+@main
+struct AsyncMain4 {
+  static func main() async {
+    print(await getGreeting4())
+  }
+
+  static func getGreeting4() async -> String {
+      return "Hello, async universe"
+  }
+}

Fixtures/Miscellaneous/TestableAsyncExe/Tests/TestableAsyncExeTests/TestableAsyncExeTests.swift

@@ -0,0 +1,25 @@
+import XCTest
+@testable import TestableAsyncExe1
+@testable import TestableAsyncExe2
+@testable import TestableAsyncExe3
+@testable import TestableAsyncExe4
+
+final class TestableAsyncExeTests: XCTestCase {
+    func testExample() async throws {
+        let greeting1 = await GetAsyncGreeting1()
+        print(greeting1)
+        XCTAssertEqual(greeting1, "Hello, async world")
+
+        let greeting2 = await GetAsyncGreeting2()
+        print(greeting2)
+        XCTAssertEqual(greeting2, "Hello, async planet")
+
+        let greeting3 = await AsyncMain3.getGreeting3()
+        print(greeting3)
+        XCTAssertEqual(greeting3, "Hello, async galaxy")
+
+        let greeting4 = await AsyncMain4.getGreeting4()
+        print(greeting4)
+        XCTAssertEqual(greeting4, "Hello, async universe")
+    }
+}

Tests/FunctionalTests/MiscellaneousTests.swift

@@ -425,6 +425,28 @@ class MiscellaneousTestCase: XCTestCase {
         }
     }
 
+    func testTestsCanLinkAgainstAsyncExecutable() throws {
+        #if compiler(<5.10)
+        try XCTSkipIf(true, "skipping because host compiler doesn't have a fix for symbol conflicts yet")
+        #endif
+        try fixture(name: "Miscellaneous/TestableAsyncExe") { fixturePath in
+            let (stdout, stderr) = try executeSwiftTest(fixturePath)
+            // in "swift test" build output goes to stderr
+            XCTAssertMatch(stderr, .contains("Linking TestableAsyncExe1"))
+            XCTAssertMatch(stderr, .contains("Linking TestableAsyncExe2"))
+            XCTAssertMatch(stderr, .contains("Linking TestableAsyncExe3"))
+            XCTAssertMatch(stderr, .contains("Linking TestableAsyncExe4"))
+            XCTAssertMatch(stderr, .contains("Linking TestableAsyncExePackageTests"))
+            XCTAssertMatch(stderr, .contains("Build complete!"))
+            // in "swift test" test output goes to stdout
+            XCTAssertMatch(stdout, .contains("Executed 1 test"))
+            XCTAssertMatch(stdout, .contains("Hello, async world"))
+            XCTAssertMatch(stdout, .contains("Hello, async planet"))
+            XCTAssertMatch(stdout, .contains("Hello, async galaxy"))
+            XCTAssertMatch(stdout, .contains("Hello, async universe"))
+        }
+    }
+
     func testExecutableTargetMismatch() throws {
         try fixture(name: "Miscellaneous/TargetMismatch") { path in
             do {