How to use testDeclaredType_parsesMultipleGenericComponentsQualifiedType method of DeclaredTypeTests class

...380    let actual = DeclaredType(from: "Foundation.Dictionary<String, Int>.Element")381    XCTAssertEqual(String(reflecting: actual), "DeclaredType(Single(Foundation.Dictionary<DeclaredType(Single(String)), DeclaredType(Single(Int))>.Element))")382  }383  384  func testDeclaredType_parsesMultipleGenericComponentsQualifiedType() {385    let actual = DeclaredType(from: "Foundation.Dictionary<String, Int>.Array<String>")386    XCTAssertEqual(String(reflecting: actual), "DeclaredType(Single(Foundation.Dictionary<DeclaredType(Single(String)), DeclaredType(Single(Int))>.Array<DeclaredType(Single(String))>))")387  }388  389  func testDeclaredType_parsesFullyQualifiedTupleType() {390    let actual = DeclaredType(from: "(Foundation.Array.Element, Foundation.NSObject)")391    XCTAssertEqual(String(reflecting: actual), "DeclaredType(Tuple((DeclaredType(Single(Foundation.Array.Element)), DeclaredType(Single(Foundation.NSObject)))))")392  }393  394  func testDeclaredType_parsesFullyQualifiedFunctionParameterType() {395    let actual = DeclaredType(from: "(Foundation.Array.Element, Foundation.NSObject) -> Void")396    XCTAssertEqual(String(reflecting: actual), "DeclaredType(Single(Function((Parameter(DeclaredType(Single(Foundation.Array.Element))), Parameter(DeclaredType(Single(Foundation.NSObject)))) -> DeclaredType(Single(Void)))))")397    XCTAssertTrue(actual.isFunction)398  }...

1DeclaredTypeTests().testDeclaredType_parsesMultipleGenericComponentsQualifiedType()2DeclaredTypeTests().testDeclaredType_parsesMultipleGenericComponentsUnqualifiedType()3DeclaredTypeTests().testDeclaredType_parsesSingleGenericComponent()4DeclaredTypeTests().testDeclaredType_parsesSingleGenericComponentQualifiedType()5DeclaredTypeTests().testDeclaredType_parsesSingleGenericComponentUnqualifiedType()6DeclaredTypeTests().testDeclaredType_parsesSingleGenericComponentWithGenericArgument()7DeclaredTypeTests().testDeclaredType_parsesSingleGenericComponentWithGenericArgumentQualifiedType()8DeclaredTypeTests().testDeclaredType_parsesSingleGenericComponentWithGenericArgumentUnqualifiedType()9DeclaredTypeTests().testDeclaredType_parsesSingleGenericComponentWithGenericArguments()10DeclaredTypeTests().testDeclaredType_parsesSingleGenericComponentWithGenericArgumentsQualifiedType()11DeclaredTypeTests().testDeclaredType_parsesSingleGenericComponentWithGenericArgumentsUnqualifiedType()

