How to use testStringExtensions_substringComponents_separatesEmptyStrings method of StringExtensionsTests class

1//
2//  StringExtensionsTests.swift
3//  MockingbirdTests
4//
5//  Created by Andrew Chang on 9/2/19.
6//
7
8import XCTest
9@testable import MockingbirdGenerator
10
11class StringExtensionsTests: XCTestCase {
12  
13  // MARK: - Capitalized first
14  
15  func testStringExtensions_capitalizedFirst_capitalizesFirstLowercaseCharacter() {
16    XCTAssertEqual("hello world!".capitalizedFirst, "Hello world!")
17  }
18  
19  func testStringExtensions_capitalizedFirst_handlesFirstUppercaseCharacter() {
20    XCTAssertEqual("Hello world!".capitalizedFirst, "Hello world!")
21  }
22
23  // MARK: Backtick Wrapped
24
25  func testStringExtensions_backtickWrapped_wrapsStringWithBackticks() {
26    XCTAssertEqual("test string".backtickWrapped, "`test string`")
27  }
28  
29  // MARK: - Substring components
30  
31  func testStringExtensions_substringComponents_separatesByDelimiterCharacter() {
32    let expected: [Substring] = ["a", "b", "c", "d"]
33    XCTAssertEqual("a.b.c.d".substringComponents(separatedBy: "."), expected)
34  }
35  
36  func testStringExtensions_substringComponents_separatesStringsWithNoDelimiters() {
37    let expected: [Substring] = ["abcd"]
38    XCTAssertEqual("abcd".substringComponents(separatedBy: "."), expected)
39  }
40  
41  func testStringExtensions_substringComponents_separatesEmptyStrings() {
42    let expected: [Substring] = [""]
43    XCTAssertEqual("".substringComponents(separatedBy: "."), expected)
44  }
45  
46  func testStringExtensions_substringComponents_handlesLeadingDelimiter() {
47    let expected: [Substring] = ["", "a"]
48    XCTAssertEqual(".a".substringComponents(separatedBy: "."), expected)
49  }
50  
51  func testStringExtensions_substringComponents_handlesTrailingDelimiter() {
52    let expected: [Substring] = ["a", ""]
53    XCTAssertEqual("a.".substringComponents(separatedBy: "."), expected)
54  }
55  
56  // MARK: - Indent
57  
58  func testStringExtensions_indent_addsIndentationToSingleLineString() {
59    XCTAssertEqual("foo-bar".indent(by: 2), "    foo-bar")
60  }
61  
62  func testStringExtensions_indent_addsIndentationToMultiLineString() {
63    let actual = """
64    line1
65      line2
66        line3
67    """.indent(by: 2)
68    let expected = """
69        line1
70          line2
71            line3
72    """
73    XCTAssertEqual(actual, expected)
74  }
75  
76  func testStringExtensions_indent_doesNotChangeEmptyStrings() {
77    XCTAssertEqual("".indent(by: 2), "")
78  }
79  
80  func testStringExtensions_indent_ignoresEmptyLines() {
81    let actual = """
82    line1
83    
84    line2
85
86    line3
87    """.indent(by: 2)
88    let expected = """
89        line1
90    
91        line2
92
93        line3
94    """
95    XCTAssertEqual(actual, expected)
96  }
97  
98  // MARK: - Removing parameter attributes
99  
100  func testStringExtensions_removingParameterAttributes_removesFunctionAttributes() {
101    let actual = "@escaping @autoclosure (Int, Bool) -> String".removingParameterAttributes()
102    XCTAssertEqual(actual, "(Int, Bool) -> String")
103  }
104  
105  func testStringExtensions_removingParameterAttributes_removesInoutAttribute() {
106    let actual = "inout String".removingParameterAttributes()
107    XCTAssertEqual(actual, "String")
108  }
109  
110  func testStringExtensions_removingParameterAttributes_removesTopLevelInoutAttribute() {
111    let actual = "inout (inout Int, inout Bool) -> String".removingParameterAttributes()
112    XCTAssertEqual(actual, "(inout Int, inout Bool) -> String")
113  }
114  
115  func testStringExtensions_removingParameterAttributes_removesVariadicAttribute() {
116    let actual = "String...".removingParameterAttributes()
117    XCTAssertEqual(actual, "String")
118  }
119  
120  func testStringExtensions_removingParameterAttributes_removesSpacedVariadicAttribute() {
121    let actual = "String \n\t ...".removingParameterAttributes()
122    XCTAssertEqual(actual, "String")
123  }
124  
125  func testStringExtensions_removingParameterAttributes_removesTopLevelVariadicAttribute() {
126    let actual = "(Int..., Bool ...) -> String".removingParameterAttributes()
127    XCTAssertEqual(actual, "(Int..., Bool...) -> String")
128  }
129  
130  // MARK: - Removing generic typing
131  
132  func testStringExtensions_removingGenericTyping_removesAllGenericTypes() {
133    let actual = "Type1<A, B, C>.Type2.Type3<D, E, F>.Type4".removingGenericTyping()
134    XCTAssertEqual(actual, "Type1.Type2.Type3.Type4")
135  }
136  
137  func testStringExtensions_removingGenericTyping_ignoresNestedGenerics() {
138    let actual = "Type1<A<Int>, B<String>, C<Bool>>.Type2".removingGenericTyping()
139    XCTAssertEqual(actual, "Type1.Type2")
140  }
141  
142  // MARK: - Contains needle
143  
144  func testStringExtensions_containsNeedle_excludesCharacterGroups() {
145    let actual = "abc (d123ef) <gh123i>".contains("123", excluding: ["(": ")", "<": ">"])
146    XCTAssertFalse(actual)
147  }
148  
149  func testStringExtensions_containsNeedle_excludesDefinedCharacterGroupsOnly() {
150    let actual = "abc (d123ef) <gh123i> [jkl123]".contains("123", excluding: ["(": ")", "<": ">"])
151    XCTAssertTrue(actual)
152  }
153  
154  func testStringExtensions_containsNeedle_handlesNeedlesDefinedAsGroupStartCharacter() {
155    let actual = "abc <(def)> [ghi] (jkl)".contains("(", excluding: ["(": ")", "<": ">"])
156    XCTAssertTrue(actual)
157  }
158  
159  // MARK: - First index of needle
160  
161  func testStringExtensions_firstIndexOfNeedle_excludesCharacterGroups() {
162    let actual = "abc (d123ef) <gh123i>".firstIndex(of: "123", excluding: ["(": ")", "<": ">"])
163    XCTAssertNil(actual)
164  }
165  
166  func testStringExtensions_firstIndexOfNeedle_excludesDefinedCharacterGroupsOnly() {
167    let string = "abc (d123ef) <gh123i> [jkl123]"
168    let actual = string.firstIndex(of: "123", excluding: ["(": ")", "<": ">"])
169    XCTAssertEqual(actual, string.index(string.startIndex, offsetBy: 26))
170  }
171  
172  func testStringExtensions_firstIndexOfNeedle_handlesNeedlesDefinedAsGroupStartCharacter() {
173    let string = "abc <(def)> [ghi] (jkl)"
174    let actual = string.firstIndex(of: "(", excluding: ["(": ")", "<": ">"])
175    XCTAssertEqual(actual, string.index(string.startIndex, offsetBy: 18))
176  }
177  
178  // MARK: - Components separated by
179  
180  func testStringExtensions_componentsSeparatedBySingleDelimiter_excludesCharacterGroups() {
181    let actual = "abc.(de.f).<g.hi>".components(separatedBy: ".", excluding: ["(": ")", "<": ">"])
182    XCTAssertEqual(actual, ["abc", "(de.f)", "<g.hi>"])
183  }
184  
185  func testStringExtensions_componentsSeparatedByMultipleDelimiters_excludesCharacterGroups() {
186    let actual = "abc.(d,e.f),<g.h,i>".components(separatedBy: [".", ","],
187                                                  excluding: ["(": ")", "<": ">"])
188    XCTAssertEqual(actual, ["abc", "(d,e.f)", "<g.h,i>"])
189  }
190}
191

