How to use ConvenienceInitializerClass class

1//
2//  ClassInitializers.swift
3//  MockingbirdTestsHost
4//
5//  Created by Andrew Chang on 8/25/19.
6//
7
8import Foundation
9
10class NoInitializerClass {}
11
12class InheritingNoInitializerClass: NoInitializerClass {}
13class IndirectlyInheritingNoInitializerClass: InheritingNoInitializerClass {}
14
15protocol ConformingToNoInitializerClass: NoInitializerClass {}
16protocol IndirectlyConformingToNoInitializerClass: ConformingToNoInitializerClass {}
17
18class EmptyInitializerClass {
19  init() {}
20}
21
22class InheritingEmptyInitializerClass: EmptyInitializerClass {}
23class IndirectlyInheritingEmptyInitializerClass: InheritingEmptyInitializerClass {}
24
25protocol ConformingToEmptyInitializerClass: EmptyInitializerClass {}
26protocol IndirectlyConformingToEmptyInitializerClass: ConformingToEmptyInitializerClass {}
27
28class PrivateInitializerClass {
29  private init() {}
30}
31
32class InheritingPrivateInitializerClass: PrivateInitializerClass {}
33class IndirectlyInheritingPrivateInitializerClass: InheritingPrivateInitializerClass {}
34
35protocol ConformingToPrivateInitializerClass: PrivateInitializerClass {}
36protocol IndirectlyConformingToPrivateInitializerClass: ConformingToPrivateInitializerClass {}
37
38class PrivateInitializerClassWithAccessibleInitializer {
39  private init() {}
40  init(param: Bool) {}
41}
42
43class ParameterizedInitializerClass {
44  init(param1: Bool, param2: Int) {}
45}
46
47class RequiredInitializerClass {
48  required init(param1: Bool, param2: Int) {}
49}
50
51class ConvenienceInitializerClass {
52  init(param1: Bool, param2: Int) {}
53  convenience init(param1: Bool) {
54    self.init(param1: param1, param2: 1)
55  }
56}
57
58class FailableEmptyInitializerClass {
59  init?() {}
60}
61
62class FailableUnwrappedEmptyInitializerClass {
63  init!() {}
64}
65
66class FailableParameterizedInitializerClass {
67  init?(param1: Bool, param2: Int) {}
68}
69
70class FailableUnwrappedParameterizedInitializerClass {
71  init!(param1: Bool, param2: Int) {}
72}
73

Source: ClassInitializers.swift

//
//  ClassInitializers.swift
//  MockingbirdTestsHost
//
//  Created by Andrew Chang on 8/25/19.
//

import Foundation

class NoInitializerClass {}

class InheritingNoInitializerClass: NoInitializerClass {}
class IndirectlyInheritingNoInitializerClass: InheritingNoInitializerClass {}

protocol ConformingToNoInitializerClass: NoInitializerClass {}
protocol IndirectlyConformingToNoInitializerClass: ConformingToNoInitializerClass {}

class EmptyInitializerClass {
  init() {}
}

class InheritingEmptyInitializerClass: EmptyInitializerClass {}
class IndirectlyInheritingEmptyInitializerClass: InheritingEmptyInitializerClass {}

protocol ConformingToEmptyInitializerClass: EmptyInitializerClass {}
protocol IndirectlyConformingToEmptyInitializerClass: ConformingToEmptyInitializerClass {}

class PrivateInitializerClass {
  private init() {}
}

class InheritingPrivateInitializerClass: PrivateInitializerClass {}
class IndirectlyInheritingPrivateInitializerClass: InheritingPrivateInitializerClass {}

protocol ConformingToPrivateInitializerClass: PrivateInitializerClass {}
protocol IndirectlyConformingToPrivateInitializerClass: ConformingToPrivateInitializerClass {}

class PrivateInitializerClassWithAccessibleInitializer {
  private init() {}
  init(param: Bool) {}
}

class ParameterizedInitializerClass {
  init(param1: Bool, param2: Int) {}
}

class RequiredInitializerClass {
  required init(param1: Bool, param2: Int) {}
}

class ConvenienceInitializerClass {
  init(param1: Bool, param2: Int) {}
  convenience init(param1: Bool) {
    self.init(param1: param1, param2: 1)
  }
}

class FailableEmptyInitializerClass {
  init?() {}
}

class FailableUnwrappedEmptyInitializerClass {
  init!() {}
}

class FailableParameterizedInitializerClass {
  init?(param1: Bool, param2: Int) {}
}

class FailableUnwrappedParameterizedInitializerClass {
  init!(param1: Bool, param2: Int) {}
}