1import XCTest2import class Foundation.Bundle3final class DeclaredTypeTests: XCTestCase {4    func testDeclaredType_parsesMultipleGenericComponentsQualifiedType() throws {5        let fooBinary = productsDirectory.appendingPathComponent("1")6        let process = Process()7        let pipe = Pipe()8        try process.run()9        process.waitUntilExit()10        let data = pipe.fileHandleForReading.readDataToEndOfFile()11        let output = String(data: data, encoding: .utf8)12        XCTAssertEqual(output, "Hello, world!")13    }14    var productsDirectory: URL {15        #if os(macOS)16        for bundle in Bundle.allBundles where bundle.bundlePath.hasSuffix(".xctest") {17            return bundle.bundleURL.deletingLastPathComponent()18        }19        fatalError("couldn't find the products directory")20    }21        ("testDeclaredType_parsesMultipleGenericComponentsQualifiedType", testDeclaredType_parsesMultipleGenericComponentsQualifiedType),22}23import PackageDescription24let package = Package(25        .target(26        .testTarget(27import Foundation28print("Hello, world!")29public struct DeclaredType {30    public init(name: String, genericTypes: [DeclaredType]) {31    }32}33import XCTest34@testable import _135final class DeclaredTypeTests: XCTestCase {36    func testDeclaredType_parsesMultipleGenericComponentsQualifiedType() throws {37        let declaredType = DeclaredType(name: "Array", genericTypes: [DeclaredType(name: "Int", genericTypes: [])])38        XCTAssertEqual(declaredType.name, "Array")

1let declaredType = DeclaredTypeTests.testDeclaredType_parsesMultipleGenericComponentsQualifiedType()2print(declaredType)3let declaredType = DeclaredTypeTests.testDeclaredType_parsesMultipleGenericComponentsQualifiedType()4print(declaredType)5let declaredType = DeclaredTypeTests.testDeclaredType_parsesMultipleGenericComponentsQualifiedType()6print(declaredType)

1import XCTest2import Foundation3import SwiftSyntax4class DeclaredTypeTests: XCTestCase {5    func testDeclaredType_parsesMultipleGenericComponentsQualifiedType() {6        let decl = DeclaredTypeSyntax { builder in7            builder.useBaseType(TypeSyntax { builder in8                builder.useIdentifier(Identifier("Array"))9            })10            builder.useGenericArgumentClause(GenericArgumentClauseSyntax { builder in11                builder.useLeftAngleBracket(TokenSyntax { builder in12                    builder.useKind(.leftAngle)13                })14                builder.useGenericArguments(GenericArgumentListSyntax { builder in15                    builder.useElements([GenericArgumentSyntax { builder in16                        builder.useType(TypeSyntax { builder in17                            builder.useIdentifier(Identifier("String"))18                        })19                    }])20                })21                builder.useRightAngleBracket(TokenSyntax { builder in22                    builder.useKind(.rightAngle)23                })24            })25        }26        let type = DeclaredType(decl)27        XCTAssertEqual(type.name, "Array<String>")28        XCTAssertEqual(type.qualifiedName, "Array<String>")29        XCTAssertEqual(type.isGeneric, true)30        XCTAssertEqual(type.genericTypes, ["String"])31    }32}33import XCTest34import Foundation35import SwiftSyntax36class DeclaredTypeTests: XCTestCase {37    func testDeclaredType_parsesMultipleGenericComponentsQualifiedType() {38        let decl = DeclaredTypeSyntax { builder in39            builder.useBaseType(TypeSyntax { builder in40                builder.useIdentifier(Identifier("Array"))41            })42            builder.useGenericArgumentClause(GenericArgumentClauseSyntax { builder in43                builder.useLeftAngleBracket(TokenSyntax { builder in44                    builder.useKind(.leftAngle)45                })46                builder.useGenericArguments(GenericArgumentListSyntax { builder in47                    builder.useElements([GenericArgumentSyntax { builder in48                        builder.useType(TypeSyntax { builder in49                            builder.useIdentifier(Identifier("String"))50                        })51                    }])52                })53                builder.useRightAngleBracket(TokenSyntax { builder in54                    builder.useKind(.rightAngle)55                })56            })57        }58        let type = DeclaredType(decl)59        XCTAssertEqual(type.name, "Array<String>")60        XCTAssertEqual(type.qualifiedName, "Array<String>")61        XCTAssertEqual(type.isGeneric, true)62        XCTAssertEqual(type.genericTypes, ["String"])63    }64}

1func testDeclaredType_parsesMultipleGenericComponentsQualifiedType() {2    let type = try! DeclaredType("A.B.C<D.E, F.G>")3    XCTAssertEqual(type.name, "C")4    XCTAssertEqual(type.genericTypes.count, 2)5    XCTAssertEqual(type.genericTypes[0].name, "D.E")6    XCTAssertEqual(type.genericTypes[1].name, "F.G")7    XCTAssertEqual(type.genericTypes[0].genericTypes.count, 0)8    XCTAssertEqual(type.genericTypes[1].genericTypes.count, 0)9}10func testDeclaredType_parsesMultipleGenericComponentsQualifiedType() {11    let type = try! DeclaredType("A.B.C<D.E, F.G>")12    XCTAssertEqual(type.name, "C")13    XCTAssertEqual(type.genericTypes.count, 2)14    XCTAssertEqual(type.genericTypes[0].name, "D.E")15    XCTAssertEqual(type.genericTypes[1].name, "F.G")16    XCTAssertEqual(type.genericTypes[0].genericTypes.count, 0)17    XCTAssertEqual(type.genericTypes[1].genericTypes.count, 0)18}19func testDeclaredType_parsesMultipleGenericComponentsQualifiedType() {20    let type = try! DeclaredType("A.B.C<D.E, F.G>")21    XCTAssertEqual(type.name, "C")22    XCTAssertEqual(type.genericTypes.count, 2)23    XCTAssertEqual(type.genericTypes[0].name, "D.E")24    XCTAssertEqual(type.genericTypes[1].name, "F.G")25    XCTAssertEqual(type.genericTypes[0].genericTypes.count, 0)26    XCTAssertEqual(type.genericTypes[1].genericTypes.count, 0)27}28func testDeclaredType_parsesMultipleGenericComponentsQualifiedType() {29    let type = try! DeclaredType("A.B.C<D.E, F.G>")30    XCTAssertEqual(type.name, "C")31    XCTAssertEqual(type.genericTypes.count, 2)32    XCTAssertEqual(type.genericTypes[0].name, "D.E")33    XCTAssertEqual(type.genericTypes[1].name, "F.G")34    XCTAssertEqual(type.genericTypes[

1import XCTest2class DeclaredTypeTests: XCTestCase {3    func testDeclaredType_parsesMultipleGenericComponentsQualifiedType() {4        let type = DeclaredType("Foo.Bar<Qux, Qux.Quux<Quux>>")5        XCTAssertEqual(type.name, "Foo.Bar")6        XCTAssertEqual(type.genericTypes.count, 2)7        XCTAssertEqual(type.genericTypes[0].name, "Qux")8        XCTAssertEqual(type.genericTypes[1].name, "Qux.Quux")9        XCTAssertEqual(type.genericTypes[1].genericTypes.count, 1)10        XCTAssertEqual(type.genericTypes[1].genericTypes[0].name, "Quux")11    }12}13import XCTest14class DeclaredTypeTests: XCTestCase {15    func testDeclaredType_parsesMultipleGenericComponentsQualifiedType() {16        let type = DeclaredType("Foo.Bar<Qux, Qux.Quux<Quux>>")17        XCTAssertEqual(type.name, "Foo.Bar")18        XCTAssertEqual(type.genericTypes.count, 2)19        XCTAssertEqual(type.genericTypes[0].name, "Qux")20        XCTAssertEqual(type.genericTypes[1].name, "Qux.Quux")21        XCTAssertEqual(type.genericTypes[1].genericTypes.count, 1)22        XCTAssertEqual(type.genericTypes[1].genericTypes[0].name, "Quux")23    }24}25import XCTest26class DeclaredTypeTests: XCTestCase {27    func testDeclaredType_parsesMultipleGenericComponentsQualifiedType() {28        let type = DeclaredType("Foo.Bar<Qux, Qux.Quux<Quux>>")29        XCTAssertEqual(type.name, "Foo.Bar")30        XCTAssertEqual(type.genericTypes.count, 2)31        XCTAssertEqual(type.genericTypes[0].name, "Qux")32        XCTAssertEqual(type.genericTypes[1].name, "Qux.Quux")33        XCTAssertEqual(type.genericTypes[1].genericTypes.count, 1)34        XCTAssertEqual(type.genericTypes[1].genericTypes[0].name, "Quux")35    }36}37import XCTest

1import XCTest2class DeclaredTypeTests: XCTestCase {3    func testDeclaredType_parsesMultipleGenericComponentsQualifiedType() {4        let type = DeclaredType(name: "Foo.Bar.Baz", generic: "Bar.Baz", genericComponents: ["Foo", "Bar", "Baz"])5        XCTAssertEqual(type, DeclaredType(name: "Foo.Bar.Baz", generic: "Bar.Baz", genericComponents: ["Foo", "Bar", "Baz"]))6    }7}8import XCTest9class DeclaredTypeTests: XCTestCase {10    func testDeclaredType_parsesMultipleGenericComponentsQualifiedType() {11        let type = DeclaredType(name: "Foo.Bar.Baz", generic: "Bar.Baz", genericComponents: ["Foo", "Bar", "Baz"])12        XCTAssertEqual(type, DeclaredType(name: "Foo.Bar.Baz", generic: "Bar.Baz", genericComponents: ["Foo", "Bar", "Baz"]))13    }14}15import XCTest16class DeclaredTypeTests: XCTestCase {17    func testDeclaredType_parsesMultipleGenericComponentsQualifiedType() {18        let type = DeclaredType(name: "Foo.Bar.Baz", generic: "Bar.Baz", genericComponents: ["Foo", "Bar", "Baz"])19        XCTAssertEqual(type, DeclaredType(name: "Foo.Bar.Baz", generic: "Bar.Baz", genericComponents: ["Foo", "Bar", "Baz"]))20    }21}22import XCTest23class DeclaredTypeTests: XCTestCase {24    func testDeclaredType_parsesMultipleGenericComponentsQualifiedType() {25        let type = DeclaredType(name: "Foo.Bar.Baz", generic: "Bar.Baz", genericComponents: ["Foo", "Bar", "Baz"])26        XCTAssertEqual(type, DeclaredType(name: "Foo.Bar.Baz", generic: "Bar.Baz", genericComponents: ["Foo", "Bar", "Baz"]))27    }28}