How to use PublicClass class

1//2//3import Foundation4public class PublicClass {5    internal typealias InternalArray = [PublicClass.InternalStruct]6    internal typealias InternalStructTypeDef = PublicClass.InternalStruct7    internal typealias StringToInternalStructMap = [String: PublicClass.InternalStruct]8    internal var internalStructProperty: PublicClass.InternalStruct {9        get {10            let c_result_handle = smoke_PublicClass_internalStructProperty_get(self.c_instance)11            return moveFromCType(c_result_handle)12        }13        set {14            let c_value = moveToCType(newValue)15            smoke_PublicClass_internalStructProperty_set(self.c_instance, c_value.ref)16        }17    }18    public internal(set) var internalSetterProperty: String {19        get {20            let c_result_handle = smoke_PublicClass_internalSetterProperty_get(self.c_instance)21            return moveFromCType(c_result_handle)22        }23        set {24            let c_value = moveToCType(newValue)25            smoke_PublicClass_internalSetterProperty_set(self.c_instance, c_value.ref)26        }27    }28    let c_instance : _baseRef29    init(cPublicClass: _baseRef) {30        guard cPublicClass != 0 else {31            fatalError("Nullptr value is not supported for initializers")32        }33        c_instance = cPublicClass34    }35    deinit {36        smoke_PublicClass_remove_swift_object_from_wrapper_cache(c_instance)37        smoke_PublicClass_release_handle(c_instance)38    }39    internal enum InternalEnum : UInt32, CaseIterable, Codable {40        case foo41        case bar42    }43    internal struct InternalStruct {44        internal var stringField: String45        internal init(stringField: String) {46            self.stringField = stringField47        }48        internal init(cHandle: _baseRef) {49            stringField = moveFromCType(smoke_PublicClass_InternalStruct_stringField_get(cHandle))50        }51    }52    public struct PublicStruct {53        internal var internalField: PublicClass.InternalStruct54        internal init(internalField: PublicClass.InternalStruct) {55            self.internalField = internalField56        }57        internal init(cHandle: _baseRef) {58            internalField = moveFromCType(smoke_PublicClass_PublicStruct_internalField_get(cHandle))59        }60    }61    public struct PublicStructWithInternalDefaults {62        internal var internalField: String63        public var publicField: Float64        public init(publicField: Float) {65            self.publicField = publicField66            self.internalField = "foo"67        }68        internal init(internalField: String = "foo", publicField: Float) {69            self.internalField = internalField70            self.publicField = publicField71        }72        internal init(cHandle: _baseRef) {73            internalField = moveFromCType(smoke_PublicClass_PublicStructWithInternalDefaults_internalField_get(cHandle))74            publicField = moveFromCType(smoke_PublicClass_PublicStructWithInternalDefaults_publicField_get(cHandle))75        }76    }77    internal func internalMethod(input: PublicClass.InternalStruct) -> PublicClass.InternalStructTypeDef {78        let c_input = moveToCType(input)79        let c_result_handle = smoke_PublicClass_internalMethod(self.c_instance, c_input.ref)80        return moveFromCType(c_result_handle)81    }82}83internal func getRef(_ ref: PublicClass?, owning: Bool = true) -> RefHolder {84    guard let c_handle = ref?.c_instance else {85        return RefHolder(0)86    }87    let handle_copy = smoke_PublicClass_copy_handle(c_handle)88    return owning89        ? RefHolder(ref: handle_copy, release: smoke_PublicClass_release_handle)90        : RefHolder(handle_copy)91}92extension PublicClass: NativeBase {93    /// :nodoc:94    var c_handle: _baseRef { return c_instance }95}96extension PublicClass: Hashable {97    /// :nodoc:98    public static func == (lhs: PublicClass, rhs: PublicClass) -> Bool {99        return lhs.c_handle == rhs.c_handle100    }101    /// :nodoc:102    public func hash(into hasher: inout Hasher) {103        hasher.combine(c_handle)104    }105}106internal func PublicClass_copyFromCType(_ handle: _baseRef) -> PublicClass {107    if let swift_pointer = smoke_PublicClass_get_swift_object_from_wrapper_cache(handle),108        let re_constructed = Unmanaged<AnyObject>.fromOpaque(swift_pointer).takeUnretainedValue() as? PublicClass {109        return re_constructed110    }111    let result = PublicClass(cPublicClass: smoke_PublicClass_copy_handle(handle))112    smoke_PublicClass_cache_swift_object_wrapper(handle, Unmanaged<AnyObject>.passUnretained(result).toOpaque())113    return result114}115internal func PublicClass_moveFromCType(_ handle: _baseRef) -> PublicClass {116    if let swift_pointer = smoke_PublicClass_get_swift_object_from_wrapper_cache(handle),117        let re_constructed = Unmanaged<AnyObject>.fromOpaque(swift_pointer).takeUnretainedValue() as? PublicClass {118        smoke_PublicClass_release_handle(handle)119        return re_constructed120    }121    let result = PublicClass(cPublicClass: handle)122    smoke_PublicClass_cache_swift_object_wrapper(handle, Unmanaged<AnyObject>.passUnretained(result).toOpaque())123    return result124}125internal func PublicClass_copyFromCType(_ handle: _baseRef) -> PublicClass? {126    guard handle != 0 else {127        return nil128    }129    return PublicClass_moveFromCType(handle) as PublicClass130}131internal func PublicClass_moveFromCType(_ handle: _baseRef) -> PublicClass? {132    guard handle != 0 else {133        return nil134    }135    return PublicClass_moveFromCType(handle) as PublicClass136}137internal func copyToCType(_ swiftClass: PublicClass) -> RefHolder {138    return getRef(swiftClass, owning: false)139}140internal func moveToCType(_ swiftClass: PublicClass) -> RefHolder {141    return getRef(swiftClass, owning: true)142}143internal func copyToCType(_ swiftClass: PublicClass?) -> RefHolder {144    return getRef(swiftClass, owning: false)145}146internal func moveToCType(_ swiftClass: PublicClass?) -> RefHolder {147    return getRef(swiftClass, owning: true)148}149internal func copyFromCType(_ handle: _baseRef) -> PublicClass.InternalStruct {150    return PublicClass.InternalStruct(cHandle: handle)151}152internal func moveFromCType(_ handle: _baseRef) -> PublicClass.InternalStruct {153    defer {154        smoke_PublicClass_InternalStruct_release_handle(handle)155    }156    return copyFromCType(handle)157}158internal func copyToCType(_ swiftType: PublicClass.InternalStruct) -> RefHolder {159    let c_stringField = moveToCType(swiftType.stringField)160    return RefHolder(smoke_PublicClass_InternalStruct_create_handle(c_stringField.ref))161}162internal func moveToCType(_ swiftType: PublicClass.InternalStruct) -> RefHolder {163    return RefHolder(ref: copyToCType(swiftType).ref, release: smoke_PublicClass_InternalStruct_release_handle)164}165internal func copyFromCType(_ handle: _baseRef) -> PublicClass.InternalStruct? {166    guard handle != 0 else {167        return nil168    }169    let unwrappedHandle = smoke_PublicClass_InternalStruct_unwrap_optional_handle(handle)170    return PublicClass.InternalStruct(cHandle: unwrappedHandle) as PublicClass.InternalStruct171}172internal func moveFromCType(_ handle: _baseRef) -> PublicClass.InternalStruct? {173    defer {174        smoke_PublicClass_InternalStruct_release_optional_handle(handle)175    }176    return copyFromCType(handle)177}178internal func copyToCType(_ swiftType: PublicClass.InternalStruct?) -> RefHolder {179    guard let swiftType = swiftType else {180        return RefHolder(0)181    }182    let c_stringField = moveToCType(swiftType.stringField)183    return RefHolder(smoke_PublicClass_InternalStruct_create_optional_handle(c_stringField.ref))184}185internal func moveToCType(_ swiftType: PublicClass.InternalStruct?) -> RefHolder {186    return RefHolder(ref: copyToCType(swiftType).ref, release: smoke_PublicClass_InternalStruct_release_optional_handle)187}188internal func copyFromCType(_ handle: _baseRef) -> PublicClass.PublicStruct {189    return PublicClass.PublicStruct(cHandle: handle)190}191internal func moveFromCType(_ handle: _baseRef) -> PublicClass.PublicStruct {192    defer {193        smoke_PublicClass_PublicStruct_release_handle(handle)194    }195    return copyFromCType(handle)196}197internal func copyToCType(_ swiftType: PublicClass.PublicStruct) -> RefHolder {198    let c_internalField = moveToCType(swiftType.internalField)199    return RefHolder(smoke_PublicClass_PublicStruct_create_handle(c_internalField.ref))200}201internal func moveToCType(_ swiftType: PublicClass.PublicStruct) -> RefHolder {202    return RefHolder(ref: copyToCType(swiftType).ref, release: smoke_PublicClass_PublicStruct_release_handle)203}204internal func copyFromCType(_ handle: _baseRef) -> PublicClass.PublicStruct? {205    guard handle != 0 else {206        return nil207    }208    let unwrappedHandle = smoke_PublicClass_PublicStruct_unwrap_optional_handle(handle)209    return PublicClass.PublicStruct(cHandle: unwrappedHandle) as PublicClass.PublicStruct210}211internal func moveFromCType(_ handle: _baseRef) -> PublicClass.PublicStruct? {212    defer {213        smoke_PublicClass_PublicStruct_release_optional_handle(handle)214    }215    return copyFromCType(handle)216}217internal func copyToCType(_ swiftType: PublicClass.PublicStruct?) -> RefHolder {218    guard let swiftType = swiftType else {219        return RefHolder(0)220    }221    let c_internalField = moveToCType(swiftType.internalField)222    return RefHolder(smoke_PublicClass_PublicStruct_create_optional_handle(c_internalField.ref))223}224internal func moveToCType(_ swiftType: PublicClass.PublicStruct?) -> RefHolder {225    return RefHolder(ref: copyToCType(swiftType).ref, release: smoke_PublicClass_PublicStruct_release_optional_handle)226}227internal func copyFromCType(_ handle: _baseRef) -> PublicClass.PublicStructWithInternalDefaults {228    return PublicClass.PublicStructWithInternalDefaults(cHandle: handle)229}230internal func moveFromCType(_ handle: _baseRef) -> PublicClass.PublicStructWithInternalDefaults {231    defer {232        smoke_PublicClass_PublicStructWithInternalDefaults_release_handle(handle)233    }234    return copyFromCType(handle)235}236internal func copyToCType(_ swiftType: PublicClass.PublicStructWithInternalDefaults) -> RefHolder {237    let c_internalField = moveToCType(swiftType.internalField)238    let c_publicField = moveToCType(swiftType.publicField)239    return RefHolder(smoke_PublicClass_PublicStructWithInternalDefaults_create_handle(c_internalField.ref, c_publicField.ref))240}241internal func moveToCType(_ swiftType: PublicClass.PublicStructWithInternalDefaults) -> RefHolder {242    return RefHolder(ref: copyToCType(swiftType).ref, release: smoke_PublicClass_PublicStructWithInternalDefaults_release_handle)243}244internal func copyFromCType(_ handle: _baseRef) -> PublicClass.PublicStructWithInternalDefaults? {245    guard handle != 0 else {246        return nil247    }248    let unwrappedHandle = smoke_PublicClass_PublicStructWithInternalDefaults_unwrap_optional_handle(handle)249    return PublicClass.PublicStructWithInternalDefaults(cHandle: unwrappedHandle) as PublicClass.PublicStructWithInternalDefaults250}251internal func moveFromCType(_ handle: _baseRef) -> PublicClass.PublicStructWithInternalDefaults? {252    defer {253        smoke_PublicClass_PublicStructWithInternalDefaults_release_optional_handle(handle)254    }255    return copyFromCType(handle)256}257internal func copyToCType(_ swiftType: PublicClass.PublicStructWithInternalDefaults?) -> RefHolder {258    guard let swiftType = swiftType else {259        return RefHolder(0)260    }261    let c_internalField = moveToCType(swiftType.internalField)262    let c_publicField = moveToCType(swiftType.publicField)263    return RefHolder(smoke_PublicClass_PublicStructWithInternalDefaults_create_optional_handle(c_internalField.ref, c_publicField.ref))264}265internal func moveToCType(_ swiftType: PublicClass.PublicStructWithInternalDefaults?) -> RefHolder {266    return RefHolder(ref: copyToCType(swiftType).ref, release: smoke_PublicClass_PublicStructWithInternalDefaults_release_optional_handle)267}268internal func copyToCType(_ swiftEnum: PublicClass.InternalEnum) -> PrimitiveHolder<UInt32> {269    return PrimitiveHolder(swiftEnum.rawValue)270}271internal func moveToCType(_ swiftEnum: PublicClass.InternalEnum) -> PrimitiveHolder<UInt32> {272    return copyToCType(swiftEnum)273}274internal func copyToCType(_ swiftEnum: PublicClass.InternalEnum?) -> RefHolder {275    return copyToCType(swiftEnum?.rawValue)276}277internal func moveToCType(_ swiftEnum: PublicClass.InternalEnum?) -> RefHolder {278    return moveToCType(swiftEnum?.rawValue)279}280internal func copyFromCType(_ cValue: UInt32) -> PublicClass.InternalEnum {281    return PublicClass.InternalEnum(rawValue: cValue)!282}283internal func moveFromCType(_ cValue: UInt32) -> PublicClass.InternalEnum {284    return copyFromCType(cValue)285}286internal func copyFromCType(_ handle: _baseRef) -> PublicClass.InternalEnum? {287    guard handle != 0 else {288        return nil289    }290    return PublicClass.InternalEnum(rawValue: uint32_t_value_get(handle))!291}292internal func moveFromCType(_ handle: _baseRef) -> PublicClass.InternalEnum? {293    defer {294        uint32_t_release_handle(handle)295    }296    return copyFromCType(handle)297}...