Source: StringExtensionsTests.swift

//
//  StringExtensionsTests.swift
//  MockingbirdTests
//
//  Created by Andrew Chang on 9/2/19.
//

import XCTest
@testable import MockingbirdGenerator

class StringExtensionsTests: XCTestCase {
  
  // MARK: - Capitalized first
  
  func testStringExtensions_capitalizedFirst_capitalizesFirstLowercaseCharacter() {
    XCTAssertEqual("hello world!".capitalizedFirst, "Hello world!")
  }
  
  func testStringExtensions_capitalizedFirst_handlesFirstUppercaseCharacter() {
    XCTAssertEqual("Hello world!".capitalizedFirst, "Hello world!")
  }

  // MARK: Backtick Wrapped

  func testStringExtensions_backtickWrapped_wrapsStringWithBackticks() {
    XCTAssertEqual("test string".backtickWrapped, "`test string`")
  }
  
  // MARK: - Substring components
  
  func testStringExtensions_substringComponents_separatesByDelimiterCharacter() {
    let expected: [Substring] = ["a", "b", "c", "d"]
    XCTAssertEqual("a.b.c.d".substringComponents(separatedBy: "."), expected)
  }
  
  func testStringExtensions_substringComponents_separatesStringsWithNoDelimiters() {
    let expected: [Substring] = ["abcd"]
    XCTAssertEqual("abcd".substringComponents(separatedBy: "."), expected)
  }
  
