RxSwift/RxTest/Event+Equatable.swift at main · ReactiveX/RxSwift · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
//
//  Event+Equatable.swift
//  RxTest
//
//  Created by Krunoslav Zaher on 12/19/15.
//  Copyright © 2015 Krunoslav Zaher. All rights reserved.
//

import Foundation
import RxSwift

func equals<Element: Equatable>(lhs: Event<Element>, rhs: Event<Element>) -> Bool {
    switch (lhs, rhs) {
    case (.completed, .completed): return true
    case let (.error(e1), .error(e2)):
        #if os(Linux)
        return "\(e1)" == "\(e2)"
        #else
        let error1 = e1 as NSError
        let error2 = e2 as NSError

        return error1.domain == error2.domain
            && error1.code == error2.code
            && "\(e1)" == "\(e2)"
        #endif
    case let (.next(v1), .next(v2)): return v1 == v2
    default: return false
    }
}

func equals<Element: Equatable>(lhs: Event<Element?>, rhs: Event<Element?>) -> Bool {
    switch (lhs, rhs) {
    case (.completed, .completed): return true
    case let (.error(e1), .error(e2)):
        #if os(Linux)
        return "\(e1)" == "\(e2)"
        #else
        let error1 = e1 as NSError
        let error2 = e2 as NSError

        return error1.domain == error2.domain
            && error1.code == error2.code
            && "\(e1)" == "\(e2)"
        #endif
    case let (.next(v1), .next(v2)): return v1 == v2
    default: return false
    }
}

func equals<Element: Equatable>(lhs: SingleEvent<Element>, rhs: SingleEvent<Element>) -> Bool {
    switch (lhs, rhs) {
    case let (.failure(e1), .failure(e2)):
        #if os(Linux)
        return "\(e1)" == "\(e2)"
        #else
        let error1 = e1 as NSError
        let error2 = e2 as NSError

        return error1.domain == error2.domain
            && error1.code == error2.code
            && "\(e1)" == "\(e2)"
        #endif
    case let (.success(v1), .success(v2)): return v1 == v2
    default: return false
    }
}

func equals<Element: Equatable>(lhs: MaybeEvent<Element>, rhs: MaybeEvent<Element>) -> Bool {
    switch (lhs, rhs) {
    case (.completed, .completed): return true
    case let (.error(e1), .error(e2)):
        #if os(Linux)
        return "\(e1)" == "\(e2)"
        #else
        let error1 = e1 as NSError
        let error2 = e2 as NSError

        return error1.domain == error2.domain
            && error1.code == error2.code
            && "\(e1)" == "\(e2)"
        #endif
    case let (.success(v1), .success(v2)): return v1 == v2
    default: return false
    }
}

/// Compares two `CompletableEvent` events.
///
/// In case `Error` events are being compared, they are equal in case their `NSError` representations are equal (domain and code)
/// and their string representations are equal.
extension CompletableEvent: Equatable {
    public static func == (lhs: CompletableEvent, rhs: CompletableEvent) -> Bool {
        switch (lhs, rhs) {
        case (.completed, .completed): return true
        case let (.error(e1), .error(e2)):
            #if os(Linux)
            return "\(e1)" == "\(e2)"
            #else
            let error1 = e1 as NSError
            let error2 = e2 as NSError

            return error1.domain == error2.domain
                && error1.code == error2.code
                && "\(e1)" == "\(e2)"
            #endif
        default: return false
        }
    }
}

extension Event: Equatable where Element: Equatable {
    public static func == (lhs: Event<Element>, rhs: Event<Element>) -> Bool {
        equals(lhs: lhs, rhs: rhs)
    }
}

extension MaybeEvent: Equatable where Element: Equatable {
    public static func == (lhs: MaybeEvent<Element>, rhs: MaybeEvent<Element>) -> Bool {
        equals(lhs: lhs, rhs: rhs)
    }
}