Быстрое тестирование нескалярных типов

Question

Я хочу проверить свою функцию, которая принимает строку, а возвращает все пары символов в виде массива st

func pairsOfChars(_ s: String) -> [(Character,Character)] {
    let strArray = Array(s)
    var outputArray = [(Character,Character)]()
    for i in 0..<strArray.count - 1 {
        for j in i + 1..<strArray.count {
            outputArray.append( (strArray[i], strArray[j]) )
        }
    }
    return outputArray
}

Поэтому я хочу создать набор тестов с использованием XCTestCase.Я обычно использую XCTestCase и XCTAssertEqual, но они подходят только для скалярных типов Си.Это означает, что следующий тестовый пример возвращает ошибку:

    class pairsTests: XCTestCase {
        func testNaive() {
            measure {
                XCTAssertEqual( pairsOfChars("abc") , [(Character("a"),Character("b")),(Character("a"),Character("c")),(Character("b"),Character("c")) ] )
            }
        }
    }

Я мог бы преобразовать в строку, но я думаю, что есть лучшее решение.

Как я могупроверить вывод массива пар символов [[Character, Character)]

Answer 1

Ваше представление о нескалярном - это полная красная сельдь.Проблема заключается в уравнимости.

Как я могу проверить вывод массива пар символов [(Character,Character)]

Вы не можете, потому что нетпонятие по умолчанию о том, что будет означать приравнивать два таких массива.Это старая проблема «кортежи из Equatable не являются уравняемыми» (https://bugs.swift.org/browse/SR-1222), которая до сих пор возрождает свою голову с массивами. Оператор == работает с кортежами с помощью какой-то магии, но они по-прежнему не являются формально Equatable.

Вы можете определить уравновешенность массивов пар символов самостоятельно:

typealias CharPair = (Character,Character)
func ==(lhs:[CharPair], rhs:[CharPair]) -> Bool {
    if lhs.count != rhs.count {
        return false
    }
    let zipped = zip(lhs,rhs)
    return zipped.allSatisfy{$0 == $1}
}

В качестве альтернативы, ваш pairsOfChars может вернуть что-то, что легче сделать равным, например, массив структуры длякакой Equatable определен.

Например:

struct CharacterPair : Equatable {
    let c1:Character
    let c2:Character
    // in Swift 4.2 this next bit is not needed
    static func ==(lhs:CharacterPair, rhs:CharacterPair) -> Bool {
        return lhs.c1 == rhs.c1 && lhs.c2 == rhs.c2
    }
}

func pairsOfChars(_ s: String) -> [CharacterPair] {
    let strArray = Array(s)
    var outputArray = [CharacterPair]()
    for i in 0..<strArray.count - 1 {
        for j in i + 1..<strArray.count {
            outputArray.append(CharacterPair(c1:strArray[i],c2:strArray[j]))
        }
    }
    return outputArray
}

Затем необходимо переписать тест для соответствия:

XCTAssertEqual(
    pairsOfChars("abc"),
    [CharacterPair(c1:Character("a"),c2:Character("b")), 
         CharacterPair(c1:Character("a"),c2:Character("c")),
         CharacterPair(c1:Character("b"),c2:Character("c"))]
)