  func testStringExtensions_substringComponents_separatesEmptyStrings() {
    let expected: [Substring] = [""]
    XCTAssertEqual("".substringComponents(separatedBy: "."), expected)
  }
  
  func testStringExtensions_substringComponents_handlesLeadingDelimiter() {
    let expected: [Substring] = ["", "a"]
    XCTAssertEqual(".a".substringComponents(separatedBy: "."), expected)
  }
  
  func testStringExtensions_substringComponents_handlesTrailingDelimiter() {
    let expected: [Substring] = ["a", ""]
    XCTAssertEqual("a.".substringComponents(separatedBy: "."), expected)
  }
  
  // MARK: - Indent
  
  func testStringExtensions_indent_addsIndentationToSingleLineString() {
    XCTAssertEqual("foo-bar".indent(by: 2), "    foo-bar")
  }
  
  func testStringExtensions_indent_addsIndentationToMultiLineString() {
    let actual = """
    line1
      line2
        line3
    """.indent(by: 2)
    let expected = """
        line1
          line2
            line3
    """
    XCTAssertEqual(actual, expected)
  }
  
  func testStringExtensions_indent_doesNotChangeEmptyStrings() {
    XCTAssertEqual("".indent(by: 2), "")
  }
  
  func testStringExtensions_indent_ignoresEmptyLines() {
    let actual = """
    line1
    
    line2

    line3
    """.indent(by: 2)
    let expected = """
        line1
    
        line2

        line3
    """
    XCTAssertEqual(actual, expected)
  }
  
  // MARK: - Removing parameter attributes
  
  func testStringExtensions_removingParameterAttributes_removesFunctionAttributes() {
    let actual = "@escaping @autoclosure (Int, Bool) -> String".removingParameterAttributes()
    XCTAssertEqual(actual, "(Int, Bool) -> String")
  }
  
  func testStringExtensions_removingParameterAttributes_removesInoutAttribute() {
    let actual = "inout String".removingParameterAttributes()
    XCTAssertEqual(actual, "String")
  }
  
  func testStringExtensions_removingParameterAttributes_removesTopLevelInoutAttribute() {
    let actual = "inout (inout Int, inout Bool) -> String".removingParameterAttributes()
    XCTAssertEqual(actual, "(inout Int, inout Bool) -> String")
  }
  
