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
|
//===----------------------------------------------------------------------===//
//
// This source file is part of the SwiftCrypto open source project
//
// Copyright (c) 2019 Apple Inc. and the SwiftCrypto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.md for the list of SwiftCrypto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//
#if CRYPTO_IN_SWIFTPM && !CRYPTO_IN_SWIFTPM_FORCE_BUILD_API
#else
@testable import Crypto
import XCTest
final class ArbitraryPrecisionIntegerTests: XCTestCase {
func testSimpleArithmetic() {
let six = ArbitraryPrecisionInteger(6)
let twelve = ArbitraryPrecisionInteger(12)
let result = six * twelve
XCTAssertEqual(result, 72)
}
func testPositivity() {
let six = ArbitraryPrecisionInteger(6)
let negativeOne = ArbitraryPrecisionInteger(-1)
XCTAssertFalse(negativeOne._positive)
XCTAssertFalse((six * negativeOne)._positive)
XCTAssertTrue((six * negativeOne * negativeOne)._positive)
}
func testSquaring() {
let six = ArbitraryPrecisionInteger(6)
XCTAssertEqual(six.squared(), 36)
XCTAssertEqual(six, 6)
}
func testPositiveSquareRoot() {
XCTAssertNoThrow(XCTAssertEqual(try ArbitraryPrecisionInteger(144).positiveSquareRoot(), 12))
XCTAssertThrowsError(try ArbitraryPrecisionInteger(101).positiveSquareRoot()) { error in
guard case .some(.underlyingCoreCryptoError) = error as? CryptoKitError else {
XCTFail("Unexpected error: \(error)")
return
}
}
}
func testSimpleRepresentation() {
let six = ArbitraryPrecisionInteger(60)
XCTAssertEqual(six.debugDescription, "3c")
}
func testMoreArithmetic() {
let fifteen = ArbitraryPrecisionInteger(15) + .zero
let sixteen = fifteen + 1
var sixteenTwo = sixteen
sixteenTwo += 4
let ten = sixteenTwo - 10
sixteenTwo -= 4
XCTAssertEqual(fifteen, 15)
XCTAssertEqual(sixteen, 16)
XCTAssertEqual(sixteenTwo, 16)
XCTAssertEqual(ten, 10)
}
func testNegationAndAbsoluteValues() {
let oneOhFour = ArbitraryPrecisionInteger(104)
var copy = oneOhFour
copy.negate()
XCTAssertEqual(copy, ArbitraryPrecisionInteger(-104))
XCTAssertEqual(copy.magnitude, oneOhFour.magnitude)
XCTAssertEqual(copy.magnitude, oneOhFour)
}
func testAllInPlaceArithmeticCoWs() {
let base = ArbitraryPrecisionInteger(5)
var adder = base
var subber = base
var timeser = base
adder += base
subber -= base
timeser *= base
XCTAssertEqual(base, 5)
XCTAssertEqual(adder, 10)
XCTAssertEqual(subber, 0)
XCTAssertEqual(timeser, 25)
}
func testComparable() {
let one = ArbitraryPrecisionInteger(1)
let two = ArbitraryPrecisionInteger(2)
// Not using XCTAssertLessThan and friends
// because we want to test these operators specifically.
XCTAssertTrue(one < two)
XCTAssertTrue(one <= two)
XCTAssertFalse(one < one)
XCTAssertTrue(one <= one)
XCTAssertTrue(two > one)
XCTAssertTrue(two >= one)
XCTAssertFalse(two > two)
XCTAssertTrue(two >= two)
}
}
#endif // CRYPTO_IN_SWIFTPM && !CRYPTO_IN_SWIFTPM_FORCE_BUILD_API
|
