How to use ElementsEqualTest class

...34    self.expected = expected35    self.loc = SourceLoc(file, line, comment: "dropLast() test data")36  }37}38public struct ElementsEqualTest {39  public let expected: Bool40  public let sequence: [Int]41  public let other: [Int]42  public let expectedLeftoverSequence: [Int]43  public let expectedLeftoverOther: [Int]44  public let loc: SourceLoc45  public init(46    _ expected: Bool, _ sequence: [Int], _ other: [Int],47    _ expectedLeftoverSequence: [Int],48    _ expectedLeftoverOther: [Int],49    file: String = __FILE__, line: UInt = __LINE__,50    comment: String = ""51  ) {52    self.expected = expected53    self.sequence = sequence54    self.other = other55    self.expectedLeftoverSequence = expectedLeftoverSequence56    self.expectedLeftoverOther = expectedLeftoverOther57    self.loc = SourceLoc(file, line, comment: "test data" + comment)58  }59  func flip() -> ElementsEqualTest {60    return ElementsEqualTest(61      expected, other, sequence,62      expectedLeftoverOther, expectedLeftoverSequence,63      file: loc.file, line: loc.line, comment: " (flipped)")64  }65}66public struct EnumerateTest {67  public let expected: [(Int, Int)]68  public let sequence: [Int]69  public let loc: SourceLoc70  public init(71    _ expected: [(Int, Int)], _ sequence: [Int],72    file: String = __FILE__, line: UInt = __LINE__,73    comment: String = ""74  ) {75    self.expected = expected76    self.sequence = sequence77    self.loc = SourceLoc(file, line, comment: "test data" + comment)78  }79}80public struct FilterTest {81  public let expected: [Int]82  public let sequence: [Int]83  public let includeElement: (Int) -> Bool84  public let loc: SourceLoc85  public init(86    _ expected: [Int],87    _ sequence: [Int],88    _ includeElement: (Int) -> Bool,89    file: String = __FILE__, line: UInt = __LINE__90  ) {91    self.expected = expected92    self.sequence = sequence93    self.includeElement = includeElement94    self.loc = SourceLoc(file, line, comment: "test data")95  }96}97public struct FindTest {98  public let expected: Int?99  public let element: MinimalEquatableValue100  public let sequence: [MinimalEquatableValue]101  public let expectedLeftoverSequence: [MinimalEquatableValue]102  public let loc: SourceLoc103  public init(104    expected: Int?, element: Int, sequence: [Int],105    expectedLeftoverSequence: [Int],106    file: String = __FILE__, line: UInt = __LINE__107  ) {108    self.expected = expected109    self.element = MinimalEquatableValue(element)110    self.sequence = sequence.map(MinimalEquatableValue.init)111    self.expectedLeftoverSequence = expectedLeftoverSequence.map(112      MinimalEquatableValue.init)113    self.loc = SourceLoc(file, line, comment: "test data")114  }115}116public struct FlatMapTest {117  public let expected: [Int32]118  public let sequence: [Int]119  public let transform: (Int) -> [Int32]120  public let loc: SourceLoc121  public init(122    expected: [Int32],123    sequence: [Int],124    transform: (Int) -> [Int32],125    file: String = __FILE__, line: UInt = __LINE__126  ) {127    self.expected = expected128    self.sequence = sequence129    self.transform = transform130    self.loc = SourceLoc(file, line, comment: "test data")131  }132}133public struct FlatMapToOptionalTest {134  public let expected: [Int32]135  public let sequence: [Int]136  public let transform: (Int) -> Int32?137  public let loc: SourceLoc138  public init(139    _ expected: [Int32],140    _ sequence: [Int],141    _ transform: (Int) -> Int32?,142    file: String = __FILE__, line: UInt = __LINE__143  ) {144    self.expected = expected145    self.sequence = sequence146    self.transform = transform147    self.loc = SourceLoc(file, line, comment: "test data")148  }149}150/// This test performs a side effect on each element of `sequence`. The expected151/// side effect for the purposes of testing is to append each element to an152/// external array, which can be compared to `sequence`.153internal struct ForEachTest {154  let sequence: [Int]155  let loc: SourceLoc156  init(157    _ sequence: [Int],158    file: String = __FILE__, line: UInt = __LINE__159  ) {160    self.sequence = sequence161    self.loc = SourceLoc(file, line, comment: "test data")162  }163}164public struct LexicographicalCompareTest {165  public let expected: ExpectedComparisonResult166  public let sequence: [Int]167  public let other: [Int]168  public let expectedLeftoverSequence: [Int]169  public let expectedLeftoverOther: [Int]170  public let loc: SourceLoc171  public init(172    _ expected: ExpectedComparisonResult, _ sequence: [Int], _ other: [Int],173    _ expectedLeftoverSequence: [Int],174    _ expectedLeftoverOther: [Int],175    file: String = __FILE__, line: UInt = __LINE__,176    comment: String = ""177  ) {178    self.expected = expected179    self.sequence = sequence180    self.other = other181    self.expectedLeftoverSequence = expectedLeftoverSequence182    self.expectedLeftoverOther = expectedLeftoverOther183    self.loc = SourceLoc(file, line, comment: "test data" + comment)184  }185  func flip() -> LexicographicalCompareTest {186    return LexicographicalCompareTest(187      expected.flip(), other, sequence,188      expectedLeftoverOther, expectedLeftoverSequence,189      file: loc.file, line: loc.line, comment: " (flipped)")190  }191}192public struct MapTest {193  public let expected: [Int32]194  public let sequence: [Int]195  public let transform: (Int) -> Int32196  public let loc: SourceLoc197  public init(198    _ expected: [Int32],199    _ sequence: [Int],200    _ transform: (Int) -> Int32,201    file: String = __FILE__, line: UInt = __LINE__202  ) {203    self.expected = expected204    self.sequence = sequence205    self.transform = transform206    self.loc = SourceLoc(file, line, comment: "test data")207  }208}209public struct MinMaxElementTest {210  public let expectedMinValue: Int?211  public let expectedMinIndex: Int?212  public let expectedMaxValue: Int?213  public let expectedMaxIndex: Int?214  public let sequence: [Int]215  public let loc: SourceLoc216  public init(217    minValue expectedMinValue: Int?,218    index expectedMinIndex: Int?,219    maxValue expectedMaxValue: Int?,220    index expectedMaxIndex: Int?,221    _ sequence: [Int],222    file: String = __FILE__, line: UInt = __LINE__,223    comment: String = ""224  ) {225    self.expectedMinValue = expectedMinValue226    self.expectedMinIndex = expectedMinIndex227    self.expectedMaxValue = expectedMaxValue228    self.expectedMaxIndex = expectedMaxIndex229    self.sequence = sequence230    self.loc = SourceLoc(file, line, comment: "test data" + comment)231  }232}233public struct PrefixTest {234  public var sequence: [Int]235  public let maxLength: Int236  public let expected: [Int]237  public let loc: SourceLoc238  public init(sequence: [Int], maxLength: Int, expected: [Int],239      file: String = __FILE__, line: UInt = __LINE__) {240    self.sequence = sequence241    self.maxLength = maxLength242    self.expected = expected243    self.loc = SourceLoc(file, line, comment: "prefix() test data")244  }245}246public struct ReduceTest {247  public let sequence: [Int]248  public let loc: SourceLoc249  public init(250    _ sequence: [Int],251    file: String = __FILE__, line: UInt = __LINE__252  ) {253    self.sequence = sequence254    self.loc = SourceLoc(file, line, comment: "test data")255  }256}257public struct ReverseTest {258  public let expected: [Int]259  public let sequence: [Int]260  public let loc: SourceLoc261  public init(262    _ expected: [Int], _ sequence: [Int],263    file: String = __FILE__, line: UInt = __LINE__264  ) {265    self.expected = expected266    self.sequence = sequence267    self.loc = SourceLoc(file, line, comment: "test data")268  }269}270public struct SuffixTest {271  public var sequence: [Int]272  public let maxLength: Int273  public let expected: [Int]274  public let loc: SourceLoc275  public init(sequence: [Int], maxLength: Int, expected: [Int],276      file: String = __FILE__, line: UInt = __LINE__) {277    self.sequence = sequence278    self.maxLength = maxLength279    self.expected = expected280    self.loc = SourceLoc(file, line, comment: "suffix() test data")281  }282}283public struct SplitTest {284  public var sequence: [Int]285  public let maxSplit: Int286  public let separator: Int287  public let allowEmptySlices: Bool288  public let expected: [[Int]]289  public let loc: SourceLoc290  public init(sequence: [Int], maxSplit: Int, separator: Int, expected: [[Int]],291       allowEmptySlices: Bool, file: String = __FILE__, line: UInt = __LINE__) {292    self.sequence = sequence293    self.maxSplit = maxSplit294    self.separator = separator295    self.allowEmptySlices = allowEmptySlices296    self.expected = expected297    self.loc = SourceLoc(file, line, comment: "suffix() test data")298  }299}300public struct StartsWithTest {301  public let expected: Bool302  public let sequence: [Int]303  public let prefix: [Int]304  public let expectedLeftoverSequence: [Int]305  public let expectedLeftoverPrefix: [Int]306  public let loc: SourceLoc307  public init(308    _ expected: Bool, _ sequence: [Int], _ prefix: [Int],309    _ expectedLeftoverSequence: [Int],310    _ expectedLeftoverPrefix: [Int],311    file: String = __FILE__, line: UInt = __LINE__312  ) {313    self.expected = expected314    self.sequence = sequence315    self.prefix = prefix316    self.expectedLeftoverSequence = expectedLeftoverSequence317    self.expectedLeftoverPrefix = expectedLeftoverPrefix318    self.loc = SourceLoc(file, line, comment: "test data")319  }320}321public struct ZipTest {322  public let expected: [(Int, Int32)]323  public let sequence: [Int]324  public let other: [Int32]325  public let expectedLeftoverSequence: [Int]326  public let expectedLeftoverOther: [Int32]327  public let loc: SourceLoc328  public init(329    _ expected: [(Int, Int32)],330    sequences sequence: [Int],331    _ other: [Int32],332    leftovers expectedLeftoverSequence: [Int],333    _ expectedLeftoverOther: [Int32],334    file: String = __FILE__, line: UInt = __LINE__335  ) {336    self.expected = expected337    self.sequence = sequence338    self.other = other339    self.expectedLeftoverSequence = expectedLeftoverSequence340    self.expectedLeftoverOther = expectedLeftoverOther341    self.loc = SourceLoc(file, line, comment: "test data")342  }343}344public let elementsEqualTests: [ElementsEqualTest] = [345  ElementsEqualTest(true, [], [], [], []),346  ElementsEqualTest(false, [ 1 ], [], [], []),347  ElementsEqualTest(false, [], [ 1 ], [], []),348  ElementsEqualTest(false, [ 1, 2 ], [], [ 2 ], []),349  ElementsEqualTest(false, [], [ 1, 2 ], [], [ 2 ]),350  ElementsEqualTest(false, [ 1, 2, 3, 4 ], [ 1, 2 ], [ 4 ], []),351  ElementsEqualTest(false, [ 1, 2 ], [ 1, 2, 3, 4 ], [], [ 4 ]),352].flatMap { [ $0, $0.flip() ] }353public let enumerateTests = [354  EnumerateTest([], []),355  EnumerateTest([ (0, 10) ], [ 10 ]),356  EnumerateTest([ (0, 10), (1, 20) ], [ 10, 20 ]),357  EnumerateTest([ (0, 10), (1, 20), (2, 30) ], [ 10, 20, 30 ]),358]359public let filterTests = [360  FilterTest(361    [], [],362    { (x: Int) -> Bool in expectUnreachable(); return true }),363  FilterTest([], [ 0, 30, 10, 90 ], { (x: Int) -> Bool in false }),364  FilterTest(365    [ 0, 30, 10, 90 ], [ 0, 30, 10, 90 ], { (x: Int) -> Bool in true }...