...17// RUN: %empty-directory(%t)18// RUN: %target-swift-frontend -enable-testing -module-name comments -emit-module -emit-module-path %t/comments.swiftmodule -emit-module-doc -emit-module-doc-path %t/comments.swiftdoc -emit-module-source-info-path %t/comments.swiftsourceinfo %s19// RUN: %target-swift-ide-test -print-module-comments -module-to-print=comments -enable-swiftsourceinfo  -source-filename %s -I %t > %t.testing.txt20// RUN: %FileCheck %s -check-prefix=SOURCE-LOC < %t.testing.txt21/// PublicClass Documentation22public class PublicClass {23  /// Public Function Documentation24  public func f_public() { }25  /// Public Init Documentation26  public init(_ name: String) {}27  /// Public Subscript Documentation28  public subscript(_ name: String) -> Int { return 0 }29  /// Internal Function Documentation NotForNormal30  internal func f_internal() { }31  /// Private Function Documentation NotForNormal NotForTesting32  private func f_private() { }33  /// Public Filter Function Documentation NotForNormal NotForTesting34  public func __UnderscoredPublic() {}35  /// Public Filter Init Documentation NotForNormal NotForTesting36  public init(__label name: String) {}37  /// Public Filter Subscript Documentation NotForNormal NotForFiltering38  public subscript(__label name: String) -> Int { return 0 }39  /// Public Filter Init Documentation NotForNormal NotForTesting40  public init(label __name: String) {}41  /// Public Filter Subscript Documentation NotForNormal NotForTesting42  public subscript(label __name: String) -> Int { return 0 }43  /// SPI Function Documentation NotForNormal NotForTesting44  @_spi(SPI) public func f_spi() { }45}46public extension PublicClass {47  /// Public Filter Operator Documentation NotForNormal NotForTesting48  static func -=(__lhs: inout PublicClass, __rhs: PublicClass) {}49}50/// InternalClass Documentation NotForNormal51internal class InternalClass {52  /// Internal Function Documentation NotForNormal53  internal func f_internal() { }54  /// Private Function Documentation NotForNormal NotForTesting55  private func f_private() { }56}57/// PrivateClass Documentation NotForNormal NotForTesting58private class PrivateClass {59  /// Private Function Documentation NotForNormal NotForTesting60  private func f_private() { }61}62/// SPI Documentation NotForNormal NotForTesting63@_spi(SPI) public class SPIClass {64  /// SPI Function Documentation NotForNormal NotForTesting65  public func f_spi() { }66}67/// SPI Extension Documentation NotForNormal NotForTesting68@_spi(SPI) public extension PublicClass {69}70// NORMAL-NEGATIVE-NOT: NotForNormal71// NORMAL-NEGATIVE-NOT: NotForTesting72// NORMAL: PublicClass Documentation73// NORMAL: Public Function Documentation74// NORMAL: Public Init Documentation75// NORMAL: Public Subscript Documentation76// TESTING-NEGATIVE-NOT: NotForTesting77// TESTING: PublicClass Documentation78// TESTING: Public Function Documentation79// TESTING: Public Init Documentation80// TESTING: Public Subscript Documentation81// TESTING: Internal Function Documentation82// TESTING: InternalClass Documentation83// TESTING: Internal Function Documentation84// SOURCE-LOC: comments-hidden.swift:37:15: Func/PublicClass.__UnderscoredPublic85// SOURCE-LOC: comments-hidden.swift:39:10: Constructor/PublicClass.init86// SOURCE-LOC: comments-hidden.swift:41:10: Subscript/PublicClass.subscript87// SOURCE-LOC: comments-hidden.swift:43:10: Constructor/PublicClass.init88// SOURCE-LOC: comments-hidden.swift:45:10: Subscript/PublicClass.subscript89// SOURCE-LOC: comments-hidden.swift:52:15: Func/-=...