  func testStringExtensions_removingParameterAttributes_removesVariadicAttribute() {
    let actual = "String...".removingParameterAttributes()
    XCTAssertEqual(actual, "String")
  }
  
  func testStringExtensions_removingParameterAttributes_removesSpacedVariadicAttribute() {
    let actual = "String \n\t ...".removingParameterAttributes()
    XCTAssertEqual(actual, "String")
  }
  
  func testStringExtensions_removingParameterAttributes_removesTopLevelVariadicAttribute() {
    let actual = "(Int..., Bool ...) -> String".removingParameterAttributes()
    XCTAssertEqual(actual, "(Int..., Bool...) -> String")
  }
  
  // MARK: - Removing generic typing
  
  func testStringExtensions_removingGenericTyping_removesAllGenericTypes() {
    let actual = "Type1<A, B, C>.Type2.Type3<D, E, F>.Type4".removingGenericTyping()
    XCTAssertEqual(actual, "Type1.Type2.Type3.Type4")
  }
  
  func testStringExtensions_removingGenericTyping_ignoresNestedGenerics() {
    let actual = "Type1<A<Int>, B<String>, C<Bool>>.Type2".removingGenericTyping()
    XCTAssertEqual(actual, "Type1.Type2")
  }
  
  // MARK: - Contains needle
  
  func testStringExtensions_containsNeedle_excludesCharacterGroups() {
    let actual = "abc (d123ef) <gh123i>".contains("123", excluding: ["(": ")", "<": ">"])
    XCTAssertFalse(actual)
  }
  
  func testStringExtensions_containsNeedle_excludesDefinedCharacterGroupsOnly() {
    let actual = "abc (d123ef) <gh123i> [jkl123]".contains("123", excluding: ["(": ")", "<": ">"])
    XCTAssertTrue(actual)
  }
  
  func testStringExtensions_containsNeedle_handlesNeedlesDefinedAsGroupStartCharacter() {
    let actual = "abc <(def)> [ghi] (jkl)".contains("(", excluding: ["(": ")", "<": ">"])
    XCTAssertTrue(actual)
  }
  
  // MARK: - First index of needle
  
  func testStringExtensions_firstIndexOfNeedle_excludesCharacterGroups() {
    let actual = "abc (d123ef) <gh123i>".firstIndex(of: "123", excluding: ["(": ")", "<": ">"])
    XCTAssertNil(actual)
  }
  
  func testStringExtensions_firstIndexOfNeedle_excludesDefinedCharacterGroupsOnly() {
    let string = "abc (d123ef) <gh123i> [jkl123]"
    let actual = string.firstIndex(of: "123", excluding: ["(": ")", "<": ">"])
    XCTAssertEqual(actual, string.index(string.startIndex, offsetBy: 26))
  }
  
  func testStringExtensions_firstIndexOfNeedle_handlesNeedlesDefinedAsGroupStartCharacter() {
    let string = "abc <(def)> [ghi] (jkl)"
    let actual = string.firstIndex(of: "(", excluding: ["(": ")", "<": ">"])
    XCTAssertEqual(actual, string.index(string.startIndex, offsetBy: 18))
  }
  
  // MARK: - Components separated by
  
  func testStringExtensions_componentsSeparatedBySingleDelimiter_excludesCharacterGroups() {
    let actual = "abc.(de.f).<g.hi>".components(separatedBy: ".", excluding: ["(": ")", "<": ">"])
    XCTAssertEqual(actual, ["abc", "(de.f)", "<g.hi>"])
  }
  
  func testStringExtensions_componentsSeparatedByMultipleDelimiters_excludesCharacterGroups() {
    let actual = "abc.(d,e.f),<g.h,i>".components(separatedBy: [".", ","],
                                                  excluding: ["(": ")", "<": ">"])
    XCTAssertEqual(actual, ["abc", "(d,e.f)", "<g.h,i>"])
  }
}