BagTests_ns.swift

import XCTest
import ReactiveSwift
import Result

private func _measure(times: UInt64 = 2_000_000, label: String = #function, _ action: (() -> UInt64) -> Void) {
	var result: UInt64 = 0
	var minResult: UInt64 = .max

	for i in 0 ..< times {
		var start: UInt64!
		action {
			start = mach_absolute_time()
			return i
		}
		let end = mach_absolute_time()

		let r = (end - start)
		result += r
		minResult = min(minResult, r)
	}

	var base = mach_timebase_info()
	_ = withUnsafeMutablePointer(to: &base, mach_timebase_info)

	let ns = (result / times) / UInt64(base.denom) * UInt64(base.numer)
	let minNs = minResult / UInt64(base.denom) * UInt64(base.numer)

	print("@\(label): avg \(ns) ns; min \(minNs) ns")
}

private func _measureAndStart(times: UInt64 = 2_000_000, label: String = #function, _ action: () -> Void) {
	return _measure(times: times, label: label) { start in
		_ = start()
		action()
	}
}

final class Token {}

class BagTests: XCTestCase {
	func testCopying() {
		var _bag = Bag<Token>()
		_ = (0 ..< 8).map { _ in _bag.insert(Token()) }

		_measureAndStart {
			var bag = _bag
			bag.insert(Token())
		}
	}

	func testIterationOfOne() {
		var bag = Bag<Token>()
		_ = bag.insert(Token())

		_measureAndStart {
			for i in bag {
				_ = i
			}
		}
	}

	func testIteration() {
		var bag = Bag<Token>()
		_ = (0 ..< 8).map { _ in bag.insert(Token()) }

		_measureAndStart {
			for i in bag {
				_ = i
			}
		}
	}

	func testInsertion() {
		_measure { start in
			var bag = Bag<Token>()
			_ = start()

			for _ in 0 ..< 8 {
				bag.insert(Token())
			}
		}
	}

	func testFastPathRemoval() {
		_measure { start in
			var bag = Bag<Token>()
			let tokens = (0 ..< 8).map { _ in bag.insert(Token()) }
			_ = start()

			for token in tokens.reversed() {
				bag.remove(using: token)
			}
		}
	}

	func testAverageRemoval() {
		_measure { start in
			var bag = Bag<Token>()
			let tokens = (0 ..< 8).map { _ in bag.insert(Token()) }
			_ = start()

			for token in tokens {
				bag.remove(using: token)
			}
		}
	}

	func testSignalDelivery() {
		let (signal, observer) = Signal<Int, NoError>.pipe()
		_ =  (0 ..< 8).map { _ in signal.observe { _ in } }

		_measure { start in
			observer.send(value: Int(start()))
		}
	}

	func testDisposableDetachment() {
		_measure { start in
			let (signal, observer) = Signal<Int, NoError>.pipe()

			// Worst case: Removing from the earliest ones.
			let disposables = (0 ..< 8).map { _ in signal.observe { _ in } }
			_ = start()

			for disposable in disposables {
				disposable?.dispose()
			}
		}
	}
}