1let publicClass = PublicClass()2publicClass.publicMethod()3let internalClass = InternalClass()4internalClass.internalMethod()5let privateClass = PrivateClass()6privateClass.privateMethod()

1let publicClass = PublicClass()2publicClass.publicMethod()3let internalClass = InternalClass()4internalClass.internalMethod()5let privateClass = PrivateClass()6privateClass.privateMethod()7let publicClass = PublicClass()8publicClass.publicMethod()9let internalClass = InternalClass()10internalClass.internalMethod()11let privateClass = PrivateClass()12privateClass.privateMethod()13let publicClass = PublicClass()14publicClass.publicMethod()15let internalClass = InternalClass()16internalClass.internalMethod()17let privateClass = PrivateClass()18privateClass.privateMethod()19let publicClass = PublicClass()20publicClass.publicMethod()21let internalClass = InternalClass()22internalClass.internalMethod()23let privateClass = PrivateClass()24privateClass.privateMethod()25let publicClass = PublicClass()26publicClass.publicMethod()27let internalClass = InternalClass()28internalClass.internalMethod()29let privateClass = PrivateClass()30privateClass.privateMethod()

1let publicClass = PublicClass()2publicClass.publicMethod()3let internalClass = internalClass()4internalClass.internalMethod()5let privateClass = PrivateClass()6privateClass.privateMethod()7In this case, I have 3 files that I want to use different classes, but I want to use the same module. I have tried to use @testable import MockingbirdTests in each file, but it does not work. I have also tried to use import MockingbirdTests in each file, but it does not work either. I have also tried to use @testable import MockingbirdTests in each file, but it does not work either. I have also tried to use import MockingbirdTests in each file, but it does not work either. I have also tried to use @testable import MockingbirdTests in each file, but it does not work either. I have also tried to use import MockingbirdTests in each file, but it does not work either. I have also tried to use @testable import MockingbirdTests in each file, but it does not work either. I have also tried to use import MockingbirdTests in each file, but it does not work either. I have also tried to use @testable import MockingbirdTests in each file, but it does not work either. I have also tried to use import MockingbirdTests in each file, but it does not work either. I have also tried to use @testable import MockingbirdTests in each file, but it does not work either. I have also tried to use import MockingbirdTests in each file, but it does not work either. I have also tried to use @testable import MockingbirdTests in each file, but it does not work either. I have also tried to use import MockingbirdTests in each file, but it does not work either. I have also tried to use @testable import MockingbirdTests in each file, but it does not work either. I have also tried to use import MockingbirdTests in each file, but it does not work either. I have also tried to use @testable import MockingbirdTests in each file,

