You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
808 lines
27 KiB
808 lines
27 KiB
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copyright 2014 Realm Inc.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
import XCTest
|
|
import RealmSwift
|
|
|
|
#if !swift(>=4.1)
|
|
extension Sequence {
|
|
func compactMap<ElementOfResult>(_ transform: (Self.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult] {
|
|
return try flatMap(transform)
|
|
}
|
|
}
|
|
#endif
|
|
|
|
class ListTests: TestCase {
|
|
var str1: SwiftStringObject?
|
|
var str2: SwiftStringObject?
|
|
var arrayObject: SwiftArrayPropertyObject!
|
|
var array: List<SwiftStringObject>?
|
|
|
|
func createArray() -> SwiftArrayPropertyObject {
|
|
fatalError("abstract")
|
|
}
|
|
|
|
func createArrayWithLinks() -> SwiftListOfSwiftObject {
|
|
fatalError("abstract")
|
|
}
|
|
|
|
override func setUp() {
|
|
super.setUp()
|
|
|
|
let str1 = SwiftStringObject()
|
|
str1.stringCol = "1"
|
|
self.str1 = str1
|
|
|
|
let str2 = SwiftStringObject()
|
|
str2.stringCol = "2"
|
|
self.str2 = str2
|
|
|
|
arrayObject = createArray()
|
|
array = arrayObject.array
|
|
|
|
let realm = realmWithTestPath()
|
|
try! realm.write {
|
|
realm.add(str1)
|
|
realm.add(str2)
|
|
}
|
|
|
|
realm.beginWrite()
|
|
}
|
|
|
|
override func tearDown() {
|
|
try! realmWithTestPath().commitWrite()
|
|
|
|
str1 = nil
|
|
str2 = nil
|
|
arrayObject = nil
|
|
array = nil
|
|
|
|
super.tearDown()
|
|
}
|
|
|
|
#if swift(>=4)
|
|
override class var defaultTestSuite: XCTestSuite {
|
|
// Don't run tests for the base class
|
|
if isEqual(ListTests.self) {
|
|
return XCTestSuite(name: "empty")
|
|
}
|
|
return super.defaultTestSuite
|
|
}
|
|
#else
|
|
override class func defaultTestSuite() -> XCTestSuite {
|
|
// Don't run tests for the base class
|
|
if isEqual(ListTests.self) {
|
|
return XCTestSuite(name: "empty")
|
|
}
|
|
return super.defaultTestSuite()
|
|
}
|
|
#endif
|
|
|
|
func testPrimitive() {
|
|
let obj = SwiftListObject()
|
|
obj.int.append(5)
|
|
XCTAssertEqual(obj.int.first!, 5)
|
|
XCTAssertEqual(obj.int.last!, 5)
|
|
XCTAssertEqual(obj.int[0], 5)
|
|
obj.int.append(objectsIn: [6, 7, 8] as [Int])
|
|
XCTAssertEqual(obj.int.index(of: 6), 1)
|
|
XCTAssertEqual(2, obj.int.index(matching: NSPredicate(format: "self == 7")))
|
|
XCTAssertNil(obj.int.index(matching: NSPredicate(format: "self == 9")))
|
|
XCTAssertEqual(obj.int.max(), 8)
|
|
XCTAssertEqual(obj.int.sum(), 26)
|
|
|
|
obj.string.append("str")
|
|
XCTAssertEqual(obj.string.first!, "str")
|
|
XCTAssertEqual(obj.string[0], "str")
|
|
}
|
|
|
|
func testPrimitiveIterationAcrossNil() {
|
|
let obj = SwiftListObject()
|
|
XCTAssertFalse(obj.int.contains(5))
|
|
XCTAssertFalse(obj.int8.contains(5))
|
|
XCTAssertFalse(obj.int16.contains(5))
|
|
XCTAssertFalse(obj.int32.contains(5))
|
|
XCTAssertFalse(obj.int64.contains(5))
|
|
XCTAssertFalse(obj.float.contains(3.141592))
|
|
XCTAssertFalse(obj.double.contains(3.141592))
|
|
XCTAssertFalse(obj.string.contains("foobar"))
|
|
XCTAssertFalse(obj.data.contains(Data()))
|
|
XCTAssertFalse(obj.date.contains(Date()))
|
|
|
|
XCTAssertFalse(obj.intOpt.contains { $0 == nil })
|
|
XCTAssertFalse(obj.int8Opt.contains { $0 == nil })
|
|
XCTAssertFalse(obj.int16Opt.contains { $0 == nil })
|
|
XCTAssertFalse(obj.int32Opt.contains { $0 == nil })
|
|
XCTAssertFalse(obj.int64Opt.contains { $0 == nil })
|
|
XCTAssertFalse(obj.floatOpt.contains { $0 == nil })
|
|
XCTAssertFalse(obj.doubleOpt.contains { $0 == nil })
|
|
XCTAssertFalse(obj.stringOpt.contains { $0 == nil })
|
|
XCTAssertFalse(obj.dataOpt.contains { $0 == nil })
|
|
XCTAssertFalse(obj.dateOpt.contains { $0 == nil })
|
|
}
|
|
|
|
func testInvalidated() {
|
|
guard let array = array else {
|
|
fatalError("Test precondition failure")
|
|
}
|
|
XCTAssertFalse(array.isInvalidated)
|
|
|
|
if let realm = arrayObject.realm {
|
|
realm.delete(arrayObject)
|
|
XCTAssertTrue(array.isInvalidated)
|
|
}
|
|
}
|
|
|
|
func testFastEnumerationWithMutation() {
|
|
guard let array = array, let str1 = str1, let str2 = str2 else {
|
|
fatalError("Test precondition failure")
|
|
}
|
|
|
|
array.append(objectsIn: [str1, str2, str1, str2, str1, str2, str1, str2, str1,
|
|
str2, str1, str2, str1, str2, str1, str2, str1, str2, str1, str2])
|
|
var str = ""
|
|
for obj in array {
|
|
str += obj.stringCol
|
|
array.append(objectsIn: [str1])
|
|
}
|
|
|
|
XCTAssertEqual(str, "12121212121212121212")
|
|
}
|
|
|
|
func testAppendObject() {
|
|
guard let array = array, let str1 = str1, let str2 = str2 else {
|
|
fatalError("Test precondition failure")
|
|
}
|
|
for str in [str1, str2, str1] {
|
|
array.append(str)
|
|
}
|
|
XCTAssertEqual(Int(3), array.count)
|
|
assertEqual(str1, array[0])
|
|
assertEqual(str2, array[1])
|
|
assertEqual(str1, array[2])
|
|
}
|
|
|
|
func testAppendArray() {
|
|
guard let array = array, let str1 = str1, let str2 = str2 else {
|
|
fatalError("Test precondition failure")
|
|
}
|
|
array.append(objectsIn: [str1, str2, str1])
|
|
XCTAssertEqual(Int(3), array.count)
|
|
assertEqual(str1, array[0])
|
|
assertEqual(str2, array[1])
|
|
assertEqual(str1, array[2])
|
|
}
|
|
|
|
func testAppendResults() {
|
|
guard let array = array, let str1 = str1, let str2 = str2 else {
|
|
fatalError("Test precondition failure")
|
|
}
|
|
array.append(objectsIn: realmWithTestPath().objects(SwiftStringObject.self))
|
|
XCTAssertEqual(Int(2), array.count)
|
|
assertEqual(str1, array[0])
|
|
assertEqual(str2, array[1])
|
|
}
|
|
|
|
func testInsert() {
|
|
guard let array = array, let str1 = str1, let str2 = str2 else {
|
|
fatalError("Test precondition failure")
|
|
}
|
|
|
|
XCTAssertEqual(Int(0), array.count)
|
|
|
|
array.insert(str1, at: 0)
|
|
XCTAssertEqual(Int(1), array.count)
|
|
assertEqual(str1, array[0])
|
|
|
|
array.insert(str2, at: 0)
|
|
XCTAssertEqual(Int(2), array.count)
|
|
assertEqual(str2, array[0])
|
|
assertEqual(str1, array[1])
|
|
|
|
assertThrows(_ = array.insert(str2, at: 200))
|
|
assertThrows(_ = array.insert(str2, at: -200))
|
|
}
|
|
|
|
func testRemoveAtIndex() {
|
|
guard let array = array, let str1 = str1, let str2 = str2 else {
|
|
fatalError("Test precondition failure")
|
|
}
|
|
|
|
array.append(objectsIn: [str1, str2, str1])
|
|
|
|
array.remove(at: 1)
|
|
assertEqual(str1, array[0])
|
|
assertEqual(str1, array[1])
|
|
|
|
assertThrows(array.remove(at: 2))
|
|
assertThrows(array.remove(at: -2))
|
|
}
|
|
|
|
func testRemoveLast() {
|
|
guard let array = array, let str1 = str1, let str2 = str2 else {
|
|
fatalError("Test precondition failure")
|
|
}
|
|
|
|
array.append(objectsIn: [str1, str2])
|
|
|
|
array.removeLast()
|
|
XCTAssertEqual(Int(1), array.count)
|
|
assertEqual(str1, array[0])
|
|
|
|
array.removeLast()
|
|
XCTAssertEqual(Int(0), array.count)
|
|
|
|
assertThrows(array.removeLast()) // Should throw if already empty
|
|
}
|
|
|
|
func testRemoveAll() {
|
|
guard let array = array, let str1 = str1, let str2 = str2 else {
|
|
fatalError("Test precondition failure")
|
|
}
|
|
|
|
array.append(objectsIn: [str1, str2])
|
|
|
|
array.removeAll()
|
|
XCTAssertEqual(Int(0), array.count)
|
|
|
|
array.removeAll() // should be a no-op
|
|
XCTAssertEqual(Int(0), array.count)
|
|
}
|
|
|
|
func testReplace() {
|
|
guard let array = array, let str1 = str1, let str2 = str2 else {
|
|
fatalError("Test precondition failure")
|
|
}
|
|
|
|
array.append(objectsIn: [str1, str1])
|
|
|
|
array.replace(index: 0, object: str2)
|
|
XCTAssertEqual(Int(2), array.count)
|
|
assertEqual(str2, array[0])
|
|
assertEqual(str1, array[1])
|
|
|
|
array.replace(index: 1, object: str2)
|
|
XCTAssertEqual(Int(2), array.count)
|
|
assertEqual(str2, array[0])
|
|
assertEqual(str2, array[1])
|
|
|
|
assertThrows(array.replace(index: 200, object: str2))
|
|
assertThrows(array.replace(index: -200, object: str2))
|
|
}
|
|
|
|
func testMove() {
|
|
guard let array = array, let str1 = str1, let str2 = str2 else {
|
|
fatalError("Test precondition failure")
|
|
}
|
|
|
|
array.append(objectsIn: [str1, str2])
|
|
|
|
array.move(from: 1, to: 0)
|
|
|
|
XCTAssertEqual(array[0].stringCol, "2")
|
|
XCTAssertEqual(array[1].stringCol, "1")
|
|
|
|
array.move(from: 0, to: 1)
|
|
|
|
XCTAssertEqual(array[0].stringCol, "1")
|
|
XCTAssertEqual(array[1].stringCol, "2")
|
|
|
|
array.move(from: 0, to: 0)
|
|
|
|
XCTAssertEqual(array[0].stringCol, "1")
|
|
XCTAssertEqual(array[1].stringCol, "2")
|
|
|
|
assertThrows(array.move(from: 0, to: 2))
|
|
assertThrows(array.move(from: 2, to: 0))
|
|
}
|
|
|
|
func testReplaceRange() {
|
|
guard let array = array, let str1 = str1, let str2 = str2 else {
|
|
fatalError("Test precondition failure")
|
|
}
|
|
|
|
array.append(objectsIn: [str1, str1])
|
|
|
|
array.replaceSubrange(0..<1, with: [str2])
|
|
XCTAssertEqual(Int(2), array.count)
|
|
assertEqual(str2, array[0])
|
|
assertEqual(str1, array[1])
|
|
|
|
array.replaceSubrange(1..<2, with: [str2])
|
|
XCTAssertEqual(Int(2), array.count)
|
|
assertEqual(str2, array[0])
|
|
assertEqual(str2, array[1])
|
|
|
|
array.replaceSubrange(0..<0, with: [str2])
|
|
XCTAssertEqual(Int(3), array.count)
|
|
assertEqual(str2, array[0])
|
|
assertEqual(str2, array[1])
|
|
assertEqual(str2, array[2])
|
|
|
|
array.replaceSubrange(0..<3, with: [])
|
|
XCTAssertEqual(Int(0), array.count)
|
|
|
|
assertThrows(array.replaceSubrange(200..<201, with: [str2]))
|
|
assertThrows(array.replaceSubrange(-200..<200, with: [str2]))
|
|
assertThrows(array.replaceSubrange(0..<200, with: [str2]))
|
|
}
|
|
|
|
func testSwapAt() {
|
|
guard let array = array, let str1 = str1, let str2 = str2 else {
|
|
fatalError("Test precondition failure")
|
|
}
|
|
|
|
array.append(objectsIn: [str1, str2])
|
|
|
|
array.swapAt(0, 1)
|
|
XCTAssertEqual(Int(2), array.count)
|
|
assertEqual(str2, array[0])
|
|
assertEqual(str1, array[1])
|
|
|
|
array.swapAt(1, 1)
|
|
XCTAssertEqual(Int(2), array.count)
|
|
assertEqual(str2, array[0])
|
|
assertEqual(str1, array[1])
|
|
|
|
assertThrows(array.swapAt(-1, 0))
|
|
assertThrows(array.swapAt(0, -1))
|
|
assertThrows(array.swapAt(1000, 0))
|
|
assertThrows(array.swapAt(0, 1000))
|
|
}
|
|
|
|
func testChangesArePersisted() {
|
|
guard let array = array, let str1 = str1, let str2 = str2 else {
|
|
fatalError("Test precondition failure")
|
|
}
|
|
if let realm = array.realm {
|
|
array.append(objectsIn: [str1, str2])
|
|
|
|
let otherArray = realm.objects(SwiftArrayPropertyObject.self).first!.array
|
|
XCTAssertEqual(Int(2), otherArray.count)
|
|
}
|
|
}
|
|
|
|
func testPopulateEmptyArray() {
|
|
guard let array = array else {
|
|
fatalError("Test precondition failure")
|
|
}
|
|
|
|
XCTAssertEqual(array.count, 0, "Should start with no array elements.")
|
|
|
|
let obj = SwiftStringObject()
|
|
obj.stringCol = "a"
|
|
array.append(obj)
|
|
array.append(realmWithTestPath().create(SwiftStringObject.self, value: ["b"]))
|
|
array.append(obj)
|
|
|
|
XCTAssertEqual(array.count, 3)
|
|
XCTAssertEqual(array[0].stringCol, "a")
|
|
XCTAssertEqual(array[1].stringCol, "b")
|
|
XCTAssertEqual(array[2].stringCol, "a")
|
|
|
|
// Make sure we can enumerate
|
|
for obj in array {
|
|
XCTAssertTrue(obj.description.utf16.count > 0, "Object should have description")
|
|
}
|
|
}
|
|
|
|
func testEnumeratingListWithListProperties() {
|
|
let arrayObject = createArrayWithLinks()
|
|
|
|
arrayObject.realm?.beginWrite()
|
|
for _ in 0..<10 {
|
|
arrayObject.array.append(SwiftObject())
|
|
}
|
|
try! arrayObject.realm?.commitWrite()
|
|
|
|
XCTAssertEqual(10, arrayObject.array.count)
|
|
|
|
for object in arrayObject.array {
|
|
XCTAssertEqual(123, object.intCol)
|
|
XCTAssertEqual(false, object.objectCol!.boolCol)
|
|
XCTAssertEqual(0, object.arrayCol.count)
|
|
}
|
|
}
|
|
|
|
func testValueForKey() {
|
|
do {
|
|
let realm = try! Realm()
|
|
try! realm.write {
|
|
for value in [1, 2] {
|
|
let listObject = SwiftListOfSwiftObject()
|
|
let object = SwiftObject()
|
|
object.intCol = value
|
|
object.doubleCol = Double(value)
|
|
object.stringCol = String(value)
|
|
listObject.array.append(object)
|
|
realm.add(listObject)
|
|
}
|
|
}
|
|
|
|
do {
|
|
let objects = realm.objects(SwiftListOfSwiftObject.self)
|
|
|
|
let properties: [Int] = Array(objects.flatMap { $0.array.map { $0.intCol }})
|
|
let listsOfObjects = objects.value(forKeyPath: "array") as! [List<SwiftObject>]
|
|
let kvcProperties: [Int] = Array(listsOfObjects.flatMap { $0.map { $0.intCol }})
|
|
|
|
XCTAssertEqual(properties, kvcProperties)
|
|
}
|
|
do {
|
|
let objects = realm.objects(SwiftListOfSwiftObject.self)
|
|
|
|
let properties = Array(objects.flatMap { $0.array.map { $0.doubleCol }})
|
|
let listsOfObjects = objects.value(forKeyPath: "array") as! [List<SwiftObject>]
|
|
let kvcProperties = Array(listsOfObjects.flatMap { $0.map { $0.doubleCol }})
|
|
|
|
XCTAssertEqual(properties, kvcProperties)
|
|
}
|
|
do {
|
|
let objects = realm.objects(SwiftListOfSwiftObject.self)
|
|
|
|
let properties = Array(objects.flatMap { $0.array.map { $0.stringCol }})
|
|
let listsOfObjects = objects.value(forKeyPath: "array") as! [List<SwiftObject>]
|
|
let kvcProperties = Array(listsOfObjects.flatMap { $0.map { $0.stringCol }})
|
|
|
|
XCTAssertEqual(properties, kvcProperties)
|
|
}
|
|
|
|
do {
|
|
let realm = try! Realm()
|
|
do {
|
|
let objects = realm.objects(SwiftObject.self)
|
|
|
|
let properties = Array(objects.compactMap { $0.intCol })
|
|
let listsOfObjects = objects.value(forKeyPath: "intCol") as! [Int]
|
|
let kvcProperties = Array(listsOfObjects.compactMap { $0 })
|
|
|
|
XCTAssertEqual(properties, kvcProperties)
|
|
}
|
|
do {
|
|
let objects = realm.objects(SwiftObject.self)
|
|
|
|
let properties = Array(objects.compactMap { $0.doubleCol })
|
|
let listsOfObjects = objects.value(forKeyPath: "doubleCol") as! [Double]
|
|
let kvcProperties = Array(listsOfObjects.compactMap { $0 })
|
|
|
|
XCTAssertEqual(properties, kvcProperties)
|
|
}
|
|
do {
|
|
let objects = realm.objects(SwiftObject.self)
|
|
|
|
let properties = Array(objects.compactMap { $0.stringCol })
|
|
let listsOfObjects = objects.value(forKeyPath: "stringCol") as! [String]
|
|
let kvcProperties = Array(listsOfObjects.compactMap { $0 })
|
|
|
|
XCTAssertEqual(properties, kvcProperties)
|
|
}
|
|
}
|
|
}
|
|
|
|
do {
|
|
let realm = try! Realm()
|
|
try! realm.write {
|
|
for value in [1, 2] {
|
|
let listObject = SwiftListOfSwiftOptionalObject()
|
|
let object = SwiftOptionalObject()
|
|
object.optIntCol.value = value
|
|
object.optInt8Col.value = Int8(value)
|
|
object.optDoubleCol.value = Double(value)
|
|
object.optStringCol = String(value)
|
|
object.optNSStringCol = NSString(format: "%d", value)
|
|
listObject.array.append(object)
|
|
realm.add(listObject)
|
|
}
|
|
}
|
|
|
|
do {
|
|
let objects = realm.objects(SwiftListOfSwiftOptionalObject.self)
|
|
|
|
let properties = Array(objects.flatMap { $0.array.compactMap { $0.optIntCol.value }})
|
|
let listsOfObjects = objects.value(forKeyPath: "array") as! [List<SwiftOptionalObject>]
|
|
let kvcProperties = Array(listsOfObjects.flatMap { $0.compactMap { $0.optIntCol.value }})
|
|
|
|
XCTAssertEqual(properties, kvcProperties)
|
|
}
|
|
do {
|
|
let objects = realm.objects(SwiftListOfSwiftOptionalObject.self)
|
|
|
|
let properties = Array(objects.flatMap { $0.array.compactMap { $0.optInt8Col.value }})
|
|
let listsOfObjects = objects.value(forKeyPath: "array") as! [List<SwiftOptionalObject>]
|
|
let kvcProperties = Array(listsOfObjects.flatMap { $0.compactMap { $0.optInt8Col.value }})
|
|
|
|
XCTAssertEqual(properties, kvcProperties)
|
|
}
|
|
do {
|
|
let objects = realm.objects(SwiftListOfSwiftOptionalObject.self)
|
|
|
|
let properties = Array(objects.flatMap { $0.array.compactMap { $0.optDoubleCol.value }})
|
|
let listsOfObjects = objects.value(forKeyPath: "array") as! [List<SwiftOptionalObject>]
|
|
let kvcProperties = Array(listsOfObjects.flatMap { $0.compactMap { $0.optDoubleCol.value }})
|
|
|
|
XCTAssertEqual(properties, kvcProperties)
|
|
}
|
|
do {
|
|
let objects = realm.objects(SwiftListOfSwiftOptionalObject.self)
|
|
|
|
let properties = Array(objects.flatMap { $0.array.compactMap { $0.optStringCol }})
|
|
let listsOfObjects = objects.value(forKeyPath: "array") as! [List<SwiftOptionalObject>]
|
|
let kvcProperties = Array(listsOfObjects.flatMap { $0.compactMap { $0.optStringCol }})
|
|
|
|
XCTAssertEqual(properties, kvcProperties)
|
|
}
|
|
do {
|
|
let objects = realm.objects(SwiftListOfSwiftOptionalObject.self)
|
|
|
|
let properties = Array(objects.flatMap { $0.array.compactMap { $0.optNSStringCol }})
|
|
let listsOfObjects = objects.value(forKeyPath: "array") as! [List<SwiftOptionalObject>]
|
|
let kvcProperties = Array(listsOfObjects.flatMap { $0.compactMap { $0.optNSStringCol }})
|
|
|
|
XCTAssertEqual(properties, kvcProperties)
|
|
}
|
|
|
|
do {
|
|
let objects = realm.objects(SwiftOptionalObject.self)
|
|
|
|
let properties = Array(objects.compactMap { $0.optIntCol.value })
|
|
let listsOfObjects = objects.value(forKeyPath: "optIntCol") as! [Int]
|
|
let kvcProperties = Array(listsOfObjects.compactMap { $0 })
|
|
|
|
XCTAssertEqual(properties, kvcProperties)
|
|
}
|
|
do {
|
|
let objects = realm.objects(SwiftOptionalObject.self)
|
|
|
|
let properties = Array(objects.compactMap { $0.optInt8Col.value })
|
|
#if swift(>=3.1)
|
|
let listsOfObjects = objects.value(forKeyPath: "optInt8Col") as! [Int8]
|
|
#else
|
|
let listsOfObjects = (objects.value(forKeyPath: "optInt8Col") as! [NSNumber]).map { $0.int8Value }
|
|
#endif
|
|
let kvcProperties = Array(listsOfObjects.compactMap { $0 })
|
|
|
|
XCTAssertEqual(properties, kvcProperties)
|
|
}
|
|
do {
|
|
let objects = realm.objects(SwiftOptionalObject.self)
|
|
|
|
let properties = Array(objects.compactMap { $0.optDoubleCol.value })
|
|
let listsOfObjects = objects.value(forKeyPath: "optDoubleCol") as! [Double]
|
|
let kvcProperties = Array(listsOfObjects.compactMap { $0 })
|
|
|
|
XCTAssertEqual(properties, kvcProperties)
|
|
}
|
|
#if swift(>=4)
|
|
// this test crashes xcode 9 beta 1's compiler
|
|
#else
|
|
do {
|
|
let objects = realm.objects(SwiftOptionalObject.self)
|
|
|
|
let properties = Array(objects.compactMap { $0.optStringCol })
|
|
let listsOfObjects = objects.value(forKeyPath: "optStringCol") as! [String]
|
|
let kvcProperties = Array(listsOfObjects.compactMap { $0 })
|
|
|
|
XCTAssertEqual(properties, kvcProperties)
|
|
}
|
|
#endif
|
|
do {
|
|
let objects = realm.objects(SwiftOptionalObject.self)
|
|
|
|
let properties = Array(objects.compactMap { $0.optNSStringCol })
|
|
let listsOfObjects = objects.value(forKeyPath: "optNSStringCol") as! [NSString]
|
|
let kvcProperties = Array(listsOfObjects.compactMap { $0 })
|
|
|
|
XCTAssertEqual(properties, kvcProperties)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
class ListStandaloneTests: ListTests {
|
|
override func createArray() -> SwiftArrayPropertyObject {
|
|
let array = SwiftArrayPropertyObject()
|
|
XCTAssertNil(array.realm)
|
|
return array
|
|
}
|
|
|
|
override func createArrayWithLinks() -> SwiftListOfSwiftObject {
|
|
let array = SwiftListOfSwiftObject()
|
|
XCTAssertNil(array.realm)
|
|
return array
|
|
}
|
|
}
|
|
|
|
class ListNewlyAddedTests: ListTests {
|
|
override func createArray() -> SwiftArrayPropertyObject {
|
|
let array = SwiftArrayPropertyObject()
|
|
array.name = "name"
|
|
let realm = realmWithTestPath()
|
|
try! realm.write { realm.add(array) }
|
|
|
|
XCTAssertNotNil(array.realm)
|
|
return array
|
|
}
|
|
|
|
override func createArrayWithLinks() -> SwiftListOfSwiftObject {
|
|
let array = SwiftListOfSwiftObject()
|
|
let realm = try! Realm()
|
|
try! realm.write { realm.add(array) }
|
|
|
|
XCTAssertNotNil(array.realm)
|
|
return array
|
|
}
|
|
}
|
|
|
|
class ListNewlyCreatedTests: ListTests {
|
|
override func createArray() -> SwiftArrayPropertyObject {
|
|
let realm = realmWithTestPath()
|
|
realm.beginWrite()
|
|
let array = realm.create(SwiftArrayPropertyObject.self, value: ["name", [], []])
|
|
try! realm.commitWrite()
|
|
|
|
XCTAssertNotNil(array.realm)
|
|
return array
|
|
}
|
|
|
|
override func createArrayWithLinks() -> SwiftListOfSwiftObject {
|
|
let realm = try! Realm()
|
|
realm.beginWrite()
|
|
let array = realm.create(SwiftListOfSwiftObject.self)
|
|
try! realm.commitWrite()
|
|
|
|
XCTAssertNotNil(array.realm)
|
|
return array
|
|
}
|
|
}
|
|
|
|
class ListRetrievedTests: ListTests {
|
|
override func createArray() -> SwiftArrayPropertyObject {
|
|
let realm = realmWithTestPath()
|
|
realm.beginWrite()
|
|
realm.create(SwiftArrayPropertyObject.self, value: ["name", [], []])
|
|
try! realm.commitWrite()
|
|
let array = realm.objects(SwiftArrayPropertyObject.self).first!
|
|
|
|
XCTAssertNotNil(array.realm)
|
|
return array
|
|
}
|
|
|
|
override func createArrayWithLinks() -> SwiftListOfSwiftObject {
|
|
let realm = try! Realm()
|
|
realm.beginWrite()
|
|
realm.create(SwiftListOfSwiftObject.self)
|
|
try! realm.commitWrite()
|
|
let array = realm.objects(SwiftListOfSwiftObject.self).first!
|
|
|
|
XCTAssertNotNil(array.realm)
|
|
return array
|
|
}
|
|
}
|
|
|
|
/// Ensure the range replaceable collection methods behave correctly when emulated for Swift 4 and later.
|
|
class ListRRCMethodsTests: XCTestCase {
|
|
private func compare(array: [Int], with list: List<SwiftIntObject>) {
|
|
guard array.count == list.count else {
|
|
XCTFail("Array and list have different sizes (\(array.count) and \(list.count), respectively).")
|
|
return
|
|
}
|
|
for i in 0..<array.count {
|
|
XCTAssertEqual(array[i], list[i].intCol,
|
|
"Mistmatched array value (\(array[i])) and list value (\(list[i].intCol)) at index \(i)")
|
|
}
|
|
}
|
|
|
|
private func makeArray(from list: List<SwiftIntObject>) -> [Int] {
|
|
return list.map { $0.intCol }
|
|
}
|
|
|
|
private func makeSwiftIntObjects(from array: [Int]) -> [SwiftIntObject] {
|
|
return array.map { SwiftIntObject(value: [$0]) }
|
|
}
|
|
|
|
private func createListObject(_ values: [Int] = [0, 1, 2, 3, 4, 5, 6]) -> SwiftArrayPropertyObject {
|
|
let object = SwiftArrayPropertyObject()
|
|
XCTAssertNil(object.realm)
|
|
object.intArray.append(objectsIn: makeSwiftIntObjects(from: values))
|
|
return object
|
|
}
|
|
|
|
private var array: [Int]!
|
|
private var list: List<SwiftIntObject>!
|
|
|
|
override func setUp() {
|
|
super.setUp()
|
|
list = createListObject().intArray
|
|
array = makeArray(from: list)
|
|
}
|
|
|
|
#if swift(>=4.0)
|
|
func testSubscript() {
|
|
list[1..<4] = createListObject([10, 11, 12]).intArray[0..<2]
|
|
array[1..<4] = [10, 11]
|
|
compare(array: array, with: list)
|
|
}
|
|
|
|
func testReplaceWithCollectionIndices() {
|
|
let newElements = [1, 2, 3]
|
|
list.replaceSubrange(list.indices, with: makeSwiftIntObjects(from: newElements))
|
|
array.replaceSubrange(array.indices, with: newElements)
|
|
compare(array: array, with: list)
|
|
}
|
|
|
|
func testRemoveWithCollectionIndices() {
|
|
list.removeSubrange(list.indices)
|
|
XCTAssertTrue(list.isEmpty)
|
|
}
|
|
#endif
|
|
|
|
func testRemoveFirst() {
|
|
list.removeFirst()
|
|
array.removeFirst()
|
|
compare(array: array, with: list)
|
|
}
|
|
|
|
func testRemoveFirstFew() {
|
|
list.removeFirst(3)
|
|
array.removeFirst(3)
|
|
compare(array: array, with: list)
|
|
}
|
|
|
|
func testRemoveLastFew() {
|
|
list.removeLast(3)
|
|
array.removeLast(3)
|
|
compare(array: array, with: list)
|
|
}
|
|
|
|
func testInsert() {
|
|
let newElements = [10, 11, 12, 13]
|
|
list.insert(contentsOf: makeSwiftIntObjects(from: newElements), at: 2)
|
|
array.insert(contentsOf: newElements, at: 2)
|
|
compare(array: array, with: list)
|
|
}
|
|
|
|
func testRemoveClosedSubrange() {
|
|
let subrange: ClosedRange<Int> = 1...3
|
|
list.removeSubrange(subrange)
|
|
array.removeSubrange(subrange)
|
|
compare(array: array, with: list)
|
|
}
|
|
|
|
func testRemoveOpenSubrange() {
|
|
let subrange: Range<Int> = 1..<3
|
|
list.removeSubrange(subrange)
|
|
array.removeSubrange(subrange)
|
|
compare(array: array, with: list)
|
|
}
|
|
|
|
func testReplaceClosedSubrange() {
|
|
let subrange: ClosedRange<Int> = 2...5
|
|
let newElements = [10, 11, 12, 13, 14, 15, 16]
|
|
list.replaceSubrange(subrange, with: makeSwiftIntObjects(from: newElements))
|
|
array.replaceSubrange(subrange, with: newElements)
|
|
compare(array: array, with: list)
|
|
}
|
|
|
|
func testReplaceOpenSubrange() {
|
|
let subrange: Range<Int> = 2..<5
|
|
let newElements = [10, 11, 12, 13, 14, 15, 16]
|
|
list.replaceSubrange(subrange, with: makeSwiftIntObjects(from: newElements))
|
|
array.replaceSubrange(subrange, with: newElements)
|
|
compare(array: array, with: list)
|
|
}
|
|
}
|
|
|