mirror of
https://github.com/Swiftgram/Telegram-iOS.git
synced 2025-08-19 12:10:55 +00:00
1215 lines
49 KiB
Swift
1215 lines
49 KiB
Swift
import Foundation
|
|
|
|
import UIKit
|
|
import XCTest
|
|
|
|
import Postbox
|
|
@testable import Postbox
|
|
|
|
import SwiftSignalKit
|
|
|
|
private let peerId = PeerId(namespace: 1, id: 1)
|
|
private let namespace: Int32 = 1
|
|
|
|
private extension MessageIndex {
|
|
init(id: Int32, timestamp: Int32) {
|
|
self.init(id: MessageId(peerId: peerId, namespace: namespace, id: id), timestamp: timestamp)
|
|
}
|
|
}
|
|
|
|
private extension MessageTags {
|
|
static let media = MessageTags(rawValue: 1 << 0)
|
|
}
|
|
|
|
class MessageHistoryIndexTableTests: XCTestCase {
|
|
var valueBox: ValueBox?
|
|
var path: String?
|
|
|
|
var postbox: Postbox?
|
|
|
|
override func setUp() {
|
|
super.setUp()
|
|
|
|
self.continueAfterFailure = false
|
|
|
|
var randomId: Int64 = 0
|
|
arc4random_buf(&randomId, 8)
|
|
path = NSTemporaryDirectory() + "\(randomId)"
|
|
|
|
var randomKey = Data(count: 32)
|
|
randomKey.withUnsafeMutableBytes({ (bytes: UnsafeMutablePointer<Int8>) -> Void in
|
|
arc4random_buf(bytes, 32)
|
|
})
|
|
var randomSalt = Data(count: 16)
|
|
randomSalt.withUnsafeMutableBytes({ (bytes: UnsafeMutablePointer<Int8>) -> Void in
|
|
arc4random_buf(bytes, 16)
|
|
})
|
|
|
|
self.valueBox = SqliteValueBox(basePath: path!, queue: Queue.mainQueue(), encryptionParameters: ValueBoxEncryptionParameters(key: ValueBoxEncryptionParameters.Key(data: randomKey)!, salt: ValueBoxEncryptionParameters.Salt(data: randomSalt)!))
|
|
|
|
let messageHoles: [PeerId.Namespace: [MessageId.Namespace: Set<MessageTags>]] = [
|
|
peerId.namespace: [
|
|
namespace: Set([.media])
|
|
]
|
|
]
|
|
|
|
let seedConfiguration = SeedConfiguration(globalMessageIdsPeerIdNamespaces: Set(), initializeChatListWithHole: (topLevel: nil, groups: nil), messageHoles: messageHoles, existingMessageTags: [.media], messageTagsWithSummary: [], existingGlobalMessageTags: [], peerNamespacesRequiringMessageTextIndex: [], peerSummaryCounterTags: { _ in PeerSummaryCounterTags(rawValue: 0) }, additionalChatListIndexNamespace: nil)
|
|
|
|
self.postbox = Postbox(queue: Queue.mainQueue(), basePath: path!, seedConfiguration: seedConfiguration, valueBox: self.valueBox!)
|
|
}
|
|
|
|
override func tearDown() {
|
|
super.tearDown()
|
|
|
|
self.postbox = nil
|
|
let _ = try? FileManager.default.removeItem(atPath: path!)
|
|
self.path = nil
|
|
}
|
|
|
|
func addHole(_ range: ClosedRange<Int32>, space: MessageHistoryHoleSpace) {
|
|
var operations: [MessageHistoryIndexHoleOperationKey: [MessageHistoryIndexHoleOperation]] = [:]
|
|
self.postbox!.messageHistoryHoleIndexTable.add(peerId: peerId, namespace: namespace, space: space, range: range, operations: &operations)
|
|
}
|
|
|
|
func removeHole(_ range: ClosedRange<Int32>, space: MessageHistoryHoleSpace) {
|
|
var operations: [MessageHistoryIndexHoleOperationKey: [MessageHistoryIndexHoleOperation]] = [:]
|
|
self.postbox!.messageHistoryHoleIndexTable.remove(peerId: peerId, namespace: namespace, space: space, range: range, operations: &operations)
|
|
}
|
|
|
|
func addMessage(_ id: Int32, _ timestamp: Int32, _ groupingKey: Int64? = nil) {
|
|
var operations: [MessageHistoryIndexOperation] = []
|
|
self.postbox!.messageHistoryIndexTable.addMessages([InternalStoreMessage(id: MessageId(peerId: peerId, namespace: namespace, id: id), timestamp: timestamp, globallyUniqueId: nil, groupingKey: groupingKey, flags: [], tags: [], globalTags: [], localTags: [], forwardInfo: nil, authorId: peerId, text: "", attributes: [], media: [])], operations: &operations)
|
|
}
|
|
|
|
func removeMessage(_ id: Int32) {
|
|
var operations: [MessageHistoryIndexOperation] = []
|
|
self.postbox!.messageHistoryIndexTable.removeMessage(MessageId(peerId: peerId, namespace: namespace, id: id), operations: &operations)
|
|
}
|
|
|
|
private func expectMessages(_ items: [MessageIndex]) {
|
|
let actualList = self.postbox!.messageHistoryIndexTable.debugList(peerId, namespace: namespace)
|
|
if items != actualList {
|
|
XCTFail("Expected\n\(items)\nGot\n\(actualList)")
|
|
}
|
|
}
|
|
|
|
private func expectHoles(space: MessageHistoryHoleSpace, _ ranges: [ClosedRange<Int32>], failure: () -> Void = {}) {
|
|
let actualList = self.postbox!.messageHistoryHoleIndexTable.debugList(peerId: peerId, namespace: namespace, space: space)
|
|
if ranges != actualList {
|
|
failure()
|
|
XCTFail("Expected\n\(ranges)\nGot\n\(actualList)")
|
|
}
|
|
}
|
|
|
|
func testEmpty() {
|
|
expectMessages([])
|
|
expectHoles(space: .everywhere, [])
|
|
expectHoles(space: .tag(.media), [])
|
|
}
|
|
|
|
func testSimpleMessages() {
|
|
addMessage(10, 10)
|
|
expectMessages([.init(id: 10, timestamp: 10)])
|
|
addMessage(11, 11)
|
|
expectMessages([.init(id: 10, timestamp: 10), .init(id: 11, timestamp: 11)])
|
|
expectHoles(space: .everywhere, [])
|
|
expectHoles(space: .tag(.media), [])
|
|
}
|
|
|
|
func testSimpleHoles() {
|
|
removeHole(1 ... Int32.max, space: .everywhere)
|
|
|
|
addHole(3 ... 10, space: .everywhere)
|
|
expectHoles(space: .everywhere, [3 ... 10])
|
|
|
|
addHole(3 ... 10, space: .everywhere)
|
|
expectHoles(space: .everywhere, [3 ... 10])
|
|
|
|
addHole(5 ... 20, space: .everywhere)
|
|
expectHoles(space: .everywhere, [3 ... 20])
|
|
|
|
addHole(25 ... 30, space: .everywhere)
|
|
expectHoles(space: .everywhere, [3 ... 20, 25 ... 30])
|
|
|
|
addHole(21 ... 23, space: .everywhere)
|
|
expectHoles(space: .everywhere, [3 ... 23, 25 ... 30])
|
|
|
|
addHole(5 ... 25, space: .everywhere)
|
|
expectHoles(space: .everywhere, [3 ... 30])
|
|
|
|
addHole(2 ... 35, space: .everywhere)
|
|
expectHoles(space: .everywhere, [2 ... 35])
|
|
|
|
removeHole(1 ... 5, space: .everywhere)
|
|
expectHoles(space: .everywhere, [6 ... 35])
|
|
|
|
removeHole(11 ... 11, space: .everywhere)
|
|
expectHoles(space: .everywhere, [6 ... 10, 12 ... 35])
|
|
|
|
removeHole(8 ... 15, space: .everywhere)
|
|
expectHoles(space: .everywhere, [6 ... 7, 16 ... 35])
|
|
|
|
removeHole(1 ... 16, space: .everywhere)
|
|
expectHoles(space: .everywhere, [17 ... 35])
|
|
}
|
|
|
|
func testHoleVectors() {
|
|
struct Operation: Codable {
|
|
struct Key: CodingKey {
|
|
var stringValue: String
|
|
|
|
init?(stringValue: String) {
|
|
self.stringValue = stringValue
|
|
}
|
|
|
|
let intValue: Int? = nil
|
|
init?(intValue: Int) {
|
|
return nil
|
|
}
|
|
}
|
|
|
|
let add: Bool
|
|
let range: ClosedRange<Int32>
|
|
|
|
init(add: Bool, range: ClosedRange<Int32>) {
|
|
self.add = add
|
|
self.range = range
|
|
}
|
|
|
|
init(from decoder: Decoder) throws {
|
|
let container = try decoder.container(keyedBy: Key.self)
|
|
self.add = try container.decode(Bool.self, forKey: Key(stringValue: "a")!)
|
|
self.range = (try container.decode(Int32.self, forKey: Key(stringValue: "l")!)) ... (try container.decode(Int32.self, forKey: Key(stringValue: "u")!))
|
|
}
|
|
|
|
func encode(to encoder: Encoder) throws {
|
|
var container = encoder.container(keyedBy: Key.self)
|
|
try container.encode(self.add, forKey: Key(stringValue: "a")!)
|
|
try container.encode(self.range.lowerBound, forKey: Key(stringValue: "l")!)
|
|
try container.encode(self.range.upperBound, forKey: Key(stringValue: "u")!)
|
|
}
|
|
}
|
|
|
|
let bundle = Bundle(for: type(of: self))
|
|
let path = bundle.path(forResource: "HoleOperationsVector1", ofType: "json")!
|
|
let jsonData = try! Data(contentsOf: URL(fileURLWithPath: path))
|
|
|
|
var operations: [Operation] = (try? JSONDecoder().decode(Array<Operation>.self, from: jsonData)) ?? []
|
|
|
|
if operations.isEmpty {
|
|
for _ in 0 ..< 10000 {
|
|
let bound1 = Int(max(1, arc4random_uniform(1000)))
|
|
let bound2 = Int(max(1, arc4random_uniform(1000)))
|
|
let range: ClosedRange<Int> = min(bound1, bound2) ... max(bound1, bound2)
|
|
let int32Range = Int32(range.lowerBound) ... Int32(range.upperBound)
|
|
let operation = arc4random_uniform(10)
|
|
if operation < 5 {
|
|
operations.append(Operation(add: true, range: int32Range))
|
|
} else {
|
|
operations.append(Operation(add: false, range: int32Range))
|
|
}
|
|
}
|
|
let data = try! JSONEncoder().encode(operations)
|
|
print(String(data: data, encoding: .utf8)!)
|
|
}
|
|
|
|
var verificationSet = IndexSet()
|
|
for (_, holesByMessageNamespace) in self.postbox!.seedConfiguration.messageHoles {
|
|
for (_, _) in holesByMessageNamespace{
|
|
verificationSet.insert(integersIn: 1 ... Int(Int32.max - 1))
|
|
}
|
|
}
|
|
for i in 0 ..< operations.count {
|
|
let operation = operations[i]
|
|
if operation.add {
|
|
verificationSet.insert(integersIn: Int(operation.range.lowerBound) ... Int(operation.range.upperBound))
|
|
addHole(operation.range, space: .everywhere)
|
|
} else {
|
|
verificationSet.remove(integersIn: Int(operation.range.lowerBound) ... Int(operation.range.upperBound))
|
|
removeHole(operation.range, space: .everywhere)
|
|
}
|
|
let testRanges = verificationSet.rangeView.map({ ClosedRange(Int32($0.lowerBound) ... Int32($0.upperBound - 1)) })
|
|
expectHoles(space: .everywhere, testRanges)
|
|
expectHoles(space: .tag(.media), testRanges)
|
|
}
|
|
}
|
|
|
|
func testHoleTagVectors() {
|
|
struct Operation: Codable {
|
|
struct Key: CodingKey {
|
|
var stringValue: String
|
|
|
|
init?(stringValue: String) {
|
|
self.stringValue = stringValue
|
|
}
|
|
|
|
let intValue: Int? = nil
|
|
init?(intValue: Int) {
|
|
return nil
|
|
}
|
|
}
|
|
|
|
let add: Bool
|
|
let range: ClosedRange<Int32>
|
|
let space: MessageHistoryHoleSpace
|
|
|
|
init(add: Bool, range: ClosedRange<Int32>, space: MessageHistoryHoleSpace) {
|
|
self.add = add
|
|
self.range = range
|
|
self.space = space
|
|
}
|
|
|
|
init(from decoder: Decoder) throws {
|
|
let container = try decoder.container(keyedBy: Key.self)
|
|
self.add = try container.decode(Bool.self, forKey: Key(stringValue: "a")!)
|
|
self.range = (try container.decode(Int32.self, forKey: Key(stringValue: "l")!)) ... (try container.decode(Int32.self, forKey: Key(stringValue: "u")!))
|
|
let spaceValue = try container.decode(Int32.self, forKey: Key(stringValue: "s")!)
|
|
if spaceValue == 0 {
|
|
self.space = .everywhere
|
|
} else {
|
|
self.space = .tag(MessageTags(rawValue: UInt32(spaceValue)))
|
|
}
|
|
}
|
|
|
|
func encode(to encoder: Encoder) throws {
|
|
var container = encoder.container(keyedBy: Key.self)
|
|
try container.encode(self.add, forKey: Key(stringValue: "a")!)
|
|
try container.encode(self.range.lowerBound, forKey: Key(stringValue: "l")!)
|
|
try container.encode(self.range.upperBound, forKey: Key(stringValue: "u")!)
|
|
switch self.space {
|
|
case .everywhere:
|
|
try container.encode(0, forKey: Key(stringValue: "s")!)
|
|
case let .tag(tag):
|
|
try container.encode(Int32(tag.rawValue), forKey: Key(stringValue: "s")!)
|
|
}
|
|
}
|
|
}
|
|
|
|
var operations: [Operation] = []
|
|
let bundle = Bundle(for: type(of: self))
|
|
if let path = bundle.path(forResource: "HoleOperationsVector2", ofType: "json"), let jsonData = try? Data(contentsOf: URL(fileURLWithPath: path)) {
|
|
if let value = try? JSONDecoder().decode(Array<Operation>.self, from: jsonData) {
|
|
operations = value
|
|
}
|
|
}
|
|
|
|
if operations.isEmpty {
|
|
for _ in 0 ..< 10000 {
|
|
let bound1 = Int(max(1, arc4random_uniform(1000)))
|
|
let bound2 = Int(max(1, arc4random_uniform(1000)))
|
|
let range: ClosedRange<Int> = min(bound1, bound2) ... max(bound1, bound2)
|
|
let int32Range = Int32(range.lowerBound) ... Int32(range.upperBound)
|
|
let operation = arc4random_uniform(10)
|
|
let spaceValue = arc4random_uniform(2)
|
|
let space: MessageHistoryHoleSpace
|
|
if spaceValue == 0 {
|
|
space = .everywhere
|
|
} else {
|
|
space = .tag(.media)
|
|
}
|
|
if operation < 5 {
|
|
operations.append(Operation(add: true, range: int32Range, space: space))
|
|
} else {
|
|
operations.append(Operation(add: false, range: int32Range, space: space))
|
|
}
|
|
}
|
|
let data = try! JSONEncoder().encode(operations)
|
|
print(String(data: data, encoding: .utf8)!)
|
|
}
|
|
|
|
var everywhereVerificationSet = IndexSet()
|
|
var mediaVerificationSet = IndexSet()
|
|
for (_, holesByMessageNamespace) in self.postbox!.seedConfiguration.messageHoles {
|
|
for (_, _) in holesByMessageNamespace{
|
|
everywhereVerificationSet.insert(integersIn: 1 ... Int(Int32.max - 1))
|
|
mediaVerificationSet.insert(integersIn: 1 ... Int(Int32.max - 1))
|
|
}
|
|
}
|
|
for i in 0 ..< operations.count {
|
|
let operation = operations[i]
|
|
let intRange = Int(operation.range.lowerBound) ... Int(operation.range.upperBound)
|
|
if operation.add {
|
|
switch operation.space {
|
|
case .everywhere:
|
|
everywhereVerificationSet.insert(integersIn: intRange)
|
|
mediaVerificationSet.insert(integersIn: intRange)
|
|
case .tag:
|
|
mediaVerificationSet.insert(integersIn: intRange)
|
|
}
|
|
addHole(operation.range, space: operation.space)
|
|
} else {
|
|
switch operation.space {
|
|
case .everywhere:
|
|
everywhereVerificationSet.remove(integersIn: intRange)
|
|
mediaVerificationSet.remove(integersIn: intRange)
|
|
case .tag:
|
|
mediaVerificationSet.remove(integersIn: intRange)
|
|
}
|
|
removeHole(operation.range, space: operation.space)
|
|
}
|
|
let everywhereTestRanges = everywhereVerificationSet.rangeView.map({ ClosedRange(Int32($0.lowerBound) ... Int32($0.upperBound - 1)) })
|
|
let mediaTestRanges = mediaVerificationSet.rangeView.map({ ClosedRange(Int32($0.lowerBound) ... Int32($0.upperBound - 1)) })
|
|
expectHoles(space: .everywhere, everywhereTestRanges)
|
|
expectHoles(space: .tag(.media), mediaTestRanges)
|
|
}
|
|
}
|
|
|
|
func testDirectAccessPerformance() {
|
|
self.beginTestDirectAccessPerformance(compactValuesOnCreation: false)
|
|
}
|
|
|
|
func testDirectAccessPerformanceCompact() {
|
|
self.beginTestDirectAccessPerformance(compactValuesOnCreation: true)
|
|
}
|
|
|
|
func testBlobExtractPerformance() {
|
|
let table = ValueBoxTable(id: 1000, keyType: .binary, compactValuesOnCreation: false)
|
|
|
|
let valueBox = self.postbox!.valueBox
|
|
let memory = malloc(4000)!
|
|
let value = MemoryBuffer(memory: memory, capacity: 4000, length: 4000, freeWhenDone: true)
|
|
var keys: [ValueBoxKey] = []
|
|
for _ in 0 ... 1000 {
|
|
let key = ValueBoxKey(length: 16)
|
|
arc4random_buf(key.memory, 16)
|
|
keys.append(key)
|
|
valueBox.set(table, key: key, value: value)
|
|
}
|
|
self.measureMetrics([XCTPerformanceMetric_WallClockTime], automaticallyStartMeasuring: false, for: {
|
|
self.startMeasuring()
|
|
for key in keys.shuffled() {
|
|
if let value = valueBox.get(table, key: key) {
|
|
var i = 0
|
|
let length = value.length
|
|
if i < length {
|
|
var output: Int32 = 0
|
|
value.read(&output, offset: i, length: 4)
|
|
i += 4
|
|
}
|
|
}
|
|
}
|
|
self.stopMeasuring()
|
|
})
|
|
}
|
|
|
|
func testIncrementalBlobExtractPerformance() {
|
|
let table = ValueBoxTable(id: 1000, keyType: .binary, compactValuesOnCreation: false)
|
|
|
|
let valueBox = self.postbox!.valueBox
|
|
let memory = malloc(4000)!
|
|
let value = MemoryBuffer(memory: memory, capacity: 4000, length: 4000, freeWhenDone: true)
|
|
var keys: [ValueBoxKey] = []
|
|
for _ in 0 ... 100000 {
|
|
let key = ValueBoxKey(length: 16)
|
|
arc4random_buf(key.memory, 16)
|
|
keys.append(key)
|
|
valueBox.set(table, key: key, value: value)
|
|
}
|
|
self.measureMetrics([XCTPerformanceMetric_WallClockTime], automaticallyStartMeasuring: false, for: {
|
|
self.startMeasuring()
|
|
for key in keys.shuffled() {
|
|
valueBox.read(table, key: key, { length, read in
|
|
var i = 0
|
|
if i < length {
|
|
var output: Int32 = 0
|
|
read(&output, i, 4)
|
|
i += 4
|
|
}
|
|
})
|
|
}
|
|
self.stopMeasuring()
|
|
})
|
|
}
|
|
|
|
func testBlobUpdatePerformance() {
|
|
let table = ValueBoxTable(id: 1000, keyType: .binary, compactValuesOnCreation: false)
|
|
|
|
let valueBox = self.postbox!.valueBox
|
|
let memory = malloc(250)!
|
|
let value = MemoryBuffer(memory: memory, capacity: 250, length: 250, freeWhenDone: true)
|
|
var keys: [ValueBoxKey] = []
|
|
for _ in 0 ... 100000 {
|
|
let key = ValueBoxKey(length: 16)
|
|
arc4random_buf(key.memory, 16)
|
|
keys.append(key)
|
|
valueBox.set(table, key: key, value: value)
|
|
}
|
|
self.measureMetrics([XCTPerformanceMetric_WallClockTime], automaticallyStartMeasuring: false, for: {
|
|
let buffer = WriteBuffer()
|
|
self.startMeasuring()
|
|
for key in keys.shuffled() {
|
|
if let value = valueBox.get(table, key: key) {
|
|
var output: Int32 = 0
|
|
value.read(&output, offset: 0, length: 4)
|
|
output += 1
|
|
buffer.reset()
|
|
buffer.write(&output, offset: 0, length: 4)
|
|
valueBox.set(table, key: key, value: buffer)
|
|
}
|
|
}
|
|
self.stopMeasuring()
|
|
})
|
|
}
|
|
|
|
func _testBlobIncrementalUpdatePerformance() {
|
|
let table = ValueBoxTable(id: 1000, keyType: .binary, compactValuesOnCreation: false)
|
|
|
|
let valueBox = self.postbox!.valueBox
|
|
let memory = malloc(250)!
|
|
let value = MemoryBuffer(memory: memory, capacity: 250, length: 250, freeWhenDone: true)
|
|
var keys: [ValueBoxKey] = []
|
|
for _ in 0 ... 100000 {
|
|
let key = ValueBoxKey(length: 16)
|
|
arc4random_buf(key.memory, 16)
|
|
keys.append(key)
|
|
valueBox.set(table, key: key, value: value)
|
|
}
|
|
self.measureMetrics([XCTPerformanceMetric_WallClockTime], automaticallyStartMeasuring: false, for: {
|
|
self.startMeasuring()
|
|
for key in keys.shuffled() {
|
|
valueBox.readWrite(table, key: key, { size, read, write in
|
|
var output: Int32 = 0
|
|
read(&output, 0, 4)
|
|
output += 1
|
|
write(&output, 0, 4)
|
|
})
|
|
}
|
|
self.stopMeasuring()
|
|
})
|
|
}
|
|
|
|
private func beginTestDirectAccessPerformance(compactValuesOnCreation: Bool) {
|
|
let table = ValueBoxTable(id: 1000, keyType: .binary, compactValuesOnCreation: compactValuesOnCreation)
|
|
|
|
let valueBox = self.postbox!.valueBox
|
|
let memory = malloc(250)!
|
|
let value = MemoryBuffer(memory: memory, capacity: 250, length: 250, freeWhenDone: true)
|
|
var keys: [ValueBoxKey] = []
|
|
for _ in 0 ... 100000 {
|
|
let key = ValueBoxKey(length: 16)
|
|
arc4random_buf(key.memory, 16)
|
|
keys.append(key)
|
|
valueBox.set(table, key: key, value: value)
|
|
}
|
|
|
|
self.measureMetrics([XCTPerformanceMetric_WallClockTime], automaticallyStartMeasuring: false, for: {
|
|
self.startMeasuring()
|
|
for key in keys.shuffled() {
|
|
let _ = valueBox.get(table, key: key)
|
|
}
|
|
self.stopMeasuring()
|
|
})
|
|
}
|
|
|
|
func _testDirectWritePerformance() {
|
|
self.beginTestDirectWritePerformance(compactValuesOnCreation: false)
|
|
}
|
|
|
|
func _testDirectWritePerformanceCompact() {
|
|
self.beginTestDirectWritePerformance(compactValuesOnCreation: true)
|
|
}
|
|
|
|
private func beginTestDirectWritePerformance(compactValuesOnCreation: Bool) {
|
|
self.measureMetrics([XCTPerformanceMetric_WallClockTime], automaticallyStartMeasuring: false, for: {
|
|
let table = ValueBoxTable(id: 1000, keyType: .binary, compactValuesOnCreation: compactValuesOnCreation)
|
|
let valueBox = self.postbox!.valueBox
|
|
|
|
self.startMeasuring()
|
|
|
|
let memory = malloc(4)!
|
|
let value = MemoryBuffer(memory: memory, capacity: 4, length: 4, freeWhenDone: true)
|
|
var keys: [ValueBoxKey] = []
|
|
for _ in 0 ... 40000 {
|
|
let key = ValueBoxKey(length: 16)
|
|
arc4random_buf(key.memory, 16)
|
|
keys.append(key)
|
|
valueBox.set(table, key: key, value: value)
|
|
}
|
|
for key in keys.shuffled() {
|
|
let _ = valueBox.get(table, key: key)
|
|
}
|
|
self.stopMeasuring()
|
|
|
|
valueBox.dropTable(table)
|
|
})
|
|
}
|
|
|
|
func _testRangeAccessPerformance() {
|
|
self.beginTestRangeAccessPerformance(compactValuesOnCreation: false)
|
|
}
|
|
|
|
func _testRangeAccessPerformanceCompact() {
|
|
self.beginTestRangeAccessPerformance(compactValuesOnCreation: true)
|
|
}
|
|
|
|
func _testBinarySearchAccessPerformance() {
|
|
let table = ValueBoxTable(id: 1000, keyType: .binary, compactValuesOnCreation: true)
|
|
|
|
let valueBox = self.postbox!.valueBox
|
|
let memory = malloc(250)!
|
|
let value = MemoryBuffer(memory: memory, capacity: 250, length: 250, freeWhenDone: true)
|
|
var keys: [ValueBoxKey] = []
|
|
|
|
var randomSpacedKeys: [Int32] = []
|
|
for _ in 0 ... 1000000 {
|
|
randomSpacedKeys.append(Int32(arc4random_uniform(100_000_000)))
|
|
}
|
|
randomSpacedKeys.sort()
|
|
|
|
for i in 0 ..< randomSpacedKeys.count {
|
|
let key = ValueBoxKey(length: 16)
|
|
key.setUInt32(0, value: 200)
|
|
key.setUInt32(4, value: 300)
|
|
key.setInt32(8, value: Int32(randomSpacedKeys[i]))
|
|
key.setInt32(12, value: Int32(i))
|
|
keys.append(key)
|
|
valueBox.set(table, key: key, value: value)
|
|
}
|
|
|
|
let lowerBound = ValueBoxKey(length: 8)
|
|
lowerBound.setUInt32(0, value: 200)
|
|
lowerBound.setUInt32(4, value: 300)
|
|
|
|
let upperBound = ValueBoxKey(length: 16)
|
|
upperBound.setUInt32(0, value: 200)
|
|
upperBound.setUInt32(4, value: 301)
|
|
upperBound.setUInt32(8, value: UInt32.max)
|
|
upperBound.setUInt32(12, value: UInt32.max)
|
|
|
|
self.measureMetrics([XCTPerformanceMetric_WallClockTime], automaticallyStartMeasuring: false, for: {
|
|
self.startMeasuring()
|
|
for i in 0 ... 1000 {
|
|
var startingLowerIndexValue: Int32?
|
|
valueBox.range(table, start: lowerBound, end: upperBound, keys: { key in
|
|
startingLowerIndexValue = key.getInt32(8)
|
|
return false
|
|
}, limit: 1)
|
|
|
|
var startingUpperIndexValue: Int32?
|
|
valueBox.range(table, start: upperBound, end: lowerBound, keys: { key in
|
|
startingUpperIndexValue = key.getInt32(8)
|
|
return false
|
|
}, limit: 1)
|
|
|
|
guard let startingLowerIndex = startingLowerIndexValue, let startingUpperIndex = startingUpperIndexValue else {
|
|
XCTAssert(false)
|
|
continue
|
|
}
|
|
|
|
var lowerIndex: Int32 = startingLowerIndex
|
|
var upperIndex: Int32 = startingUpperIndex
|
|
var rangeToLower = false
|
|
|
|
var readCount = 0
|
|
|
|
var found = false
|
|
while true {
|
|
readCount += 1
|
|
let currentIndex = Int32((Int64(lowerIndex) + Int64(upperIndex)) / 2)
|
|
let key = ValueBoxKey(length: 12)
|
|
key.setUInt32(0, value: 200)
|
|
key.setUInt32(4, value: 300)
|
|
key.setInt32(8, value: currentIndex)
|
|
|
|
var foundValue: (Int32, Int32)?
|
|
if !rangeToLower {
|
|
valueBox.range(table, start: key, end: upperBound, keys: { key in
|
|
foundValue = (key.getInt32(8), key.getInt32(12))
|
|
return false
|
|
}, limit: 1)
|
|
} else {
|
|
valueBox.range(table, start: key, end: lowerBound, keys: { key in
|
|
foundValue = (key.getInt32(8), key.getInt32(12))
|
|
return false
|
|
}, limit: 1)
|
|
}
|
|
|
|
if let (foundKey, foundValue) = foundValue {
|
|
if foundValue == Int32(i) {
|
|
found = true
|
|
break
|
|
} else if lowerIndex > upperIndex {
|
|
break
|
|
} else {
|
|
if foundValue > Int(i) {
|
|
upperIndex = foundKey - 1
|
|
rangeToLower = true
|
|
} else {
|
|
lowerIndex = foundKey + 1
|
|
rangeToLower = false
|
|
}
|
|
}
|
|
} else {
|
|
break
|
|
}
|
|
}
|
|
if !found {
|
|
XCTAssert(false)
|
|
}
|
|
}
|
|
self.stopMeasuring()
|
|
})
|
|
}
|
|
|
|
func beginTestRangeAccessPerformance(compactValuesOnCreation: Bool) {
|
|
let table = ValueBoxTable(id: 1000, keyType: .binary, compactValuesOnCreation: compactValuesOnCreation)
|
|
|
|
let valueBox = self.postbox!.valueBox
|
|
let memory = malloc(250)!
|
|
let value = MemoryBuffer(memory: memory, capacity: 250, length: 250, freeWhenDone: true)
|
|
var keys: [ValueBoxKey] = []
|
|
for _ in 0 ... 100000 {
|
|
let key = ValueBoxKey(length: 16)
|
|
arc4random_buf(key.memory, 16)
|
|
keys.append(key)
|
|
valueBox.set(table, key: key, value: value)
|
|
}
|
|
let upperBound = ValueBoxKey(length: 16)
|
|
upperBound.setUInt32(0, value: UInt32.max)
|
|
upperBound.setUInt32(4, value: UInt32.max)
|
|
upperBound.setUInt32(8, value: UInt32.max)
|
|
upperBound.setUInt32(12, value: UInt32.max)
|
|
|
|
self.measureMetrics([XCTPerformanceMetric_WallClockTime], automaticallyStartMeasuring: false, for: {
|
|
self.startMeasuring()
|
|
for key in keys.shuffled() {
|
|
valueBox.range(table, start: key.prefix(12), end: upperBound, keys: { _ in
|
|
return false
|
|
}, limit: 1)
|
|
let _ = valueBox.get(table, key: key)
|
|
}
|
|
self.stopMeasuring()
|
|
})
|
|
}
|
|
|
|
/*func addMessagesUpperBlock(_ messages: [(Int32, Int32)]) {
|
|
var operations: [MessageHistoryIndexOperation] = []
|
|
self.indexTable!.addMessages(messages.map { (id, timestamp) in
|
|
return InternalStoreMessage(id: MessageId(peerId: peerId, namespace: namespace, id: id), timestamp: timestamp, globallyUniqueId: nil, groupingKey: nil, flags: [], tags: [], globalTags: [], localTags: [], forwardInfo: nil, authorId: peerId, text: "", attributes: [], media: [])
|
|
}, location: .UpperHistoryBlock, operations: &operations)
|
|
}
|
|
|
|
func fillHole(_ id: Int32, _ fillType: HoleFill, _ messages: [(Int32, Int32, Int64?)], _ tagMask: MessageTags? = nil) {
|
|
var operations: [MessageHistoryIndexOperation] = []
|
|
|
|
self.indexTable!.fillHole(MessageId(peerId: peerId, namespace: namespace, id: id), fillType: fillType, tagMask: tagMask, messages: messages.map({
|
|
return InternalStoreMessage(id: MessageId(peerId: peerId, namespace: namespace, id: $0.0), timestamp: $0.1, globallyUniqueId: nil, groupingKey: $0.2, flags: [], tags: [], globalTags: [], localTags: [], forwardInfo: nil, authorId: peerId, text: "", attributes: [], media: [])
|
|
}), operations: &operations)
|
|
}
|
|
|
|
func fillMultipleHoles(_ mainId: Int32, _ fillType: HoleFill, _ messages: [(Int32, Int32)], _ tagMask: MessageTags? = nil) {
|
|
var operations: [MessageHistoryIndexOperation] = []
|
|
self.indexTable!.fillMultipleHoles(mainHoleId: MessageId(peerId: peerId, namespace: namespace, id: mainId), fillType: fillType, tagMask: tagMask, messages: messages.map({
|
|
return InternalStoreMessage(id: MessageId(peerId: peerId, namespace: namespace, id: $0.0), timestamp: $0.1, globallyUniqueId: nil, groupingKey: nil, flags: [], tags: [], globalTags: [], localTags: [], forwardInfo: nil, authorId: peerId, text: "", attributes: [], media: [])
|
|
}), operations: &operations)
|
|
}
|
|
|
|
private func expect(_ items: [Item]) {
|
|
let actualList = self.indexTable!.debugList(peerId, namespace: namespace)
|
|
let actualItems = actualList.map { return Item($0) }
|
|
if items != actualItems {
|
|
XCTFail("Expected\n\(items)\nGot\n\(actualItems)")
|
|
}
|
|
}
|
|
|
|
func testEmpty() {
|
|
expect([])
|
|
}
|
|
|
|
func testAddMessageToEmpty() {
|
|
addMessage(100, 100)
|
|
expect([.Message(100, 100)])
|
|
|
|
addMessage(110, 110)
|
|
expect([.Message(100, 100), .Message(110, 110)])
|
|
|
|
addMessage(90, 90)
|
|
expect([.Message(90, 90), .Message(100, 100), .Message(110, 110)])
|
|
}
|
|
|
|
func testAddMessageIgnoreOverwrite() {
|
|
addMessage(100, 100)
|
|
expect([.Message(100, 100)])
|
|
|
|
addMessage(100, 110)
|
|
expect([.Message(100, 100)])
|
|
}
|
|
|
|
func testAddHoleToEmpty() {
|
|
addHole(100)
|
|
expect([.Hole(1, Int32.max, Int32.max)])
|
|
}
|
|
|
|
func testAddHoleToFullHole() {
|
|
addHole(100)
|
|
expect([.Hole(1, Int32.max, Int32.max)])
|
|
addHole(110)
|
|
expect([.Hole(1, Int32.max, Int32.max)])
|
|
}
|
|
|
|
func testAddMessageToFullHole() {
|
|
addHole(100)
|
|
expect([.Hole(1, Int32.max, Int32.max)])
|
|
addMessage(90, 90)
|
|
expect([.Hole(1, 89, 90), .Message(90, 90), .Hole(91, Int32.max, Int32.max)])
|
|
}
|
|
|
|
func testAddMessageDividingUpperHole() {
|
|
addHole(100)
|
|
expect([.Hole(1, Int32.max, Int32.max)])
|
|
addMessage(90, 90)
|
|
expect([.Hole(1, 89, 90), .Message(90, 90), .Hole(91, Int32.max, Int32.max)])
|
|
addMessage(100, 100)
|
|
expect([.Hole(1, 89, 90), .Message(90, 90), .Hole(91, 99, 100), .Message(100, 100), .Hole(101, Int32.max, Int32.max)])
|
|
}
|
|
|
|
func testAddMessageDividingLowerHole() {
|
|
addHole(100)
|
|
expect([.Hole(1, Int32.max, Int32.max)])
|
|
addMessage(90, 90)
|
|
expect([.Hole(1, 89, 90), .Message(90, 90), .Hole(91, Int32.max, Int32.max)])
|
|
addMessage(80, 80)
|
|
expect([.Hole(1, 79, 80), .Message(80, 80), .Hole(81, 89, 90), .Message(90, 90), .Hole(91, Int32.max, Int32.max)])
|
|
}
|
|
|
|
func testAddMessageOffsettingUpperHole() {
|
|
addHole(100)
|
|
expect([.Hole(1, Int32.max, Int32.max)])
|
|
|
|
addMessage(90, 90)
|
|
expect([.Hole(1, 89, 90), .Message(90, 90), .Hole(91, Int32.max, Int32.max)])
|
|
addMessage(91, 91)
|
|
expect([.Hole(1, 89, 90), .Message(90, 90), .Message(91, 91), .Hole(92, Int32.max, Int32.max)])
|
|
}
|
|
|
|
func testAddMessageOffsettingLowerHole() {
|
|
addHole(100)
|
|
expect([.Hole(1, Int32.max, Int32.max)])
|
|
|
|
addMessage(90, 90)
|
|
expect([.Hole(1, 89, 90), .Message(90, 90), .Hole(91, Int32.max, Int32.max)])
|
|
addMessage(89, 89)
|
|
expect([.Hole(1, 88, 89), .Message(89, 89), .Message(90, 90), .Hole(91, Int32.max, Int32.max)])
|
|
}
|
|
|
|
func testAddMessageOffsettingLeftmostHole() {
|
|
addHole(100)
|
|
expect([.Hole(1, Int32.max, Int32.max)])
|
|
|
|
addMessage(1, 1)
|
|
|
|
expect([.Message(1, 1), .Hole(2, Int32.max, Int32.max)])
|
|
}
|
|
|
|
func testAddMessageRemovingLefmostHole() {
|
|
addHole(100)
|
|
expect([.Hole(1, Int32.max, Int32.max)])
|
|
|
|
addMessage(2, 2)
|
|
expect([.Hole(1, 1, 2), .Message(2, 2), .Hole(3, Int32.max, Int32.max)])
|
|
|
|
addMessage(1, 1)
|
|
expect([.Message(1, 1), .Message(2, 2), .Hole(3, Int32.max, Int32.max)])
|
|
}
|
|
|
|
func testAddHoleLowerThanMessage() {
|
|
addMessage(100, 100)
|
|
addHole(1)
|
|
|
|
expect([.Hole(1, 99, 100), .Message(100, 100)])
|
|
}
|
|
|
|
func testAddHoleHigherThanMessage() {
|
|
addMessage(100, 100)
|
|
addHole(200)
|
|
|
|
expect([.Message(100, 100), .Hole(101, Int32.max, Int32.max)])
|
|
}
|
|
|
|
func testIgnoreHigherHole() {
|
|
addHole(200)
|
|
expect([.Hole(1, Int32.max, Int32.max)])
|
|
addHole(400)
|
|
expect([.Hole(1, Int32.max, Int32.max)])
|
|
}
|
|
|
|
func testIgnoreHigherHoleAfterMessage() {
|
|
addMessage(100, 100)
|
|
addHole(200)
|
|
expect([.Message(100, 100), .Hole(101, Int32.max, Int32.max)])
|
|
addHole(400)
|
|
expect([.Message(100, 100), .Hole(101, Int32.max, Int32.max)])
|
|
}
|
|
|
|
func testAddHoleBetweenMessages() {
|
|
addMessage(100, 100)
|
|
addMessage(200, 200)
|
|
addHole(150)
|
|
|
|
expect([.Message(100, 100), .Hole(101, 199, 200), .Message(200, 200)])
|
|
}
|
|
|
|
func testFillHoleEmpty() {
|
|
fillHole(1, HoleFill(complete: true, direction: .UpperToLower(updatedMinIndex: nil, clippingMaxIndex: nil)), [])
|
|
expect([])
|
|
}
|
|
|
|
func testFillHoleComplete() {
|
|
addHole(100)
|
|
|
|
fillHole(1, HoleFill(complete: true, direction: .UpperToLower(updatedMinIndex: nil, clippingMaxIndex: nil)), [(100, 100, nil), (200, 200, nil)])
|
|
expect([.Message(100, 100), .Message(200, 200)])
|
|
}
|
|
|
|
func testFillHoleUpperToLowerPartial() {
|
|
addHole(100)
|
|
|
|
fillHole(1, HoleFill(complete: false, direction: .UpperToLower(updatedMinIndex: nil, clippingMaxIndex: nil)), [(100, 100, nil), (200, 200, nil)])
|
|
expect([.Hole(1, 99, 100), .Message(100, 100), .Message(200, 200)])
|
|
}
|
|
|
|
func testFillHoleUpperToLowerToBounds() {
|
|
addHole(100)
|
|
|
|
fillHole(1, HoleFill(complete: false, direction: .UpperToLower(updatedMinIndex: nil, clippingMaxIndex: nil)), [(1, 1, nil), (200, 200, nil)])
|
|
expect([.Message(1, 1), .Message(200, 200)])
|
|
}
|
|
|
|
func testFillHoleLowerToUpperToBounds() {
|
|
addHole(100)
|
|
|
|
fillHole(1, HoleFill(complete: false, direction: .LowerToUpper(updatedMaxIndex: nil, clippingMinIndex: nil)), [(100, 100, nil), (Int32.max, 200, nil)])
|
|
expect([.Message(100, 100), .Message(Int32.max, 200)])
|
|
}
|
|
|
|
func testFillHoleLowerToUpperPartial() {
|
|
addHole(100)
|
|
|
|
fillHole(1, HoleFill(complete: false, direction: .LowerToUpper(updatedMaxIndex: nil, clippingMinIndex: nil)), [(100, 100, nil), (200, 200, nil)])
|
|
expect([.Message(100, 100), .Message(200, 200), .Hole(201, Int32.max, Int32.max)])
|
|
}
|
|
|
|
func testFillHoleBetweenMessagesUpperToLower() {
|
|
addHole(1)
|
|
|
|
addMessage(100, 100)
|
|
addMessage(200, 200)
|
|
|
|
fillHole(199, HoleFill(complete: false, direction: .UpperToLower(updatedMinIndex: nil, clippingMaxIndex: nil)), [(150, 150, nil)])
|
|
|
|
expect([.Hole(1, 99, 100), .Message(100, 100), .Hole(101, 149, 150), .Message(150, 150), .Message(200, 200), .Hole(201, Int32.max, Int32.max)])
|
|
}
|
|
|
|
func testFillHoleBetweenMessagesLowerToUpper() {
|
|
addHole(1)
|
|
|
|
addMessage(100, 100)
|
|
addMessage(200, 200)
|
|
|
|
fillHole(199, HoleFill(complete: false, direction: .LowerToUpper(updatedMaxIndex: nil, clippingMinIndex: nil)), [(150, 150, nil)])
|
|
|
|
expect([.Hole(1, 99, 100), .Message(100, 100), .Message(150, 150), .Hole(151, 199, 200), .Message(200, 200), .Hole(201, Int32.max, Int32.max)])
|
|
}
|
|
|
|
func testFillHoleBetweenMessagesComplete() {
|
|
addHole(1)
|
|
|
|
addMessage(100, 100)
|
|
addMessage(200, 200)
|
|
|
|
fillHole(199, HoleFill(complete: true, direction: .UpperToLower(updatedMinIndex: nil, clippingMaxIndex: nil)), [(150, 150, nil)])
|
|
|
|
expect([.Hole(1, 99, 100), .Message(100, 100), .Message(150, 150), .Message(200, 200), .Hole(201, Int32.max, Int32.max)])
|
|
}
|
|
|
|
func testFillHoleBetweenMessagesWithMessage() {
|
|
addMessage(200, 200)
|
|
addMessage(202, 202)
|
|
addHole(201)
|
|
addMessage(201, 201)
|
|
|
|
expect([.Message(200, 200), .Message(201, 201), .Message(202, 202)])
|
|
}
|
|
|
|
func testFillHoleWithNoMessagesComplete() {
|
|
addMessage(100, 100)
|
|
addHole(1)
|
|
|
|
fillHole(99, HoleFill(complete: true, direction: .UpperToLower(updatedMinIndex: nil, clippingMaxIndex: nil)), [])
|
|
|
|
expect([.Message(100, 100)])
|
|
}
|
|
|
|
func testFillHoleIgnoreOverMessage() {
|
|
addMessage(100, 100)
|
|
addMessage(101, 101)
|
|
|
|
fillHole(100, HoleFill(complete: true, direction: .UpperToLower(updatedMinIndex: nil, clippingMaxIndex: nil)), [(90, 90, nil)])
|
|
|
|
expect([.Message(90, 90), .Message(100, 100), .Message(101, 101)])
|
|
}
|
|
|
|
func testFillHoleWithOverflow() {
|
|
addMessage(100, 100)
|
|
addMessage(200, 200)
|
|
addHole(150)
|
|
|
|
fillHole(199, HoleFill(complete: false, direction: .UpperToLower(updatedMinIndex: nil, clippingMaxIndex: nil)), [(150, 150, nil), (300, 300, nil)])
|
|
|
|
expect([.Message(100, 100), .Hole(101, 149, 150), .Message(150, 150), .Message(200, 200), .Message(300, 300)])
|
|
}
|
|
|
|
func testIgnoreHoleOverMessageBetweenMessages() {
|
|
addMessage(199, 199)
|
|
addMessage(200, 200)
|
|
addHole(200)
|
|
|
|
expect([.Message(199, 199), .Message(200, 200)])
|
|
}
|
|
|
|
func testMergeHoleAfterDeletingMessage() {
|
|
addMessage(100, 100)
|
|
addHole(1)
|
|
addHole(200)
|
|
|
|
expect([.Hole(1, 99, 100), .Message(100, 100), .Hole(101, Int32.max, Int32.max)])
|
|
|
|
removeMessage(100)
|
|
|
|
expect([.Hole(1, Int32.max, Int32.max)])
|
|
}
|
|
|
|
func testMergeHoleLowerAfterDeletingMessage() {
|
|
addMessage(100, 100)
|
|
addHole(1)
|
|
addMessage(200, 200)
|
|
|
|
removeMessage(100)
|
|
|
|
expect([.Hole(1, 199, 200), .Message(200, 200)])
|
|
}
|
|
|
|
func testMergeHoleUpperAfterDeletingMessage() {
|
|
addMessage(100, 100)
|
|
addMessage(200, 200)
|
|
addHole(300)
|
|
|
|
removeMessage(200)
|
|
|
|
expect([.Message(100, 100), .Hole(101, Int32.max, Int32.max)])
|
|
}
|
|
|
|
func testExtendLowerHoleAfterDeletingMessage() {
|
|
addMessage(100, 100)
|
|
addHole(100)
|
|
|
|
removeMessage(100)
|
|
|
|
expect([.Hole(1, Int32.max, Int32.max)])
|
|
}
|
|
|
|
func testExtendUpperHoleAfterDeletingMessage() {
|
|
addMessage(100, 100)
|
|
addHole(101)
|
|
|
|
removeMessage(100)
|
|
|
|
expect([.Hole(1, Int32.max, Int32.max)])
|
|
}
|
|
|
|
func testDeleteMessageBelowMessage() {
|
|
addMessage(100, 100)
|
|
addMessage(200, 200)
|
|
removeMessage(100)
|
|
|
|
expect([.Message(200, 200)])
|
|
}
|
|
|
|
func testDeleteMessageAboveMessage() {
|
|
addMessage(100, 100)
|
|
addMessage(200, 200)
|
|
removeMessage(200)
|
|
|
|
expect([.Message(100, 100)])
|
|
}
|
|
|
|
func testDeleteMessageBetweenMessages() {
|
|
addMessage(100, 100)
|
|
addMessage(200, 200)
|
|
addMessage(300, 300)
|
|
removeMessage(200)
|
|
|
|
expect([.Message(100, 100), .Message(300, 300)])
|
|
}
|
|
|
|
func testAddMessageCutInitialHole() {
|
|
addHole(1)
|
|
expect([.Hole(1, Int32.max, Int32.max)])
|
|
addMessagesUpperBlock([(100, 100)])
|
|
expect([.Hole(1, 99, 100), .Message(100, 100)])
|
|
}
|
|
|
|
func testAddMessageRemoveInitialHole() {
|
|
addHole(1)
|
|
expect([.Hole(1, Int32.max, Int32.max)])
|
|
addMessagesUpperBlock([(1, 100)])
|
|
expect([.Message(1, 100)])
|
|
}
|
|
|
|
func testAddMessageCutHoleAfterMessage1() {
|
|
addMessage(10, 10)
|
|
addHole(11)
|
|
expect([.Message(10, 10), .Hole(11, Int32.max, Int32.max)])
|
|
addMessagesUpperBlock([(100, 100)])
|
|
expect([.Message(10, 10), .Hole(11, 99, 100), .Message(100, 100)])
|
|
}
|
|
|
|
func testAddMessageCutHoleAfterMessage2() {
|
|
addMessage(10, 10)
|
|
addHole(11)
|
|
expect([.Message(10, 10), .Hole(11, Int32.max, Int32.max)])
|
|
addMessagesUpperBlock([(12, 12)])
|
|
expect([.Message(10, 10), .Hole(11, 11, 12), .Message(12, 12)])
|
|
}
|
|
|
|
func testAddMessageRemoveHoleAfterMessage() {
|
|
addMessage(10, 10)
|
|
addHole(11)
|
|
expect([.Message(10, 10), .Hole(11, Int32.max, Int32.max)])
|
|
addMessagesUpperBlock([(11, 11)])
|
|
expect([.Message(10, 10), .Message(11, 11)])
|
|
}
|
|
|
|
func testAddMessageRemoveHoleIgnoreOverwriteMessage() {
|
|
addMessage(10, 10)
|
|
addHole(11)
|
|
expect([.Message(10, 10), .Hole(11, Int32.max, Int32.max)])
|
|
addMessagesUpperBlock([(10, 11)])
|
|
expect([.Message(10, 10)])
|
|
}
|
|
|
|
func testFillHoleAtIndex() {
|
|
addHole(1)
|
|
expect([.Hole(1, Int32.max, Int32.max)])
|
|
fillHole(1, HoleFill(complete: false, direction: .AroundId(MessageId(peerId: peerId, namespace: namespace, id: 10), lowerComplete: false, upperComplete: false)), [(5, 5, nil), (10, 10, nil)])
|
|
expect([.Hole(1, 4, 5), .Message(5, 5), .Message(10, 10), .Hole(11, Int32.max, Int32.max)])
|
|
}
|
|
|
|
func testFillHoleAtIndexComplete() {
|
|
addHole(1)
|
|
expect([.Hole(1, Int32.max, Int32.max)])
|
|
fillHole(1, HoleFill(complete: true, direction: .AroundId(MessageId(peerId: peerId, namespace: namespace, id: 10), lowerComplete: false, upperComplete: false)), [(5, 5, nil), (10, 10, nil)])
|
|
expect([.Message(5, 5), .Message(10, 10)])
|
|
}
|
|
|
|
func testFillMultipleHolesSingleHole() {
|
|
addHole(1)
|
|
expect([.Hole(1, Int32.max, Int32.max)])
|
|
|
|
fillMultipleHoles(1, HoleFill(complete: false, direction: .UpperToLower(updatedMinIndex: nil, clippingMaxIndex: nil)), [(5, 5), (10, 10)])
|
|
expect([.Hole(1, 4, 5), .Message(5, 5), .Message(10, 10)])
|
|
}
|
|
|
|
func testFillMultipleHolesTwoHolesUpperToLowerNotComplete() {
|
|
addHole(1)
|
|
addMessage(10, 10)
|
|
expect([.Hole(1, 9, 10), .Message(10, 10), .Hole(11, Int32.max, Int32.max)])
|
|
|
|
fillMultipleHoles(12, HoleFill(complete: false, direction: .UpperToLower(updatedMinIndex: nil, clippingMaxIndex: nil)), [(8, 8), (15, 15), (20, 20)])
|
|
|
|
expect([.Hole(1, 7, 8), .Message(8, 8), .Message(10, 10), .Message(15, 15), .Message(20, 20)])
|
|
}
|
|
|
|
func testFillMultipleHolesTwoHolesUpperToLowerNotCompleteSkipOverOne() {
|
|
addHole(1)
|
|
addMessage(10, 10)
|
|
addMessage(13, 13)
|
|
expect([.Hole(1, 9, 10), .Message(10, 10), .Hole(11, 12, 13), .Message(13, 13), .Hole(14, Int32.max, Int32.max)])
|
|
|
|
fillMultipleHoles(20, HoleFill(complete: false, direction: .UpperToLower(updatedMinIndex: nil, clippingMaxIndex: nil)), [(8, 8), (15, 15), (20, 20)])
|
|
|
|
expect([.Hole(1, 7, 8), .Message(8, 8), .Message(10, 10), .Message(13, 13), .Message(15, 15), .Message(20, 20)])
|
|
}
|
|
|
|
func testFillMultipleHolesTwoHolesUpperToLowerComplete() {
|
|
addHole(1)
|
|
addMessage(10, 10)
|
|
expect([.Hole(1, 9, 10), .Message(10, 10), .Hole(11, Int32.max, Int32.max)])
|
|
|
|
fillMultipleHoles(12, HoleFill(complete: true, direction: .UpperToLower(updatedMinIndex: nil, clippingMaxIndex: nil)), [(8, 8), (15, 15), (20, 20)])
|
|
|
|
expect([.Message(8, 8), .Message(10, 10), .Message(15, 15), .Message(20, 20)])
|
|
}
|
|
|
|
func testFillMultipleHolesTwoHolesLowerToUpperNotComplete() {
|
|
addHole(1)
|
|
addMessage(10, 10)
|
|
expect([.Hole(1, 9, 10), .Message(10, 10), .Hole(11, Int32.max, Int32.max)])
|
|
|
|
fillMultipleHoles(12, HoleFill(complete: false, direction: .LowerToUpper(updatedMaxIndex: nil, clippingMinIndex: nil)), [(8, 8), (15, 15), (20, 20)])
|
|
|
|
expect([.Hole(1, 7, 8), .Message(8, 8), .Message(10, 10), .Message(15, 15), .Message(20, 20), .Hole(21, Int32.max, Int32.max)])
|
|
}
|
|
|
|
func testFillMultipleHolesTwoHolesLowerToUpperComplete() {
|
|
addHole(1)
|
|
addMessage(10, 10)
|
|
expect([.Hole(1, 9, 10), .Message(10, 10), .Hole(11, Int32.max, Int32.max)])
|
|
|
|
fillMultipleHoles(12, HoleFill(complete: true, direction: .LowerToUpper(updatedMaxIndex: nil, clippingMinIndex: nil)), [(8, 8), (15, 15), (20, 20)])
|
|
|
|
expect([.Hole(1, 7, 8), .Message(8, 8), .Message(10, 10), .Message(15, 15), .Message(20, 20)])
|
|
}
|
|
|
|
func testFillMultipleHolesTwoHolesAroundIndexNotComplete() {
|
|
addHole(1)
|
|
addMessage(10, 10)
|
|
expect([.Hole(1, 9, 10), .Message(10, 10), .Hole(11, Int32.max, Int32.max)])
|
|
|
|
fillMultipleHoles(12, HoleFill(complete: false, direction: .AroundId(MessageId(peerId: peerId, namespace: namespace, id: 15), lowerComplete: false, upperComplete: false)), [(8, 8), (15, 15), (20, 20)])
|
|
|
|
expect([.Hole(1, 7, 8), .Message(8, 8), .Message(10, 10), .Message(15, 15), .Message(20, 20), .Hole(21, Int32.max, Int32.max)])
|
|
}
|
|
|
|
func testFillMultipleHolesTwoHolesAroundIndexUpperComplete() {
|
|
addHole(1)
|
|
addMessage(10, 10)
|
|
expect([.Hole(1, 9, 10), .Message(10, 10), .Hole(11, Int32.max, Int32.max)])
|
|
|
|
fillMultipleHoles(12, HoleFill(complete: false, direction: .AroundId(MessageId(peerId: peerId, namespace: namespace, id: 15), lowerComplete: false, upperComplete: true)), [(8, 8), (15, 15), (20, 20)])
|
|
|
|
expect([.Hole(1, 7, 8), .Message(8, 8), .Message(10, 10), .Message(15, 15), .Message(20, 20)])
|
|
}
|
|
|
|
func testFillMultipleHolesTwoHolesAroundIndexLowerComplete() {
|
|
addHole(1)
|
|
addMessage(10, 10)
|
|
expect([.Hole(1, 9, 10), .Message(10, 10), .Hole(11, Int32.max, Int32.max)])
|
|
|
|
fillMultipleHoles(12, HoleFill(complete: false, direction: .AroundId(MessageId(peerId: peerId, namespace: namespace, id: 15), lowerComplete: true, upperComplete: false)), [(8, 8), (15, 15), (20, 20)])
|
|
|
|
expect([.Hole(1, 7, 8), .Message(8, 8), .Message(10, 10), .Message(15, 15), .Message(20, 20), .Hole(21, Int32.max, Int32.max)])
|
|
}
|
|
|
|
func testFillMultipleHolesTwoHolesAroundIndexAutoComplete() {
|
|
addHole(1)
|
|
addMessage(10, 10)
|
|
expect([.Hole(1, 9, 10), .Message(10, 10), .Hole(11, Int32.max, Int32.max)])
|
|
|
|
fillMultipleHoles(12, HoleFill(complete: false, direction: .AroundId(MessageId(peerId: peerId, namespace: namespace, id: 15), lowerComplete: false, upperComplete: false)), [(8, 8), (15, 15), (20, 20)])
|
|
|
|
expect([.Hole(1, 7, 8), .Message(8, 8), .Message(10, 10), .Message(15, 15), .Message(20, 20), .Hole(21, Int32.max, Int32.max)])
|
|
}
|
|
|
|
func testHole1() {
|
|
addMessage(1000, 1000)
|
|
addMessage(1001, 1001)
|
|
addHole(Int32.max)
|
|
expect([.Message(1000, 1000), .Message(1001, 1001), .Hole(1002, Int32.max, Int32.max)])
|
|
addMessagesUpperBlock([(1005, 1005)])
|
|
expect([.Message(1000, 1000), .Message(1001, 1001), .Hole(1002, 1004, 1005), .Message(1005, 1005)])
|
|
addMessage(1003, 1003)
|
|
expect([.Message(1000, 1000), .Message(1001, 1001), .Hole(1002, 1002, 1003), .Message(1003, 1003), .Hole(1004, 1004, 1005), .Message(1005, 1005)])
|
|
}*/
|
|
}
|