1let publicClass = PublicClass()2publicClass.publicMethod()3let publicClass = PublicClass()4publicClass.publicMethod()5let publicClass = PublicClass()6publicClass.publicMethod()7let publicClass = PublicClass()8publicClass.publicMethod()9let publicClass = PublicClass()10publicClass.publicMethod()11let publicClass = PublicClass()12publicClass.publicMethod()13let publicClass = PublicClass()14publicClass.publicMethod()15let publicClass = PublicClass()16publicClass.publicMethod()17let publicClass = PublicClass()18publicClass.publicMethod()19let publicClass = PublicClass()20publicClass.publicMethod()21let publicClass = PublicClass()22publicClass.publicMethod()23let publicClass = PublicClass()24publicClass.publicMethod()

1let a = PublicClass()2a.publicMethod()3let a = PublicClass()4a.publicMethod()5let a = PublicClass()6a.publicMethod()7import MockingbirdTests8let a = PublicClass()9a.publicMethod()10let expectation = XCTestExpectation(description: "Completion handler invoked")11let completion: (String) -> Void = { _ in12    expectation.fulfill()13}14sut.someFunction(completion: completion)15let expectation = XCTestExpectation(description: "Completion handler invoked")16let completion: (String) -> Void = { _ in17    expectation.fulfill()18}19sut.someFunction(completion: completion)20let expectation = XCTestExpectation(description: "Completion handler invoked")21let completion: (String) -> Void = { _ in22    expectation.fulfill()23}24sut.someFunction(completion: completion)