1import Nimble2import XCTest3class ElementsEqualTest: XCTestCase {4    func testElementsEqual() {5        expect(array1).to(equal(array2))6    }7}8import XCTest9class ElementsEqualTest: XCTestCase {10    func testElementsEqual() {11        XCTAssertEqual(array1, array2)12    }13}14import XCTest15class ElementsEqualTest: XCTestCase {16    func testElementsEqual() {17        XCTAssert(array1.elementsEqual(array2))18    }19}20import XCTest21class ElementsEqualTest: XCTestCase {22    func testElementsEqual() {23        XCTAssert(array1 == array2)24    }25}26import XCTest27class ElementsEqualTest: XCTestCase {28    func testElementsEqual() {29        XCTAssertEqual(array1, array2, "Arrays are not equal")30    }31}32import XCTest33class ElementsEqualTest: XCTestCase {34    func testElementsEqual() {35        XCTAssertEqual(array1, array2, "Arrays are not equal", file: "1.swift", line: 10)36    }37}38import XCTest39class ElementsEqualTest: XCTestCase {40    func testElementsEqual() {

1import Nimble2import XCTest3class ElementsEqualTest: XCTestCase {4    func testElementsEqual() {5        expect([1, 2, 3]).to(equal([1, 2, 3]))6    }7}8import XCTest9class ElementsEqualTest: XCTestCase {10    func testElementsEqual() {11        XCTAssertEqual([1, 2, 3], [1, 2, 3])12    }13}14import Quick15import Nimble16import XCTest17class ElementsEqualTest: QuickSpec {18    override func spec() {19        it("elements should be equal") {20            expect([1, 2, 3]).to(equal([1, 2, 3]))21        }22    }23}24import Quick25import Nimble26import XCTest27class ElementsEqualTest: QuickSpec {28    override func spec() {29        it("elements should be equal") {30            XCTAssertEqual([1, 2, 3], [1, 2, 3])31        }32    }33}34import Quick35import Nimble36import XCTest37class ElementsEqualTest: QuickSpec {38    override func spec() {39        it("elements should be equal") {40            expect([1, 2, 3]).to(equal([1, 2, 3]))41            XCTAssertEqual([1, 2, 3], [1, 2, 3])42        }43    }44}45import Quick46import Nimble47import XCTest48class ElementsEqualTest: QuickSpec {49    override func spec() {50        it("elements should be equal") {51            expect([1, 2, 3]).to(equal([1, 2, 3]))52            XCTAssertEqual([1, 2, 3], [1, 2, 3])53            expect([1, 2, 3]).to(equal([1, 2, 3]))54            XCTAssertEqual([1, 2, 3], [1, 2, 3])

1import Nimble2import Quick3class ElementsEqualTest: QuickSpec {4    override func spec() {5        describe("ElementsEqualTest") {6            it("ElementsEqualTest") {7                expect(a).to(equal(b))8            }9        }10    }11}12import Quick13import Nimble14class ElementsEqualTest: QuickSpec {15    override func spec() {16        describe("ElementsEqualTest") {17            it("ElementsEqualTest") {18                expect(a).to(equal(b))19            }20        }21    }22}23import Quick24import Nimble25class ElementsEqualTest: QuickSpec {26    override func spec() {27        describe("ElementsEqualTest") {28            it("ElementsEqualTest") {29                expect(a).to(equal(b))30            }31        }32    }33}34import Quick35import Nimble36class ElementsEqualTest: QuickSpec {37    override func spec() {38        describe("ElementsEqualTest") {39            it("ElementsEqualTest") {40                expect(a).to(equal(b))41            }42        }43    }44}45import Quick46import Nimble47class ElementsEqualTest: QuickSpec {48    override func spec() {49        describe("ElementsEqualTest") {50            it("ElementsEqualTest") {51                expect(a).to(equal(b))52            }53        }54    }55}56import Quick57import Nimble58class ElementsEqualTest: QuickSpec {

1import Nimble2import XCTest3class ElementsEqualTest: XCTestCase {4    func testEqual() {5        expect([1, 2, 3]).to(equal([1, 2, 3]))6    }7    func testNotEqual() {8        expect([1, 2, 3]).toNot(equal([1, 2, 4]))9    }10    func testElementsEqual() {11        expect([1, 2, 3]).to(elementsEqual([3, 2, 1]))12    }13    func testElementsEqualNotEqual() {14        expect([1, 2, 3]).toNot(elementsEqual([3, 2, 1, 4]))15    }16}17import Nimble18import XCTest19class ElementsEqualTest: XCTestCase {20    func testEqual() {21        expect([1, 2, 3]).to(equal([1, 2, 3]))22    }23    func testNotEqual() {24        expect([1, 2, 3]).toNot(equal([1, 2, 4]))25    }26    func testElementsEqual() {27        expect([1, 2, 3]).to(elementsEqual([3, 2, 1]))28    }29    func testElementsEqualNotEqual() {30        expect([1, 2, 3]).toNot(elementsEqual([3, 2, 1, 4]))31    }32}33import Nimble34import XCTest35class ElementsEqualTest: XCTestCase {36    func testEqual() {37        expect([1, 2, 3]).to(equal([1, 2, 3]))38    }39    func testNotEqual() {40        expect([1, 2, 3]).toNot(equal([1, 2, 4]))41    }42    func testElementsEqual() {43        expect([1, 2, 3]).to(elementsEqual([3, 2, 1]))44    }45    func testElementsEqualNotEqual() {46        expect([1, 2, 3]).toNot(elementsEqual([3, 2, 1, 4]))47    }48}

1import Nimble2import Quick3class ElementsEqualTest: QuickSpec {4    override func spec() {5        describe("ElementsEqualTest") {6            it("tests ElementsEqual") {7                expect([1, 2, 3, 4]).to(equal([1, 2, 3, 4]))8            }9        }10    }11}12import XCTest13import Quick14import Nimble15class ElementsEqualTest: XCTestCase {16    override func setUp() {17        super.setUp()18        QuickSpec.current = ElementsEqualTest()19    }20    override func tearDown() {21        super.tearDown()22    }23    func testElementsEqual() {24        QuickSpec.current.run()25    }26}27import XCTest28@testable import Quick29class ElementsEqualTest: XCTestCase {30    func testElementsEqual() {31        let test = ElementsEqualTest()32        test.testElementsEqual()33    }34}35import XCTest36@testable import Quick37class ElementsEqualTest: XCTestCase {38    func testElementsEqual() {39        let test = ElementsEqualTest()40        test.testElementsEqual()41    }42}43import XCTest44@testable import Quick45class ElementsEqualTest: XCTestCase {46    func testElementsEqual() {47        let test = ElementsEqualTest()48        test.testElementsEqual()49    }50}51import XCTest52@testable import Quick53class ElementsEqualTest: XCTestCase {54    func testElementsEqual() {55        let test = ElementsEqualTest()56        test.testElementsEqual()57    }58}59import XCTest60@testable import Quick61class ElementsEqualTest: XCTestCase {62    func testElementsEqual() {63        let test = ElementsEqualTest()64        test.testElementsEqual()65    }66}67import XCTest68@testable import Quick69class ElementsEqualTest: XCTestCase {70    func testElementsEqual() {71        let test = ElementsEqualTest()

1import Nimble2import Quick3class ElementsEqualTest: QuickSpec {4    override func spec() {5        describe("ElementsEqualTest") {6            it("test1") {7                let result = [1, 2, 3].elementsEqual([1, 2, 3])8                expect(result).to(equal(true))9            }10        }11    }12}13import Nimble14import Quick15class ElementsEqualTest: QuickSpec {16    override func spec() {17        describe("ElementsEqualTest") {18            it("test2") {19                let result = [1, 2, 3].elementsEqual([1, 2, 3])20                expect(result).to(equal(true))21            }22        }23    }24}25import Nimble26import Quick27class ElementsEqualTest: QuickSpec {28    override func spec() {29        describe("ElementsEqualTest") {30            it("test3") {31                let result = [1, 2, 3].elementsEqual([1, 2, 3])32                expect(result).to(equal(true))33            }34        }35    }36}37import Nimble38import Quick39class ElementsEqualTest: QuickSpec {40    override func spec() {41        describe("ElementsEqualTest") {42            it("test4") {43                let result = [1, 2, 3].elementsEqual([1, 2, 3])44                expect(result).to(equal(true))45            }46        }47    }48}49import Nimble50import Quick51class ElementsEqualTest: QuickSpec {52    override func spec() {53        describe("ElementsEqualTest") {54            it("test5") {55                let result = [1, 2, 3].elementsEqual([1, 2, 3])56                expect(result).to(equal(true))57            }58        }59    }60}61import Nimble62import Quick63class ElementsEqualTest: QuickSpec {64    override func spec() {

1import Nimble2import Quick3class ElementsEqualTest: QuickSpec {4    override func spec() {5        describe("ElementsEqualTest") {6            it("test") {7                expect(array).to(elementsEqual([1,2,3,4]))8            }9        }10    }11}

1import Foundation2import Nimble3expect(arr1).to(equal(arr2))4expect(arr1).toNot(equal(arr2))5expect(arr1).to(equal(arr2))6expect(arr1).toNot(equal(arr2))7expect(arr1).to(beEquivalentTo(arr2))8expect(arr1).toNot(beEquivalentTo(arr2))9expect(arr1).to(beIdenticalTo(arr2))10expect(arr1).toNot(beIdenticalTo(arr2))11expect(arr1).to(beIdenticalTo(arr2))12expect(arr1).toNot(beIdenticalTo(arr2))13expect(arr1).to(beIdenticalTo(arr2))14expect(arr1).toNot(beIdenticalTo(arr2))15expect(arr1).to(beIdenticalTo(arr2))16expect(arr1).toNot(beIdenticalTo(arr2))17expect(arr1).to(beIdenticalTo(arr2))18expect(arr1).toNot(beIdenticalTo(arr2))19expect(arr1).to(beIdenticalTo(arr2))20expect(arr1).toNot(beIdenticalTo(arr2))21expect(arr1).to(beIdenticalTo(arr2))22expect(arr1).toNot(beIdenticalTo(arr2))23expect(arr1).to(beIdenticalTo(arr2))24expect(arr1).toNot(beIdenticalTo(arr2))

1import Nimble2import Quick3class ElementsEqualTestSpec: QuickSpec {4    override func spec() {5        describe("ElementsEqualTest") {6            it("should return true if the elements are equal") {7                expect(array.elementsEqual([1, 2, 3, 4, 5])).to(beTrue())8            }9            it("should return false if the elements are not equal") {10                expect(array.elementsEqual([1, 2, 3, 4, 5, 6])).to(beFalse())11            }12        }13    }14}15import Quick16import Nimble17class ElementsEqualTestSpec: QuickSpec {18    override func spec() {19        describe("ElementsEqualTest") {20            it("should return true if the elements are equal") {21                expect(array.elementsEqual([1, 2, 3, 4, 5])).to(beTrue())22            }23            it("should return false if the elements are not equal") {24                expect(array.elementsEqual([1, 2, 3, 4, 5, 6])).to(beFalse())25            }26        }27    }28}29import XCTest30@testable import ElementsEqualTest31class ElementsEqualTestSpec: XCTestCase {32    func testElementsEqual() {33        XCTAssertTrue(array.elementsEqual([1, 2, 3, 4, 5]))34        XCTAssertFalse(array.elementsEqual([1, 2, 3, 4, 5, 6]))35    }36}37import XCTest38@testable import ElementsEqualTest39class ElementsEqualTestSpec: XCTestCase {40    func testElementsEqual() {