1import MockingbirdTests2let publicClass = PublicClass()3publicClass.publicMethod()4publicClass.publicMethodWithParam(param: "param")5publicClass.publicMethodWithParamAndReturn(param: "param")6publicClass.publicMethodWithReturn()7import MockingbirdTests8let publicClass = PublicClass()9publicClass.publicMethod()10publicClass.publicMethodWithParam(param: "param")11publicClass.publicMethodWithParamAndReturn(param: "param")12publicClass.publicMethodWithReturn()13import MockingbirdTests14let publicClass = PublicClass()15publicClass.publicMethod()16publicClass.publicMethodWithParam(param: "param")17publicClass.publicMethodWithParamAndReturn(param: "param")18publicClass.publicMethodWithReturn()19import MockingbirdTests20let publicClass = PublicClass()21publicClass.publicMethod()22publicClass.publicMethodWithParam(param: "param")23publicClass.publicMethodWithParamAndReturn(param: "param")24publicClass.publicMethodWithReturn()25import MockingbirdTests26let publicClass = PublicClass()27publicClass.publicMethod()28publicClass.publicMethodWithParam(param: "param")29publicClass.publicMethodWithParamAndReturn(param: "param")30publicClass.publicMethodWithReturn()31import MockingbirdTests32let publicClass = PublicClass()33publicClass.publicMethod()34publicClass.publicMethodWithParam(param: "param")35publicClass.publicMethodWithParamAndReturn(param: "param")36publicClass.publicMethodWithReturn()37import MockingbirdTests38let publicClass = PublicClass()39publicClass.publicMethod()