Merge pull request #12000 from moiseev/arkit+metal-4
[swift-4.0-branch][overlay] Metal, MetalKit, and ARKit changes.
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
index e2afd98..128ad58 100644
--- a/lib/AST/Decl.cpp
+++ b/lib/AST/Decl.cpp
@@ -1973,17 +1973,31 @@
break;
}
+ auto restrictToEnclosing =
+ [this](Accessibility effectiveAccess,
+ Accessibility enclosingAccess) -> Accessibility {
+ if (effectiveAccess == Accessibility::Open &&
+ enclosingAccess == Accessibility::Public &&
+ isa<NominalTypeDecl>(this)) {
+ // Special case: an open class may be contained in a public
+ // class/struct/enum. Leave effectiveAccess as is.
+ return effectiveAccess;
+ }
+ return std::min(effectiveAccess, enclosingAccess);
+ };
+
if (auto enclosingNominal = dyn_cast<NominalTypeDecl>(getDeclContext())) {
- effectiveAccess = std::min(effectiveAccess,
- enclosingNominal->getEffectiveAccess());
+ effectiveAccess =
+ restrictToEnclosing(effectiveAccess,
+ enclosingNominal->getEffectiveAccess());
} else if (auto enclosingExt = dyn_cast<ExtensionDecl>(getDeclContext())) {
// Just check the base type. If it's a constrained extension, Sema should
// have already enforced access more strictly.
if (auto extendedTy = enclosingExt->getExtendedType()) {
if (auto nominal = extendedTy->getAnyNominal()) {
- effectiveAccess = std::min(effectiveAccess,
- nominal->getEffectiveAccess());
+ effectiveAccess =
+ restrictToEnclosing(effectiveAccess, nominal->getEffectiveAccess());
}
}
diff --git a/lib/SILGen/SILGenExpr.cpp b/lib/SILGen/SILGenExpr.cpp
index 3d32374..2f97a61 100644
--- a/lib/SILGen/SILGenExpr.cpp
+++ b/lib/SILGen/SILGenExpr.cpp
@@ -2140,15 +2140,19 @@
auto fnRef = ManagedValue::forUnmanaged(emitGlobalFunctionRef(loc,generator));
auto fnType = fnRef.getType().castTo<SILFunctionType>();
- auto substFnType = fnType->substGenericArgs(SGM.M,
- defaultArgsOwner.getSubstitutions());
+
+ SubstitutionList subs;
+ if (fnType->isPolymorphic())
+ subs = defaultArgsOwner.getSubstitutions();
+
+ auto substFnType = fnType->substGenericArgs(SGM.M, subs);
+
CalleeTypeInfo calleeTypeInfo(substFnType, origResultType, resultType);
ResultPlanPtr resultPtr =
ResultPlanBuilder::computeResultPlan(*this, calleeTypeInfo, loc, C);
ArgumentScope argScope(*this, loc);
return emitApply(std::move(resultPtr), std::move(argScope), loc, fnRef,
- defaultArgsOwner.getSubstitutions(), {}, calleeTypeInfo,
- ApplyOptions::None, C);
+ subs, {}, calleeTypeInfo, ApplyOptions::None, C);
}
RValue SILGenFunction::emitApplyOfStoredPropertyInitializer(
diff --git a/lib/SILOptimizer/Analysis/BasicCalleeAnalysis.cpp b/lib/SILOptimizer/Analysis/BasicCalleeAnalysis.cpp
index 4f72d7d..c026ac5 100644
--- a/lib/SILOptimizer/Analysis/BasicCalleeAnalysis.cpp
+++ b/lib/SILOptimizer/Analysis/BasicCalleeAnalysis.cpp
@@ -201,8 +201,8 @@
return CalleeList();
case ValueKind::ThinToThickFunctionInst:
- Callee = cast<ThinToThickFunctionInst>(Callee)->getOperand();
- LLVM_FALLTHROUGH;
+ return getCalleeListForCalleeKind(
+ cast<ThinToThickFunctionInst>(Callee)->getOperand());
case ValueKind::FunctionRefInst:
return CalleeList(cast<FunctionRefInst>(Callee)->getReferencedFunction());
diff --git a/lib/SILOptimizer/Transforms/SimplifyCFG.cpp b/lib/SILOptimizer/Transforms/SimplifyCFG.cpp
index acb568d..f719fdc 100644
--- a/lib/SILOptimizer/Transforms/SimplifyCFG.cpp
+++ b/lib/SILOptimizer/Transforms/SimplifyCFG.cpp
@@ -67,10 +67,9 @@
llvm::SmallDenseMap<SILBasicBlock*, unsigned, 32> WorklistMap;
// Keep track of loop headers - we don't want to jump-thread through them.
SmallPtrSet<SILBasicBlock *, 32> LoopHeaders;
- // The number of times jump threading was done through a switch_enum in
- // a loop header. Used to limit that to prevent an infinite jump threading
- // loop.
- llvm::SmallDenseMap<SILBasicBlock*, unsigned, 8> JumpThreadedLoopHeaders;
+ // The number of times jump threading was done through a block.
+ // Used to prevent infinite jump threading loops.
+ llvm::SmallDenseMap<SILBasicBlock*, unsigned, 8> JumpThreadedBlocks;
// Dominance and post-dominance info for the current function
DominanceInfo *DT = nullptr;
@@ -1009,15 +1008,14 @@
if (DestIsLoopHeader) {
if (!isa<SwitchEnumInst>(DestBB->getTerminator()))
return false;
-
- // Limit the number we jump-thread through an switch_enum loop header.
- // In case the CFG contains an infinite loop through such a header we
- // otherwise may end up with jump-threading indefinitely.
- unsigned &NumThreaded = JumpThreadedLoopHeaders[DestBB];
- if (++NumThreaded > 8)
- return false;
}
+ // Limit the number we jump-thread through a block.
+ // Otherwise we may end up with jump-threading indefinitely.
+ unsigned &NumThreaded = JumpThreadedBlocks[DestBB];
+ if (++NumThreaded > 16)
+ return false;
+
DEBUG(llvm::dbgs() << "jump thread from bb" << SrcBB->getDebugID() <<
" to bb" << DestBB->getDebugID() << '\n');
diff --git a/lib/Sema/TypeCheckDecl.cpp b/lib/Sema/TypeCheckDecl.cpp
index 8e6c0a0..48b9784 100644
--- a/lib/Sema/TypeCheckDecl.cpp
+++ b/lib/Sema/TypeCheckDecl.cpp
@@ -6235,6 +6235,10 @@
}
void visitDynamicAttr(DynamicAttr *attr) {
+ // Final overrides are not dynamic.
+ if (Override->isFinal())
+ return;
+
makeDynamic(TC.Context, Override);
}
diff --git a/stdlib/public/SDK/Foundation/Data.swift b/stdlib/public/SDK/Foundation/Data.swift
index 560efa0..5398567 100644
--- a/stdlib/public/SDK/Foundation/Data.swift
+++ b/stdlib/public/SDK/Foundation/Data.swift
@@ -27,6 +27,10 @@
internal func __NSDataInvokeDeallocatorFree(_ mem: UnsafeMutableRawPointer, _ length: Int) {
free(mem)
}
+
+internal func __NSDataIsCompact(_ data: NSData) -> Bool {
+ return data._isCompact()
+}
#else
@@ -98,47 +102,140 @@
public var _needToZero: Bool
public var _deallocator: ((UnsafeMutableRawPointer, Int) -> Void)?
public var _backing: Backing = .swift
+ public var _offset: Int
public var bytes: UnsafeRawPointer? {
@inline(__always)
get {
switch _backing {
case .swift:
- return UnsafeRawPointer(_bytes)
+ return UnsafeRawPointer(_bytes)?.advanced(by: -_offset)
case .immutable:
- return UnsafeRawPointer(_bytes)
+ return UnsafeRawPointer(_bytes)?.advanced(by: -_offset)
case .mutable:
- return UnsafeRawPointer(_bytes)
+ return UnsafeRawPointer(_bytes)?.advanced(by: -_offset)
case .customReference(let d):
- return d.bytes
+ return d.bytes.advanced(by: -_offset)
case .customMutableReference(let d):
- return d.bytes
+ return d.bytes.advanced(by: -_offset)
+ }
+ }
+ }
+
+ @discardableResult
+ public func withUnsafeBytes<Result>(in range: Range<Int>, apply: (UnsafeRawBufferPointer) throws -> Result) rethrows -> Result {
+ switch _backing {
+ case .swift: fallthrough
+ case .immutable: fallthrough
+ case .mutable:
+ return try apply(UnsafeRawBufferPointer(start: _bytes?.advanced(by: range.lowerBound - _offset), count: Swift.min(range.count, _length)))
+ case .customReference(let d):
+ if d._isCompact() {
+ let len = d.length
+ guard len > 0 else {
+ return try apply(UnsafeRawBufferPointer(start: nil, count: 0))
+ }
+ return try apply(UnsafeRawBufferPointer(start: d.bytes.advanced(by: range.lowerBound - _offset), count: Swift.min(range.count, len)))
+ } else {
+ var buffer = UnsafeMutableRawBufferPointer.allocate(count: range.count)
+ defer { buffer.deallocate() }
+ let sliceRange = NSRange(location: range.lowerBound - _offset, length: range.count)
+ var enumerated = 0
+ d.enumerateBytes { (ptr, byteRange, stop) in
+ if NSIntersectionRange(sliceRange, byteRange).length > 0 {
+ let lower = Swift.max(byteRange.location, sliceRange.location)
+ let upper = Swift.min(byteRange.location + byteRange.length, sliceRange.location + sliceRange.length)
+ let offset = lower - byteRange.location
+ let effectiveRange = NSRange(location: lower, length: upper - lower)
+ if effectiveRange == sliceRange {
+ memcpy(buffer.baseAddress!, ptr, effectiveRange.length)
+ stop.pointee = true
+ } else {
+ memcpy(buffer.baseAddress!.advanced(by: enumerated), ptr, effectiveRange.length)
+ }
+ enumerated += byteRange.length
+ } else if sliceRange.location + sliceRange.length < byteRange.location {
+ stop.pointee = true
+ }
+ }
+ return try apply(UnsafeRawBufferPointer(buffer))
+ }
+ case .customMutableReference(let d):
+ if d._isCompact() {
+ let len = d.length
+ guard len > 0 else {
+ return try apply(UnsafeRawBufferPointer(start: nil, count: 0))
+ }
+ return try apply(UnsafeRawBufferPointer(start: d.bytes.advanced(by: range.lowerBound - _offset), count: Swift.min(range.count, len)))
+ } else {
+ var buffer = UnsafeMutableRawBufferPointer.allocate(count: range.count)
+ defer { buffer.deallocate() }
+ let sliceRange = NSRange(location: range.lowerBound - _offset, length: range.count)
+ var enumerated = 0
+ d.enumerateBytes { (ptr, byteRange, stop) in
+ if NSIntersectionRange(sliceRange, byteRange).length > 0 {
+ let lower = Swift.max(byteRange.location, sliceRange.location)
+ let upper = Swift.min(byteRange.location + byteRange.length, sliceRange.location + sliceRange.length)
+ let effectiveRange = NSRange(location: lower, length: upper - lower)
+ if effectiveRange == sliceRange {
+ memcpy(buffer.baseAddress!, ptr, effectiveRange.length)
+ stop.pointee = true
+ } else {
+ memcpy(buffer.baseAddress!.advanced(by: enumerated), ptr, effectiveRange.length)
+ }
+ enumerated += byteRange.length
+ } else if sliceRange.location + sliceRange.length < byteRange.location {
+ stop.pointee = true
+ }
+ }
+ return try apply(UnsafeRawBufferPointer(buffer))
}
}
}
+ @discardableResult
+ public func withUnsafeMutableBytes<Result>(in range: Range<Int>, apply: (UnsafeMutableRawBufferPointer) throws -> Result) rethrows -> Result {
+ switch _backing {
+ case .swift: fallthrough
+ case .mutable:
+ return try apply(UnsafeMutableRawBufferPointer(start: _bytes!.advanced(by:range.lowerBound - _offset), count: Swift.min(range.count, _length - range.lowerBound)))
+ case .customMutableReference(let d):
+ let len = d.length
+ return try apply(UnsafeMutableRawBufferPointer(start: d.mutableBytes.advanced(by:range.lowerBound - _offset), count: Swift.min(range.count, len - range.lowerBound)))
+ case .immutable(let d):
+ let data = d.mutableCopy() as! NSMutableData
+ _backing = .mutable(data)
+ _bytes = data.mutableBytes
+ return try apply(UnsafeMutableRawBufferPointer(start: _bytes!.advanced(by:range.lowerBound - _offset), count: Swift.min(range.count, _length - range.lowerBound)))
+ case .customReference(let d):
+ let data = d.mutableCopy() as! NSMutableData
+ _backing = .customMutableReference(data)
+ let len = data.length
+ return try apply(UnsafeMutableRawBufferPointer(start: data.mutableBytes.advanced(by:range.lowerBound - _offset), count: Swift.min(range.count, len - range.lowerBound)))
+ }
+ }
+
public var mutableBytes: UnsafeMutableRawPointer? {
@inline(__always)
get {
switch _backing {
case .swift:
- return _bytes
+ return _bytes?.advanced(by: -_offset)
case .immutable(let d):
let data = d.mutableCopy() as! NSMutableData
data.length = length
_backing = .mutable(data)
_bytes = data.mutableBytes
- return data.mutableBytes
+ return _bytes?.advanced(by: -_offset)
case .mutable:
- return _bytes
+ return _bytes?.advanced(by: -_offset)
case .customReference(let d):
let data = d.mutableCopy() as! NSMutableData
data.length = length
_backing = .customMutableReference(data)
- _bytes = data.mutableBytes
- return data.mutableBytes
+ return data.mutableBytes.advanced(by: -_offset)
case .customMutableReference(let d):
- return d.mutableBytes
+ return d.mutableBytes.advanced(by: -_offset)
}
}
}
@@ -176,32 +273,34 @@
}
}
- public func enumerateBytes(_ block: (_ buffer: UnsafeBufferPointer<UInt8>, _ byteIndex: Data.Index, _ stop: inout Bool) -> Void) {
- var stop: Bool = false
+ public func enumerateBytes(in range: Range<Int>, _ block: (_ buffer: UnsafeBufferPointer<UInt8>, _ byteIndex: Data.Index, _ stop: inout Bool) -> Void) {
+ var stopv: Bool = false
+ var data: NSData
switch _backing {
- case .swift:
- block(UnsafeBufferPointer<UInt8>(start: _bytes?.assumingMemoryBound(to: UInt8.self), count: _length), 0, &stop)
- case .immutable:
- block(UnsafeBufferPointer<UInt8>(start: _bytes?.assumingMemoryBound(to: UInt8.self), count: _length), 0, &stop)
- case .mutable:
- block(UnsafeBufferPointer<UInt8>(start: _bytes?.assumingMemoryBound(to: UInt8.self), count: _length), 0, &stop)
+ case .swift: fallthrough
+ case .immutable: fallthrough
+ case .mutable:
+ block(UnsafeBufferPointer<UInt8>(start: _bytes?.advanced(by: range.lowerBound - _offset).assumingMemoryBound(to: UInt8.self), count: Swift.min(range.count, _length)), 0, &stopv)
+ return
case .customReference(let d):
- d.enumerateBytes { (ptr, range, stop) in
- var stopv = false
- let bytePtr = ptr.bindMemory(to: UInt8.self, capacity: range.length)
- block(UnsafeBufferPointer(start: bytePtr, count: range.length), range.location, &stopv)
- if stopv {
- stop.pointee = true
- }
- }
+ data = d
+ break
case .customMutableReference(let d):
- d.enumerateBytes { (ptr, range, stop) in
- var stopv = false
- let bytePtr = ptr.bindMemory(to: UInt8.self, capacity: range.length)
- block(UnsafeBufferPointer(start: bytePtr, count: range.length), range.location, &stopv)
- if stopv {
- stop.pointee = true
- }
+ data = d
+ break
+ }
+ data.enumerateBytes { (ptr, region, stop) in
+ // any region that is not in the range should be skipped
+ guard range.contains(region.lowerBound) || range.contains(region.upperBound) else { return }
+ var regionAdjustment = 0
+ if region.lowerBound < range.lowerBound {
+ regionAdjustment = range.lowerBound - (region.lowerBound - _offset)
+ }
+ let bytePtr = ptr.advanced(by: regionAdjustment).assumingMemoryBound(to: UInt8.self)
+ let effectiveLength = Swift.min((region.location - _offset) + region.length, range.upperBound) - (region.location - _offset)
+ block(UnsafeBufferPointer(start: bytePtr, count: effectiveLength - regionAdjustment), region.location + regionAdjustment - _offset, &stopv)
+ if stopv {
+ stop.pointee = true
}
}
}
@@ -319,7 +418,7 @@
@inline(__always)
public func append(_ bytes: UnsafeRawPointer, length: Int) {
- precondition(length >= 0, "Length of appending bytes must be positive")
+ precondition(length >= 0, "Length of appending bytes must not be negative")
switch _backing {
case .swift:
let origLength = _length
@@ -398,6 +497,43 @@
}
}
+
+ public func get(_ index: Int) -> UInt8 {
+ switch _backing {
+ case .swift: fallthrough
+ case .immutable: fallthrough
+ case .mutable:
+ return _bytes!.advanced(by: index - _offset).assumingMemoryBound(to: UInt8.self).pointee
+ case .customReference(let d):
+ if d._isCompact() {
+ return d.bytes.advanced(by: index - _offset).assumingMemoryBound(to: UInt8.self).pointee
+ } else {
+ var byte: UInt8 = 0
+ d.enumerateBytes { (ptr, range, stop) in
+ if NSLocationInRange(index, range) {
+ let offset = index - range.location - _offset
+ byte = ptr.advanced(by: offset).assumingMemoryBound(to: UInt8.self).pointee
+ stop.pointee = true
+ }
+ }
+ return byte
+ }
+ case .customMutableReference(let d):
+ if d._isCompact() {
+ return d.bytes.advanced(by: index - _offset).assumingMemoryBound(to: UInt8.self).pointee
+ } else {
+ var byte: UInt8 = 0
+ d.enumerateBytes { (ptr, range, stop) in
+ if NSLocationInRange(index, range) {
+ let offset = index - range.location - _offset
+ byte = ptr.advanced(by: offset).assumingMemoryBound(to: UInt8.self).pointee
+ stop.pointee = true
+ }
+ }
+ return byte
+ }
+ }
+ }
@inline(__always)
public func set(_ index: Int, to value: UInt8) {
@@ -405,7 +541,7 @@
case .swift:
fallthrough
case .mutable:
- _bytes!.advanced(by: index).assumingMemoryBound(to: UInt8.self).pointee = value
+ _bytes!.advanced(by: index - _offset).assumingMemoryBound(to: UInt8.self).pointee = value
default:
var theByte = value
let range = NSRange(location: index, length: 1)
@@ -427,28 +563,29 @@
}
_length = newLength
}
- _DataStorage.move(_bytes!.advanced(by: range.location), bytes!, range.length)
+ _DataStorage.move(_bytes!.advanced(by: range.location - _offset), bytes!, range.length)
case .immutable(let d):
let data = d.mutableCopy() as! NSMutableData
- data.replaceBytes(in: range, withBytes: bytes!)
+ data.replaceBytes(in: NSRange(location: range.location - _offset, length: range.length), withBytes: bytes!)
_backing = .mutable(data)
_length = data.length
_bytes = data.mutableBytes
case .mutable(let d):
- d.replaceBytes(in: range, withBytes: bytes!)
+ d.replaceBytes(in: NSRange(location: range.location - _offset, length: range.length), withBytes: bytes!)
_length = d.length
_bytes = d.mutableBytes
case .customReference(let d):
let data = d.mutableCopy() as! NSMutableData
- data.replaceBytes(in: range, withBytes: bytes!)
+ data.replaceBytes(in: NSRange(location: range.location - _offset, length: range.length), withBytes: bytes!)
_backing = .customMutableReference(data)
case .customMutableReference(let d):
- d.replaceBytes(in: range, withBytes: bytes!)
+ d.replaceBytes(in: NSRange(location: range.location - _offset, length: range.length), withBytes: bytes!)
}
}
@inline(__always)
- public func replaceBytes(in range: NSRange, with replacementBytes: UnsafeRawPointer?, length replacementLength: Int) {
+ public func replaceBytes(in range_: NSRange, with replacementBytes: UnsafeRawPointer?, length replacementLength: Int) {
+ let range = NSRange(location: range_.location - _offset, length: range_.length)
let currentLength = _length
let resultingLength = currentLength - range.length + replacementLength
switch _backing {
@@ -497,7 +634,8 @@
}
@inline(__always)
- public func resetBytes(in range: NSRange) {
+ public func resetBytes(in range_: NSRange) {
+ let range = NSRange(location: range_.location - _offset, length: range_.length)
if range.length == 0 { return }
switch _backing {
case .swift:
@@ -546,6 +684,7 @@
_capacity = capacity
_needToZero = !clear
_length = 0
+ _offset = 0
setLength(length)
}
@@ -560,10 +699,12 @@
_bytes = _DataStorage.allocate(capacity, false)!
_capacity = capacity
_needToZero = true
+ _offset = 0
}
public init(bytes: UnsafeRawPointer?, length: Int) {
precondition(length < _DataStorage.maxSize)
+ _offset = 0
if length == 0 {
_capacity = 0
_length = 0
@@ -588,8 +729,9 @@
}
}
- public init(bytes: UnsafeMutableRawPointer?, length: Int, copy: Bool, deallocator: ((UnsafeMutableRawPointer, Int) -> Void)?) {
+ public init(bytes: UnsafeMutableRawPointer?, length: Int, copy: Bool, deallocator: ((UnsafeMutableRawPointer, Int) -> Void)?, offset: Int) {
precondition(length < _DataStorage.maxSize)
+ _offset = offset
if length == 0 {
_capacity = 0
_length = 0
@@ -630,7 +772,8 @@
}
}
- public init(immutableReference: NSData) {
+ public init(immutableReference: NSData, offset: Int) {
+ _offset = offset
_bytes = UnsafeMutableRawPointer(mutating: immutableReference.bytes)
_capacity = 0
_needToZero = false
@@ -638,7 +781,8 @@
_backing = .immutable(immutableReference)
}
- public init(mutableReference: NSMutableData) {
+ public init(mutableReference: NSMutableData, offset: Int) {
+ _offset = offset
_bytes = mutableReference.mutableBytes
_capacity = 0
_needToZero = false
@@ -646,7 +790,8 @@
_backing = .mutable(mutableReference)
}
- public init(customReference: NSData) {
+ public init(customReference: NSData, offset: Int) {
+ _offset = offset
_bytes = nil
_capacity = 0
_needToZero = false
@@ -654,7 +799,8 @@
_backing = .customReference(customReference)
}
- public init(customMutableReference: NSMutableData) {
+ public init(customMutableReference: NSMutableData, offset: Int) {
+ _offset = offset
_bytes = nil
_capacity = 0
_needToZero = false
@@ -675,30 +821,30 @@
public func mutableCopy(_ range: Range<Int>) -> _DataStorage {
switch _backing {
case .swift:
- return _DataStorage(bytes: _bytes?.advanced(by: range.lowerBound), length: range.count, copy: true, deallocator: nil)
+ return _DataStorage(bytes: _bytes?.advanced(by: range.lowerBound - _offset), length: range.count, copy: true, deallocator: nil, offset: range.lowerBound)
case .immutable(let d):
if range.lowerBound == 0 && range.upperBound == _length {
- return _DataStorage(mutableReference: d.mutableCopy() as! NSMutableData)
+ return _DataStorage(mutableReference: d.mutableCopy() as! NSMutableData, offset: range.lowerBound)
} else {
- return _DataStorage(mutableReference: d.subdata(with: NSRange(location: range.lowerBound, length: range.count))._bridgeToObjectiveC().mutableCopy() as! NSMutableData)
+ return _DataStorage(mutableReference: d.subdata(with: NSRange(location: range.lowerBound, length: range.count))._bridgeToObjectiveC().mutableCopy() as! NSMutableData, offset: range.lowerBound)
}
case .mutable(let d):
if range.lowerBound == 0 && range.upperBound == _length {
- return _DataStorage(mutableReference: d.mutableCopy() as! NSMutableData)
+ return _DataStorage(mutableReference: d.mutableCopy() as! NSMutableData, offset: range.lowerBound)
} else {
- return _DataStorage(mutableReference: d.subdata(with: NSRange(location: range.lowerBound, length: range.count))._bridgeToObjectiveC().mutableCopy() as! NSMutableData)
+ return _DataStorage(mutableReference: d.subdata(with: NSRange(location: range.lowerBound, length: range.count))._bridgeToObjectiveC().mutableCopy() as! NSMutableData, offset: range.lowerBound)
}
case .customReference(let d):
if range.lowerBound == 0 && range.upperBound == _length {
- return _DataStorage(mutableReference: d.mutableCopy() as! NSMutableData)
+ return _DataStorage(mutableReference: d.mutableCopy() as! NSMutableData, offset: range.lowerBound)
} else {
- return _DataStorage(mutableReference: d.subdata(with: NSRange(location: range.lowerBound, length: range.count))._bridgeToObjectiveC().mutableCopy() as! NSMutableData)
+ return _DataStorage(mutableReference: d.subdata(with: NSRange(location: range.lowerBound, length: range.count))._bridgeToObjectiveC().mutableCopy() as! NSMutableData, offset: range.lowerBound)
}
case .customMutableReference(let d):
if range.lowerBound == 0 && range.upperBound == _length {
- return _DataStorage(mutableReference: d.mutableCopy() as! NSMutableData)
+ return _DataStorage(mutableReference: d.mutableCopy() as! NSMutableData, offset: range.lowerBound)
} else {
- return _DataStorage(mutableReference: d.subdata(with: NSRange(location: range.lowerBound, length: range.count))._bridgeToObjectiveC().mutableCopy() as! NSMutableData)
+ return _DataStorage(mutableReference: d.subdata(with: NSRange(location: range.lowerBound, length: range.count))._bridgeToObjectiveC().mutableCopy() as! NSMutableData, offset: range.lowerBound)
}
}
}
@@ -710,26 +856,26 @@
switch _backing {
case .swift:
- return try work(NSData(bytesNoCopy: _bytes!.advanced(by: range.lowerBound), length: range.count, freeWhenDone: false))
+ return try work(NSData(bytesNoCopy: _bytes!.advanced(by: range.lowerBound - _offset), length: range.count, freeWhenDone: false))
case .immutable(let d):
guard range.lowerBound == 0 && range.upperBound == _length else {
- return try work(NSData(bytesNoCopy: _bytes!.advanced(by: range.lowerBound), length: range.count, freeWhenDone: false))
+ return try work(NSData(bytesNoCopy: _bytes!.advanced(by: range.lowerBound - _offset), length: range.count, freeWhenDone: false))
}
return try work(d)
case .mutable(let d):
guard range.lowerBound == 0 && range.upperBound == _length else {
- return try work(NSData(bytesNoCopy: _bytes!.advanced(by: range.lowerBound), length: range.count, freeWhenDone: false))
+ return try work(NSData(bytesNoCopy: _bytes!.advanced(by: range.lowerBound - _offset), length: range.count, freeWhenDone: false))
}
return try work(d)
case .customReference(let d):
guard range.lowerBound == 0 && range.upperBound == _length else {
- return try work(NSData(bytesNoCopy: UnsafeMutableRawPointer(mutating: d.bytes.advanced(by: range.lowerBound)), length: range.count, freeWhenDone: false))
+ return try work(NSData(bytesNoCopy: UnsafeMutableRawPointer(mutating: d.bytes.advanced(by: range.lowerBound - _offset)), length: range.count, freeWhenDone: false))
}
return try work(d)
case .customMutableReference(let d):
guard range.lowerBound == 0 && range.upperBound == _length else {
- return try work(NSData(bytesNoCopy: UnsafeMutableRawPointer(mutating: d.bytes.advanced(by: range.lowerBound)), length: range.count, freeWhenDone: false))
+ return try work(NSData(bytesNoCopy: UnsafeMutableRawPointer(mutating: d.bytes.advanced(by: range.lowerBound - _offset)), length: range.count, freeWhenDone: false))
}
return try work(d)
}
@@ -766,26 +912,14 @@
}
}
- public var hashValue: Int {
- switch _backing {
- case .customReference(let d):
- return d.hash
- case .customMutableReference(let d):
- return d.hash
- default:
- let len = _length
- return Int(bitPattern: CFHashBytes(_bytes?.assumingMemoryBound(to: UInt8.self), Swift.min(len, 80)))
- }
- }
-
public func subdata(in range: Range<Data.Index>) -> Data {
switch _backing {
case .customReference(let d):
- return d.subdata(with: NSRange(location: range.lowerBound, length: range.count))
+ return d.subdata(with: NSRange(location: range.lowerBound - _offset, length: range.count))
case .customMutableReference(let d):
- return d.subdata(with: NSRange(location: range.lowerBound, length: range.count))
+ return d.subdata(with: NSRange(location: range.lowerBound - _offset, length: range.count))
default:
- return Data(bytes: _bytes!.advanced(by: range.lowerBound), count: range.count)
+ return Data(bytes: _bytes!.advanced(by: range.lowerBound - _offset), count: range.count)
}
}
}
@@ -827,7 +961,7 @@
}
#if !DEPLOYMENT_RUNTIME_SWIFT
- @objc
+ @objc override
func _isCompact() -> Bool {
return true
}
@@ -1015,7 +1149,7 @@
/// - parameter deallocator: Specifies the mechanism to free the indicated buffer, or `.none`.
public init(bytesNoCopy bytes: UnsafeMutableRawPointer, count: Int, deallocator: Deallocator) {
let whichDeallocator = deallocator._deallocator
- _backing = _DataStorage(bytes: bytes, length: count, copy: false, deallocator: whichDeallocator)
+ _backing = _DataStorage(bytes: bytes, length: count, copy: false, deallocator: whichDeallocator, offset: 0)
_sliceRange = 0..<count
}
@@ -1026,7 +1160,7 @@
/// - throws: An error in the Cocoa domain, if `url` cannot be read.
public init(contentsOf url: URL, options: Data.ReadingOptions = []) throws {
let d = try NSData(contentsOf: url, options: ReadingOptions(rawValue: options.rawValue))
- _backing = _DataStorage(immutableReference: d)
+ _backing = _DataStorage(immutableReference: d, offset: 0)
_sliceRange = 0..<d.length
}
@@ -1037,7 +1171,7 @@
/// - parameter options: Encoding options. Default value is `[]`.
public init?(base64Encoded base64String: String, options: Data.Base64DecodingOptions = []) {
if let d = NSData(base64Encoded: base64String, options: Base64DecodingOptions(rawValue: options.rawValue)) {
- _backing = _DataStorage(immutableReference: d)
+ _backing = _DataStorage(immutableReference: d, offset: 0)
_sliceRange = 0..<d.length
} else {
return nil
@@ -1052,7 +1186,7 @@
/// - parameter options: Decoding options. Default value is `[]`.
public init?(base64Encoded base64Data: Data, options: Data.Base64DecodingOptions = []) {
if let d = NSData(base64Encoded: base64Data, options: Base64DecodingOptions(rawValue: options.rawValue)) {
- _backing = _DataStorage(immutableReference: d)
+ _backing = _DataStorage(immutableReference: d, offset: 0)
_sliceRange = 0..<d.length
} else {
return nil
@@ -1073,10 +1207,10 @@
let providesConcreteBacking = (reference as AnyObject)._providesConcreteBacking?() ?? false
#endif
if providesConcreteBacking {
- _backing = _DataStorage(immutableReference: reference.copy() as! NSData)
+ _backing = _DataStorage(immutableReference: reference.copy() as! NSData, offset: 0)
_sliceRange = 0..<reference.length
} else {
- _backing = _DataStorage(customReference: reference.copy() as! NSData)
+ _backing = _DataStorage(customReference: reference.copy() as! NSData, offset: 0)
_sliceRange = 0..<reference.length
}
@@ -1094,7 +1228,11 @@
} else if let buffer = elements as? UnsafeMutableBufferPointer<UInt8> {
self.init(buffer: buffer)
} else if let data = elements as? Data {
- self.init(backing: data._backing.mutableCopy(data._sliceRange), range: 0..<data.count)
+ let len = data.count
+ let backing = data.withUnsafeBytes { (bytes: UnsafePointer<UInt8>) in
+ return _DataStorage(bytes: bytes, length: len)
+ }
+ self.init(backing: backing, range: 0..<len)
} else {
let underestimatedCount = elements.underestimatedCount
self.init(count: underestimatedCount)
@@ -1137,7 +1275,7 @@
}
@inline(__always)
set {
- precondition(count >= 0, "Count must be positive")
+ precondition(count >= 0, "count must not be negative")
if !isKnownUniquelyReferenced(&_backing) {
_backing = _backing.mutableCopy(_sliceRange)
}
@@ -1151,9 +1289,9 @@
/// - warning: The byte pointer argument should not be stored and used outside of the lifetime of the call to the closure.
@inline(__always)
public func withUnsafeBytes<ResultType, ContentType>(_ body: (UnsafePointer<ContentType>) throws -> ResultType) rethrows -> ResultType {
- let bytes = _backing.bytes?.advanced(by: _sliceRange.lowerBound) ?? UnsafeRawPointer(bitPattern: 0xBAD0)!
- let contentPtr = bytes.bindMemory(to: ContentType.self, capacity: count / MemoryLayout<ContentType>.stride)
- return try body(contentPtr)
+ return try _backing.withUnsafeBytes(in: _sliceRange) {
+ return try body($0.baseAddress?.assumingMemoryBound(to: ContentType.self) ?? UnsafePointer<ContentType>(bitPattern: 0xBAD0)!)
+ }
}
@@ -1166,9 +1304,9 @@
if !isKnownUniquelyReferenced(&_backing) {
_backing = _backing.mutableCopy(_sliceRange)
}
- let mutableBytes = _backing.mutableBytes?.advanced(by: _sliceRange.lowerBound) ?? UnsafeMutableRawPointer(bitPattern: 0xBAD0)!
- let contentPtr = mutableBytes.bindMemory(to: ContentType.self, capacity: count / MemoryLayout<ContentType>.stride)
- return try body(UnsafeMutablePointer(contentPtr))
+ return try _backing.withUnsafeMutableBytes(in: _sliceRange) {
+ return try body($0.baseAddress?.assumingMemoryBound(to: ContentType.self) ?? UnsafeMutablePointer<ContentType>(bitPattern: 0xBAD0)!)
+ }
}
// MARK: -
@@ -1181,15 +1319,19 @@
/// - warning: This method does not verify that the contents at pointer have enough space to hold `count` bytes.
@inline(__always)
public func copyBytes(to pointer: UnsafeMutablePointer<UInt8>, count: Int) {
- precondition(count >= 0, "Count of bytes to copy must be positive")
+ precondition(count >= 0, "count of bytes to copy must not be negative")
if count == 0 { return }
- memcpy(UnsafeMutableRawPointer(pointer), _backing.bytes!.advanced(by: _sliceRange.lowerBound), Swift.min(count, _sliceRange.count))
+ _backing.withUnsafeBytes(in: _sliceRange) {
+ memcpy(UnsafeMutableRawPointer(pointer), $0.baseAddress!, Swift.min(count, $0.count))
+ }
}
@inline(__always)
private func _copyBytesHelper(to pointer: UnsafeMutableRawPointer, from range: NSRange) {
if range.length == 0 { return }
- memcpy(UnsafeMutableRawPointer(pointer), _backing.bytes!.advanced(by: range.location), Swift.min(range.length, _sliceRange.count))
+ _backing.withUnsafeBytes(in: range.lowerBound..<range.upperBound) {
+ memcpy(UnsafeMutableRawPointer(pointer), $0.baseAddress!, Swift.min(range.length, $0.count))
+ }
}
/// Copy a subset of the contents of the data to a pointer.
@@ -1297,27 +1439,20 @@
/// In some cases, (for example, a `Data` backed by a `dispatch_data_t`, the bytes may be stored discontiguously. In those cases, this function invokes the closure for each contiguous region of bytes.
/// - parameter block: The closure to invoke for each region of data. You may stop the enumeration by setting the `stop` parameter to `true`.
public func enumerateBytes(_ block: (_ buffer: UnsafeBufferPointer<UInt8>, _ byteIndex: Index, _ stop: inout Bool) -> Void) {
- _backing.enumerateBytes(block)
+ _backing.enumerateBytes(in: _sliceRange, block)
}
@inline(__always)
public mutating func append(_ bytes: UnsafePointer<UInt8>, count: Int) {
- precondition(count >= 0, "Count must be positive")
if count == 0 { return }
- if !isKnownUniquelyReferenced(&_backing) {
- _backing = _backing.mutableCopy(_sliceRange)
- }
- _backing.append(bytes, length: count)
- _sliceRange = _sliceRange.lowerBound..<(_sliceRange.upperBound + count)
+ append(UnsafeBufferPointer(start: bytes, count: count))
}
@inline(__always)
public mutating func append(_ other: Data) {
- if !isKnownUniquelyReferenced(&_backing) {
- _backing = _backing.mutableCopy(_sliceRange)
+ other.enumerateBytes { (buffer, _, _) in
+ append(buffer)
}
- _backing.append(other._backing, startingAt: other._sliceRange.lowerBound, endingAt: other._sliceRange.upperBound)
- _sliceRange = _sliceRange.lowerBound..<(_sliceRange.upperBound + other.count)
}
/// Append a buffer of bytes to the data.
@@ -1329,22 +1464,26 @@
if !isKnownUniquelyReferenced(&_backing) {
_backing = _backing.mutableCopy(_sliceRange)
}
- _backing.append(buffer.baseAddress!, length: buffer.count * MemoryLayout<SourceType>.stride)
+ _backing.replaceBytes(in: NSRange(location: _sliceRange.upperBound, length: _backing.length - (_sliceRange.upperBound - _backing._offset)), with: buffer.baseAddress, length: buffer.count * MemoryLayout<SourceType>.stride)
_sliceRange = _sliceRange.lowerBound..<(_sliceRange.upperBound + buffer.count * MemoryLayout<SourceType>.stride)
}
@inline(__always)
public mutating func append<S : Sequence>(contentsOf newElements: S) where S.Iterator.Element == Iterator.Element {
let estimatedCount = newElements.underestimatedCount
- var idx = count
- count += estimatedCount
- for byte in newElements {
- let newIndex = idx + 1
- if newIndex > count {
- count = newIndex
+ guard estimatedCount > 0 else {
+ for byte in newElements {
+ append(byte)
}
- self[idx] = byte
- idx = newIndex
+ return
+ }
+ _withStackOrHeapBuffer(estimatedCount) { allocation in
+ let buffer = UnsafeMutableBufferPointer(start: allocation.pointee.memory.assumingMemoryBound(to: UInt8.self), count: estimatedCount)
+ var (iterator, endPoint) = newElements._copyContents(initializing: buffer)
+ append(buffer.baseAddress!, count: endPoint - buffer.startIndex)
+ while let byte = iterator.next() {
+ append(byte)
+ }
}
}
@@ -1364,16 +1503,15 @@
@inline(__always)
public mutating func resetBytes(in range: Range<Index>) {
// it is worth noting that the range here may be out of bounds of the Data itself (which triggers a growth)
- precondition(range.lowerBound >= 0, "Ranges must be positive bounds")
- precondition(range.upperBound >= 0, "Ranges must be positive bounds")
+ precondition(range.lowerBound >= 0, "Ranges must not be negative bounds")
+ precondition(range.upperBound >= 0, "Ranges must not be negative bounds")
let range = NSMakeRange(range.lowerBound, range.upperBound - range.lowerBound)
if !isKnownUniquelyReferenced(&_backing) {
_backing = _backing.mutableCopy(_sliceRange)
}
_backing.resetBytes(in: range)
- if _sliceRange.count < range.location + range.length {
- let newLength = range.location + range.length
- _sliceRange = _sliceRange.lowerBound..<(_sliceRange.lowerBound + newLength)
+ if _sliceRange.upperBound < range.upperBound {
+ _sliceRange = _sliceRange.lowerBound..<range.upperBound
}
}
@@ -1386,34 +1524,16 @@
/// - parameter data: The replacement data.
@inline(__always)
public mutating func replaceSubrange(_ subrange: Range<Index>, with data: Data) {
- _validateRange(subrange)
- let nsRange = NSMakeRange(subrange.lowerBound, subrange.upperBound - subrange.lowerBound)
let cnt = data.count
- if !isKnownUniquelyReferenced(&_backing) {
- _backing = _backing.mutableCopy(_sliceRange)
+ data.withUnsafeBytes {
+ replaceSubrange(subrange, with: $0, count: cnt)
}
- let resultingLength = data.withUnsafeBytes { (bytes: UnsafePointer<UInt8>) -> Int in
- let currentLength = _backing.length
- _backing.replaceBytes(in: nsRange, with: bytes, length: cnt)
- return currentLength - nsRange.length + cnt
- }
- _sliceRange = _sliceRange.lowerBound..<(_sliceRange.lowerBound + resultingLength)
}
@inline(__always)
public mutating func replaceSubrange(_ subrange: CountableRange<Index>, with data: Data) {
- _validateRange(subrange)
- let nsRange = NSMakeRange(subrange.lowerBound, subrange.upperBound - subrange.lowerBound)
- let cnt = data.count
- if !isKnownUniquelyReferenced(&_backing) {
- _backing = _backing.mutableCopy(_sliceRange)
- }
- let resultingLength = data.withUnsafeBytes { (bytes: UnsafePointer<UInt8>) -> Int in
- let currentLength = _backing.length
- _backing.replaceBytes(in: nsRange, with: bytes, length: cnt)
- return currentLength - nsRange.length + cnt
- }
- _sliceRange = _sliceRange.lowerBound..<(_sliceRange.lowerBound + resultingLength)
+ let range: Range<Int> = subrange.lowerBound..<subrange.upperBound
+ replaceSubrange(range, with: data)
}
/// Replace a region of bytes in the data with new bytes from a buffer.
@@ -1425,17 +1545,8 @@
/// - parameter buffer: The replacement bytes.
@inline(__always)
public mutating func replaceSubrange<SourceType>(_ subrange: Range<Index>, with buffer: UnsafeBufferPointer<SourceType>) {
- _validateRange(subrange)
- let nsRange = NSMakeRange(subrange.lowerBound, subrange.upperBound - subrange.lowerBound)
- let bufferCount = buffer.count * MemoryLayout<SourceType>.stride
-
- if !isKnownUniquelyReferenced(&_backing) {
- _backing = _backing.mutableCopy(_sliceRange)
- }
- let currentLength = _backing.length
- _backing.replaceBytes(in: nsRange, with: buffer.baseAddress, length: bufferCount)
- let resultingLength = currentLength - nsRange.length + bufferCount
- _sliceRange = _sliceRange.lowerBound..<(_sliceRange.lowerBound + resultingLength)
+ guard buffer.count > 0 else { return }
+ replaceSubrange(subrange, with: buffer.baseAddress!, count: buffer.count * MemoryLayout<SourceType>.stride)
}
/// Replace a region of bytes in the data with new bytes from a collection.
@@ -1446,39 +1557,18 @@
/// - parameter subrange: The range in the data to replace.
/// - parameter newElements: The replacement bytes.
@inline(__always)
- public mutating func replaceSubrange<ByteCollection : Collection>(_ subrange: Range<Index>, with newElements: ByteCollection)
- where ByteCollection.Iterator.Element == Data.Iterator.Element {
- _validateRange(subrange)
- // Calculate this once, it may not be O(1)
- let replacementCount: Int = numericCast(newElements.count)
- let currentCount = self.count
- let subrangeCount = subrange.count
-
- _validateRange(subrange)
-
- let resultCount = currentCount - subrangeCount + replacementCount
- if resultCount != currentCount {
- // This may realloc.
- // In the future, if we keep the malloced pointer and count inside this struct/ref instead of deferring to NSData, we may be able to do this more efficiently.
- self.count = resultCount
+ public mutating func replaceSubrange<ByteCollection : Collection>(_ subrange: Range<Index>, with newElements: ByteCollection) where ByteCollection.Iterator.Element == Data.Iterator.Element {
+ _validateRange(subrange)
+ let totalCount: Int = numericCast(newElements.count)
+ _withStackOrHeapBuffer(totalCount) { conditionalBuffer in
+ let buffer = UnsafeMutableBufferPointer(start: conditionalBuffer.pointee.memory.assumingMemoryBound(to: UInt8.self), count: totalCount)
+ var (iterator, index) = newElements._copyContents(initializing: buffer)
+ while let byte = iterator.next() {
+ buffer[index] = byte
+ index = buffer.index(after: index)
}
-
- let shift = resultCount - currentCount
- let start = subrange.lowerBound
-
- self.withUnsafeMutableBytes { (bytes : UnsafeMutablePointer<UInt8>) -> Void in
- if shift != 0 {
- let destination = bytes + start + replacementCount
- let source = bytes + start + subrangeCount
- memmove(destination, source, currentCount - start - subrangeCount)
- }
-
- if replacementCount != 0 {
- let buf = UnsafeMutableBufferPointer(start: bytes + start, count: replacementCount)
- var (it,idx) = newElements._copyContents(initializing: buf)
- precondition(it.next() == nil && idx == buf.endIndex, "newElements iterator returned different count to newElements.count")
- }
- }
+ replaceSubrange(subrange, with: conditionalBuffer.pointee.memory, count: totalCount)
+ }
}
@inline(__always)
@@ -1488,10 +1578,10 @@
if !isKnownUniquelyReferenced(&_backing) {
_backing = _backing.mutableCopy(_sliceRange)
}
- let currentLength = _backing.length
+ let upper = _sliceRange.upperBound
_backing.replaceBytes(in: nsRange, with: bytes, length: cnt)
- let resultingLength = currentLength - nsRange.length + cnt
- _sliceRange = _sliceRange.lowerBound..<(_sliceRange.lowerBound + resultingLength)
+ let resultingUpper = upper - nsRange.length + cnt
+ _sliceRange = _sliceRange.lowerBound..<resultingUpper
}
/// Return a new copy of the data in a specified range.
@@ -1535,7 +1625,15 @@
/// The hash value for the data.
public var hashValue: Int {
- return _backing.hashValue
+ var hashValue = 0
+ let hashRange: Range<Int> = _sliceRange.lowerBound..<Swift.min(_sliceRange.lowerBound + 80, _sliceRange.upperBound)
+ _withStackOrHeapBuffer(hashRange.count) { buffer in
+ _backing.withUnsafeBytes(in: hashRange) {
+ memcpy(buffer.pointee.memory, $0.baseAddress!, hashRange.count)
+ }
+ hashValue = Int(bitPattern: CFHashBytes(buffer.pointee.memory.assumingMemoryBound(to: UInt8.self), hashRange.count))
+ }
+ return hashValue
}
@inline(__always)
@@ -1558,7 +1656,7 @@
@inline(__always)
get {
_validateIndex(index)
- return _backing.bytes!.advanced(by: index).assumingMemoryBound(to: UInt8.self).pointee
+ return _backing.get(index)
}
@inline(__always)
set {
@@ -1771,7 +1869,7 @@
// Minimal size data is output as an array
if nBytes < 64 {
- children.append((label: "bytes", value: Array(self[0..<nBytes])))
+ children.append((label: "bytes", value: Array(self[startIndex..<Swift.min(nBytes + startIndex, endIndex)])))
}
let m = Mirror(self, children:children, displayStyle: Mirror.DisplayStyle.struct)
@@ -1900,4 +1998,3 @@
}
}
}
-
diff --git a/stdlib/public/SwiftShims/FoundationOverlayShims.h b/stdlib/public/SwiftShims/FoundationOverlayShims.h
index af77954..53ef214 100644
--- a/stdlib/public/SwiftShims/FoundationOverlayShims.h
+++ b/stdlib/public/SwiftShims/FoundationOverlayShims.h
@@ -14,6 +14,9 @@
#import <objc/runtime.h>
#import <objc/message.h>
#import <sys/fcntl.h>
+#import <alloca.h>
+#import <stdlib.h>
+#import <malloc/malloc.h>
#import "FoundationShimSupport.h"
#import "NSCalendarShims.h"
@@ -29,3 +32,41 @@
#import "NSLocaleShims.h"
#import "NSTimeZoneShims.h"
#import "NSUndoManagerShims.h"
+
+typedef struct {
+ void *_Nonnull memory;
+ size_t capacity;
+ _Bool onStack;
+} _ConditionalAllocationBuffer;
+
+static inline _Bool _resizeConditionalAllocationBuffer(_ConditionalAllocationBuffer *_Nonnull buffer, size_t amt) {
+ size_t amount = malloc_good_size(amt);
+ if (amount <= buffer->capacity) { return true; }
+ void *newMemory;
+ if (buffer->onStack) {
+ newMemory = malloc(amount);
+ if (newMemory == NULL) { return false; }
+ memcpy(newMemory, buffer->memory, buffer->capacity);
+ buffer->onStack = false;
+ } else {
+ newMemory = realloc(buffer->memory, amount);
+ if (newMemory == NULL) { return false; }
+ }
+ if (newMemory == NULL) { return false; }
+ buffer->memory = newMemory;
+ buffer->capacity = amount;
+ return true;
+}
+
+static inline _Bool _withStackOrHeapBuffer(size_t amount, void (__attribute__((noescape)) ^ _Nonnull applier)(_ConditionalAllocationBuffer *_Nonnull)) {
+ _ConditionalAllocationBuffer buffer;
+ buffer.capacity = malloc_good_size(amount);
+ buffer.onStack = (pthread_main_np() != 0 ? buffer.capacity < 2048 : buffer.capacity < 512);
+ buffer.memory = buffer.onStack ? alloca(buffer.capacity) : malloc(buffer.capacity);
+ if (buffer.memory == NULL) { return false; }
+ applier(&buffer);
+ if (!buffer.onStack) {
+ free(buffer.memory);
+ }
+ return true;
+}
diff --git a/stdlib/public/SwiftShims/NSDataShims.h b/stdlib/public/SwiftShims/NSDataShims.h
index de64023..a4baabd 100644
--- a/stdlib/public/SwiftShims/NSDataShims.h
+++ b/stdlib/public/SwiftShims/NSDataShims.h
@@ -20,4 +20,8 @@
FOUNDATION_EXPORT const NSDataDeallocator NSDataDeallocatorFree;
FOUNDATION_EXPORT const NSDataDeallocator NSDataDeallocatorNone;
+@interface NSData (FoundationSPI)
+- (BOOL)_isCompact;
+@end
+
NS_END_DECLS
diff --git a/stdlib/public/runtime/SwiftObject.mm b/stdlib/public/runtime/SwiftObject.mm
index b8d2c82..54e3d73 100644
--- a/stdlib/public/runtime/SwiftObject.mm
+++ b/stdlib/public/runtime/SwiftObject.mm
@@ -407,13 +407,16 @@
// Foundation collections expect these to be implemented.
- (BOOL)isNSArray__ { return NO; }
-- (BOOL)isNSDictionary__ { return NO; }
-- (BOOL)isNSSet__ { return NO; }
-- (BOOL)isNSOrderedSet__ { return NO; }
-- (BOOL)isNSNumber__ { return NO; }
+- (BOOL)isNSCFConstantString__ { return NO; }
- (BOOL)isNSData__ { return NO; }
- (BOOL)isNSDate__ { return NO; }
+- (BOOL)isNSDictionary__ { return NO; }
+- (BOOL)isNSObject__ { return NO; }
+- (BOOL)isNSOrderedSet__ { return NO; }
+- (BOOL)isNSNumber__ { return NO; }
+- (BOOL)isNSSet__ { return NO; }
- (BOOL)isNSString__ { return NO; }
+- (BOOL)isNSTimeZone__ { return NO; }
- (BOOL)isNSValue__ { return NO; }
@end
diff --git a/test/IRGen/Inputs/vtable_symbol_linkage_base.swift b/test/IRGen/Inputs/vtable_symbol_linkage_base.swift
index 32c54c1..3ee50a6 100644
--- a/test/IRGen/Inputs/vtable_symbol_linkage_base.swift
+++ b/test/IRGen/Inputs/vtable_symbol_linkage_base.swift
@@ -10,3 +10,18 @@
private var privateVar: Int = 29
internal var internalVar: Int = 30
}
+
+
+public struct Namespace {
+ open class Nested {
+ public init() {}
+ var storedProp: Int?
+ }
+}
+
+extension Namespace {
+ open class ExtNested {
+ public init() {}
+ var storedProp: Int?
+ }
+}
diff --git a/test/IRGen/vtable_symbol_linkage.swift b/test/IRGen/vtable_symbol_linkage.swift
index 9547b4f..0800347 100644
--- a/test/IRGen/vtable_symbol_linkage.swift
+++ b/test/IRGen/vtable_symbol_linkage.swift
@@ -9,4 +9,5 @@
public class Derived : Base {
}
-
+public class DerivedNested : Namespace.Nested {}
+public class DerivedExtNested : Namespace.ExtNested {}
diff --git a/test/SILGen/default_arguments_generic.swift b/test/SILGen/default_arguments_generic.swift
index f311f89..b2909f0 100644
--- a/test/SILGen/default_arguments_generic.swift
+++ b/test/SILGen/default_arguments_generic.swift
@@ -46,3 +46,20 @@
// CHECK: function_ref @_T025default_arguments_generic7GenericVACyxGxcfcfA_ : $@convention(thin) <τ_0_0 where τ_0_0 : Initializable> () -> @out τ_0_0
// CHECK: apply [[INIT]]<InitializableImpl>({{%.+}}, {{%.+}}) : $@convention(method) <τ_0_0 where τ_0_0 : Initializable> (@in τ_0_0, @thin Generic<τ_0_0>.Type) -> Generic<τ_0_0>
} // CHECK: end sil function '_T025default_arguments_generic17testInitializableyyF'
+
+// Local generic functions with default arguments
+
+// CHECK-LABEL: sil hidden @_T025default_arguments_generic5outeryx1t_tlF : $@convention(thin) <T> (@in T) -> ()
+func outer<T>(t: T) {
+ func inner1(x: Int = 0) {}
+
+ // CHECK: [[ARG_GENERATOR:%.*]] = function_ref @_T025default_arguments_generic5outeryx1t_tlF6inner1L_ySi1x_tlFfA_ : $@convention(thin) () -> Int
+ // CHECK: [[ARG:%.*]] = apply [[ARG_GENERATOR]]() : $@convention(thin) () -> Int
+ _ = inner1()
+
+ func inner2(x: Int = 0) { _ = T.self }
+
+ // CHECK: [[ARG_GENERATOR:%.*]] = function_ref @_T025default_arguments_generic5outeryx1t_tlF6inner2L_ySi1x_tlFfA_ : $@convention(thin) <τ_0_0> () -> Int
+ // CHECK: [[ARG:%.*]] = apply [[ARG_GENERATOR]]<T>() : $@convention(thin) <τ_0_0> () -> Int
+ _ = inner2()
+}
diff --git a/test/SILGen/vtables.swift b/test/SILGen/vtables.swift
index dfc100b..1843557 100644
--- a/test/SILGen/vtables.swift
+++ b/test/SILGen/vtables.swift
@@ -1,11 +1,4 @@
-// RUN: %target-swift-frontend -sdk %S/Inputs -emit-silgen -I %S/Inputs -enable-source-import %s -disable-objc-attr-requires-foundation-module | %FileCheck %s
-
-// FIXME: rdar://problem/19648117 Needs splitting objc parts out
-// XFAIL: linux
-
-import gizmo
-
-// TODO: Generic base classes
+// RUN: %target-swift-frontend -emit-silgen %s | %FileCheck %s
// Test for compilation order independence
class C : B {
@@ -73,64 +66,6 @@
// CHECK: #B.zang!1: {{.*}} : _T07vtables1BC4zang{{[_0-9a-zA-Z]*}}F
// CHECK: }
-// Test ObjC base class
-
-class Hoozit : Gizmo {
- // Overrides Gizmo.frob
- override func frob() {}
- // Overrides Gizmo.funge
- override func funge() {}
-
- func anse() {}
- func incorrige() {}
-}
-
-// Entries only exist for native Swift methods
-
-// CHECK: sil_vtable Hoozit {
-// CHECK-NEXT: #Hoozit.anse!1: {{.*}} : _T07vtables6HoozitC4anse{{[_0-9a-zA-Z]*}}F
-// CHECK-NEXT: #Hoozit.incorrige!1: {{.*}} : _T07vtables6HoozitC9incorrige{{[_0-9a-zA-Z]*}}F
-// CHECK-NEXT: #Hoozit.init!initializer.1: (Hoozit.Type) -> () -> Hoozit! : _T07vtables6HoozitCSQyACGycfc
-// CHECK-NEXT: #Hoozit.init!initializer.1: (Hoozit.Type) -> (Int) -> Hoozit! : _T07vtables6HoozitCSQyACGSi7bellsOn_tcfc
-// CHECK-NEXT: #Hoozit.deinit!deallocator: _T07vtables6HoozitCfD
-// CHECK-NEXT: }
-
-class Wotsit : Hoozit {
- override func funge() {}
- override func incorrige() {}
-}
-
-// CHECK: sil_vtable Wotsit {
-// CHECK-NEXT: #Hoozit.anse!1: {{.*}} : _T07vtables6HoozitC4anse{{[_0-9a-zA-Z]*}}F
-// CHECK-NEXT: #Hoozit.incorrige!1: {{.*}} : _T07vtables6WotsitC9incorrige{{[_0-9a-zA-Z]*}}F
-// CHECK-NEXT: #Hoozit.init!initializer.1: (Hoozit.Type) -> () -> Hoozit! : _T07vtables6WotsitCSQyACGycfc
-// CHECK-NEXT: #Hoozit.init!initializer.1: (Hoozit.Type) -> (Int) -> Hoozit! : _T07vtables6WotsitCSQyACGSi7bellsOn_tcfc
-// CHECK-NEXT: #Wotsit.deinit!deallocator: _T07vtables6WotsitCfD
-// CHECK-NEXT: }
-
-// <rdar://problem/15282548>
-// CHECK: sil_vtable Base {
-// CHECK: #Base.init!initializer.1: {{.*}} : _T07vtables4BaseC{{[_0-9a-zA-Z]*}}fc
-// CHECK: }
-// CHECK: sil_vtable Derived {
-// CHECK: #Base.init!initializer.1: {{.*}} : _T07vtables7DerivedC{{[_0-9a-zA-Z]*}}fc
-// CHECK: }
-@objc class Base {}
-
-extension Base {
- // note: does not have a vtable slot, because it is from an extension
- func identify() -> Int {
- return 0
- }
-}
-
-class Derived : Base {
- override func identify() -> Int {
- return 1
- }
-}
-
-
// CHECK: sil_vtable RequiredInitDerived {
// CHECK-NEXT: #SimpleInitBase.init!initializer.1: {{.*}} : _T07vtables19RequiredInitDerivedC{{[_0-9a-zA-Z]*}}fc
// CHECK-NEXT #RequiredInitDerived.init!allocator.1: {{.*}} : _TFC7vtables19RequiredInitDerivedC
diff --git a/test/SILGen/vtables_objc.swift b/test/SILGen/vtables_objc.swift
new file mode 100644
index 0000000..89b9c3e
--- /dev/null
+++ b/test/SILGen/vtables_objc.swift
@@ -0,0 +1,94 @@
+// RUN: %target-swift-frontend -sdk %S/Inputs -emit-silgen -I %S/Inputs -enable-source-import %s -disable-objc-attr-requires-foundation-module | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+import gizmo
+
+// Test ObjC base class
+
+class Hoozit : Gizmo {
+ // Overrides Gizmo.frob
+ override func frob() {}
+
+ // Overrides Gizmo.funge
+ override func funge() {}
+
+ // Overrides Gizmo.foo
+ final override func foo() {}
+
+ func anse() {}
+ func incorrige() {}
+}
+
+// CHECK-LABEL: sil hidden @_T012vtables_objc10callHoozityAA0D0CF : $@convention(thin) (@owned Hoozit) -> ()
+func callHoozit(_ h: Hoozit) {
+ // CHECK: class_method [volatile] {{.*}} : $Hoozit, #Hoozit.frob!1.foreign
+ h.frob()
+ // CHECK: function_ref @_T012vtables_objc6HoozitC3fooyyF
+ h.foo()
+ // CHECK: class_method {{.*}} : $Hoozit, #Hoozit.anse!1
+ h.anse()
+ // CHECK: return
+}
+
+class Wotsit : Hoozit {
+ // Overrides Gizmo.funge
+ override func funge() {}
+
+ // Overrides Hoozit.incorrige
+ override func incorrige() {}
+
+ // Overrides Gizmo.frob
+ final override func frob() {}
+}
+
+// CHECK-LABEL: sil hidden @_T012vtables_objc10callWotsityAA0D0CF : $@convention(thin) (@owned Wotsit) -> ()
+func callWotsit(_ w: Wotsit) {
+ // CHECK: class_method [volatile] {{.*}} : $Wotsit, #Wotsit.funge!1.foreign
+ w.funge()
+ // CHECK: class_method {{.*}} : $Wotsit, #Wotsit.incorrige!1
+ w.incorrige()
+ // CHECK: function_ref @_T012vtables_objc6WotsitC4frobyyF
+ w.frob()
+ // CHECK: return
+}
+
+// Entries only exist for native Swift methods
+
+// CHECK: sil_vtable Hoozit {
+// CHECK-NEXT: #Hoozit.anse!1: {{.*}} : _T012vtables_objc6HoozitC4anse{{[_0-9a-zA-Z]*}}F
+// CHECK-NEXT: #Hoozit.incorrige!1: {{.*}} : _T012vtables_objc6HoozitC9incorrige{{[_0-9a-zA-Z]*}}F
+// CHECK-NEXT: #Hoozit.init!initializer.1: (Hoozit.Type) -> () -> Hoozit! : _T012vtables_objc6HoozitCSQyACGycfc
+// CHECK-NEXT: #Hoozit.init!initializer.1: (Hoozit.Type) -> (Int) -> Hoozit! : _T012vtables_objc6HoozitCSQyACGSi7bellsOn_tcfc
+// CHECK-NEXT: #Hoozit.deinit!deallocator: _T012vtables_objc6HoozitCfD
+// CHECK-NEXT: }
+
+// CHECK: sil_vtable Wotsit {
+// CHECK-NEXT: #Hoozit.anse!1: {{.*}} : _T012vtables_objc6HoozitC4anse{{[_0-9a-zA-Z]*}}F
+// CHECK-NEXT: #Hoozit.incorrige!1: {{.*}} : _T012vtables_objc6WotsitC9incorrige{{[_0-9a-zA-Z]*}}F
+// CHECK-NEXT: #Hoozit.init!initializer.1: (Hoozit.Type) -> () -> Hoozit! : _T012vtables_objc6WotsitCSQyACGycfc
+// CHECK-NEXT: #Hoozit.init!initializer.1: (Hoozit.Type) -> (Int) -> Hoozit! : _T012vtables_objc6WotsitCSQyACGSi7bellsOn_tcfc
+// CHECK-NEXT: #Wotsit.deinit!deallocator: _T012vtables_objc6WotsitCfD
+// CHECK-NEXT: }
+
+// <rdar://problem/15282548>
+// CHECK: sil_vtable Base {
+// CHECK: #Base.init!initializer.1: {{.*}} : _T012vtables_objc4BaseC{{[_0-9a-zA-Z]*}}fc
+// CHECK: }
+// CHECK: sil_vtable Derived {
+// CHECK: #Base.init!initializer.1: {{.*}} : _T012vtables_objc7DerivedC{{[_0-9a-zA-Z]*}}fc
+// CHECK: }
+@objc class Base {}
+
+extension Base {
+ // note: does not have a vtable slot, because it is from an extension
+ func identify() -> Int {
+ return 0
+ }
+}
+
+class Derived : Base {
+ override func identify() -> Int {
+ return 1
+ }
+}
diff --git a/test/SILOptimizer/escape_analysis.sil b/test/SILOptimizer/escape_analysis.sil
index e86fdfb..165a88f 100644
--- a/test/SILOptimizer/escape_analysis.sil
+++ b/test/SILOptimizer/escape_analysis.sil
@@ -1430,6 +1430,17 @@
return %8 : $()
}
+// CHECK-LABEL: CG of check_look_through_thin_to_thick
+// CHECK-NEXT: Arg %0 Esc: A, Succ:
+// CHECK-NEXT: End
+sil @check_look_through_thin_to_thick: $(@convention(thin) () -> ()) -> () {
+bb0(%0 : $@convention(thin) () -> ()):
+ %1 = thin_to_thick_function %0 : $@convention(thin) () -> () to $@callee_owned () -> ()
+ %2 = apply %1() : $@callee_owned () -> ()
+ %3 = tuple ()
+ return %3 : $()
+}
+
// X.deinit
// CHECK-LABEL: CG of _T04main1XCfD
// CHECK: Arg %0 Esc: A, Succ:
diff --git a/test/SILOptimizer/simplify_cfg_jump_thread_crash.sil b/test/SILOptimizer/simplify_cfg_jump_thread_crash.sil
index d9c7a68..c38ac1d 100644
--- a/test/SILOptimizer/simplify_cfg_jump_thread_crash.sil
+++ b/test/SILOptimizer/simplify_cfg_jump_thread_crash.sil
@@ -107,3 +107,51 @@
return %65 : $()
}
+sil @some_function : $@convention(thin) (AA) -> Optional<AA>
+
+// Another test for checking that SimplifyCFG does not hang.
+// CHECK-LABEL: test_other_infinite_loop
+sil hidden @test_other_infinite_loop : $@convention(method) (@owned AA) -> () {
+bb0(%5 : $AA):
+ strong_retain %5 : $AA
+ %6 = enum $Optional<AA>, #Optional.some!enumelt.1, %5 : $AA
+ br bb1(%6 : $Optional<AA>)
+
+bb1(%8 : $Optional<AA>):
+ retain_value %8 : $Optional<AA>
+ switch_enum %8 : $Optional<AA>, case #Optional.some!enumelt.1: bb3, default bb2
+
+bb2:
+ release_value %8 : $Optional<AA>
+ br bb6
+
+bb3:
+ cond_br undef, bb4, bb5
+
+bb4:
+ %85 = tuple ()
+ return %85 : $()
+
+bb5:
+ br bb6
+
+bb6:
+ switch_enum %8 : $Optional<AA>, case #Optional.none!enumelt: bb7, default bb8
+
+bb7:
+ br bb9(%8 : $Optional<AA>)
+
+bb8:
+ %23 = unchecked_enum_data %8 : $Optional<AA>, #Optional.some!enumelt.1
+ strong_retain %23 : $AA
+ %25 = function_ref @some_function : $@convention(thin) (AA) -> Optional<AA>
+ %26 = apply %25(%23) : $@convention(thin) (AA) -> Optional<AA>
+ strong_release %23 : $AA
+ br bb9(%26 : $Optional<AA>)
+
+bb9(%29 : $Optional<AA>):
+ release_value %8 : $Optional<AA>
+ br bb1(%29 : $Optional<AA>)
+
+}
+
diff --git a/test/stdlib/Inputs/SwiftObjectNSObject/SwiftObjectNSObject.m b/test/stdlib/Inputs/SwiftObjectNSObject/SwiftObjectNSObject.m
index a99fd9e..170ee43 100644
--- a/test/stdlib/Inputs/SwiftObjectNSObject/SwiftObjectNSObject.m
+++ b/test/stdlib/Inputs/SwiftObjectNSObject/SwiftObjectNSObject.m
@@ -405,6 +405,12 @@
expectTrue ([[C_meta description] isEqual:@"SwiftObjectNSObject.C"]);
expectTrue ([[S_meta description] isEqual:@"SwiftObject"]);
+ // NSLog() calls -description and also some private methods.
+ // This output is checked by FileCheck in SwiftObjectNSObject.swift.
+ NSLog(@"c ##%@##", c);
+ NSLog(@"d ##%@##", d);
+ NSLog(@"S ##%@##", S);
+
printf("NSObjectProtocol.debugDescription\n");
diff --git a/test/stdlib/SwiftObjectNSObject.swift b/test/stdlib/SwiftObjectNSObject.swift
index 56f348f..24680a8 100644
--- a/test/stdlib/SwiftObjectNSObject.swift
+++ b/test/stdlib/SwiftObjectNSObject.swift
@@ -14,7 +14,7 @@
//
// RUN: %target-clang %S/Inputs/SwiftObjectNSObject/SwiftObjectNSObject.m -c -o %t/SwiftObjectNSObject.o -g
// RUN: %target-build-swift %s -I %S/Inputs/SwiftObjectNSObject/ -Xlinker %t/SwiftObjectNSObject.o -o %t/SwiftObjectNSObject
-// RUN: %target-run %t/SwiftObjectNSObject
+// RUN: %target-run %t/SwiftObjectNSObject 2>&1 | %FileCheck %s
// REQUIRES: executable_test
// REQUIRES: objc_interop
@@ -34,5 +34,10 @@
@_silgen_name("TestSwiftObjectNSObject")
func TestSwiftObjectNSObject(_ c: C, _ d: D)
+// This check is for NSLog() output from TestSwiftObjectNSObject().
+// CHECK: c ##SwiftObjectNSObject.C##
+// CHECK-NEXT: d ##SwiftObjectNSObject.D##
+// CHECK-NEXT: S ##SwiftObject##
+
TestSwiftObjectNSObject(C(), D())
// does not return
diff --git a/test/stdlib/TestData.swift b/test/stdlib/TestData.swift
index f2addf1..f58df85 100644
--- a/test/stdlib/TestData.swift
+++ b/test/stdlib/TestData.swift
@@ -31,7 +31,71 @@
class TestData : TestDataSuper {
- // This is a type of Data that starts off as a storage of all 0x01s, but it only creates that buffer when needed. When mutated it converts into a more traditional data storage backed by a buffer.
+ class AllOnesImmutableData : NSData {
+ private var _length : Int
+ var _pointer : UnsafeMutableBufferPointer<UInt8>? {
+ willSet {
+ if let p = _pointer { free(p.baseAddress) }
+ }
+ }
+
+ init(length : Int) {
+ _length = length
+ super.init()
+ }
+
+ required init?(coder aDecoder: NSCoder) {
+ // Not tested
+ fatalError()
+ }
+
+ deinit {
+ if let p = _pointer {
+ free(p.baseAddress)
+ }
+ }
+
+ override var length : Int {
+ get {
+ return _length
+ }
+ }
+
+ override var bytes : UnsafeRawPointer {
+ if let d = _pointer {
+ return UnsafeRawPointer(d.baseAddress!)
+ } else {
+ // Need to allocate the buffer now.
+ // It doesn't matter if the buffer is uniquely referenced or not here.
+ let buffer = malloc(length)
+ memset(buffer, 1, length)
+ let bytePtr = buffer!.bindMemory(to: UInt8.self, capacity: length)
+ let result = UnsafeMutableBufferPointer(start: bytePtr, count: length)
+ _pointer = result
+ return UnsafeRawPointer(result.baseAddress!)
+ }
+ }
+
+ override func getBytes(_ buffer: UnsafeMutableRawPointer, length: Int) {
+ if let d = _pointer {
+ // Get the real data from the buffer
+ memmove(buffer, d.baseAddress, length)
+ } else {
+ // A more efficient implementation of getBytes in the case where no one has asked for our backing bytes
+ memset(buffer, 1, length)
+ }
+ }
+
+ override func copy(with zone: NSZone? = nil) -> Any {
+ return self
+ }
+
+ override func mutableCopy(with zone: NSZone? = nil) -> Any {
+ return AllOnesData(length: _length)
+ }
+ }
+
+
class AllOnesData : NSMutableData {
private var _length : Int
@@ -73,9 +137,8 @@
}
let bytePtr = newBuffer.bindMemory(to: UInt8.self, capacity: newValue)
_pointer = UnsafeMutableBufferPointer(start: bytePtr, count: newValue)
- } else {
- _length = newValue
}
+ _length = newValue
}
}
@@ -122,6 +185,15 @@
}
}
+ var heldData: Data?
+
+ // this holds a reference while applying the function which forces the internal ref type to become non-uniquely referenced
+ func holdReference(_ data: Data, apply: () -> Void) {
+ heldData = data
+ apply()
+ heldData = nil
+ }
+
// MARK: -
// String of course has its own way to get data, but this way tests our own data struct
@@ -1208,6 +1280,2382 @@
data.replaceSubrange(4 ..< 4, with: Data(bytes: []))
expectEqual(expected, data.count)
}
+
+ func test_validateMutation_withUnsafeMutableBytes() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+ data.withUnsafeMutableBytes { (ptr: UnsafeMutablePointer<UInt8>) in
+ ptr.advanced(by: 5).pointee = 0xFF
+ }
+ expectEqual(data, Data(bytes: [0, 1, 2, 3, 4, 0xFF, 6, 7, 8, 9]))
+ }
+
+ func test_validateMutation_appendBytes() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+ data.append("hello", count: 5)
+ expectEqual(data[data.startIndex.advanced(by: 5)], 0x5)
+ }
+
+ func test_validateMutation_appendData() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+ let other = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+ data.append(other)
+ expectEqual(data[data.startIndex.advanced(by: 9)], 9)
+ expectEqual(data[data.startIndex.advanced(by: 10)], 0)
+ }
+
+ func test_validateMutation_appendBuffer() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+ let bytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ bytes.withUnsafeBufferPointer { data.append($0) }
+ expectEqual(data[data.startIndex.advanced(by: 9)], 9)
+ expectEqual(data[data.startIndex.advanced(by: 10)], 0)
+ }
+
+ func test_validateMutation_appendSequence() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+ let seq = repeatElement(UInt8(1), count: 10)
+ data.append(contentsOf: seq)
+ expectEqual(data[data.startIndex.advanced(by: 9)], 9)
+ expectEqual(data[data.startIndex.advanced(by: 10)], 1)
+ }
+
+ func test_validateMutation_appendContentsOf() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+ let bytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ data.append(contentsOf: bytes)
+ expectEqual(data[data.startIndex.advanced(by: 9)], 9)
+ expectEqual(data[data.startIndex.advanced(by: 10)], 0)
+ }
+
+ func test_validateMutation_resetBytes() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+ data.resetBytes(in: 5..<8)
+ expectEqual(data, Data(bytes: [0, 1, 2, 3, 4, 0, 0, 0, 8, 9]))
+ }
+
+ func test_validateMutation_replaceSubrange() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 4)..<data.startIndex.advanced(by: 9)
+ let replacement = Data(bytes: [0xFF, 0xFF])
+ data.replaceSubrange(range, with: replacement)
+ expectEqual(data, Data(bytes: [0, 1, 2, 3, 0xFF, 0xFF, 9]))
+ }
+
+ func test_validateMutation_replaceSubrangeCountableRange() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+ let range: CountableRange<Data.Index> = data.startIndex.advanced(by: 4)..<data.startIndex.advanced(by: 9)
+ let replacement = Data(bytes: [0xFF, 0xFF])
+ data.replaceSubrange(range, with: replacement)
+ expectEqual(data, Data(bytes: [0, 1, 2, 3, 0xFF, 0xFF, 9]))
+ }
+
+ func test_validateMutation_replaceSubrangeWithBuffer() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 4)..<data.startIndex.advanced(by: 9)
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer {
+ data.replaceSubrange(range, with: $0)
+ }
+ expectEqual(data, Data(bytes: [0, 1, 2, 3, 0xFF, 0xFF, 9]))
+ }
+
+ func test_validateMutation_replaceSubrangeWithCollection() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 4)..<data.startIndex.advanced(by: 9)
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ data.replaceSubrange(range, with: bytes)
+ expectEqual(data, Data(bytes: [0, 1, 2, 3, 0xFF, 0xFF, 9]))
+ }
+
+ func test_validateMutation_replaceSubrangeWithBytes() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 4)..<data.startIndex.advanced(by: 9)
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBytes {
+ data.replaceSubrange(range, with: $0.baseAddress!, count: 2)
+ }
+ expectEqual(data, Data(bytes: [0, 1, 2, 3, 0xFF, 0xFF, 9]))
+ }
+
+ func test_validateMutation_slice_withUnsafeMutableBytes() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])[4..<9]
+ data.withUnsafeMutableBytes { (ptr: UnsafeMutablePointer<UInt8>) in
+ ptr.advanced(by: 1).pointee = 0xFF
+ }
+ expectEqual(data, Data(bytes: [4, 0xFF, 6, 7, 8]))
+ }
+
+ func test_validateMutation_slice_appendBytes() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])[4..<9]
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer { data.append($0.baseAddress!, count: $0.count) }
+ expectEqual(data, Data(bytes: [4, 5, 6, 7, 8, 0xFF, 0xFF]))
+ }
+
+ func test_validateMutation_slice_appendData() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])[4..<9]
+ let other = Data(bytes: [0xFF, 0xFF])
+ data.append(other)
+ expectEqual(data, Data(bytes: [4, 5, 6, 7, 8, 0xFF, 0xFF]))
+ }
+
+ func test_validateMutation_slice_appendBuffer() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])[4..<9]
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer { data.append($0) }
+ expectEqual(data, Data(bytes: [4, 5, 6, 7, 8, 0xFF, 0xFF]))
+ }
+
+ func test_validateMutation_slice_appendSequence() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])[4..<9]
+ let seq = repeatElement(UInt8(0xFF), count: 2)
+ data.append(contentsOf: seq)
+ expectEqual(data, Data(bytes: [4, 5, 6, 7, 8, 0xFF, 0xFF]))
+ }
+
+ func test_validateMutation_slice_appendContentsOf() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])[4..<9]
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ data.append(contentsOf: bytes)
+ expectEqual(data, Data(bytes: [4, 5, 6, 7, 8, 0xFF, 0xFF]))
+ }
+
+ func test_validateMutation_slice_resetBytes() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])[4..<9]
+ data.resetBytes(in: 5..<8)
+ expectEqual(data, Data(bytes: [4, 0, 0, 0, 8]))
+ }
+
+ func test_validateMutation_slice_replaceSubrange() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])[4..<9]
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ let replacement = Data(bytes: [0xFF, 0xFF])
+ data.replaceSubrange(range, with: replacement)
+ expectEqual(data, Data(bytes: [4, 0xFF, 0xFF, 8]))
+ }
+
+ func test_validateMutation_slice_replaceSubrangeCountableRange() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])[4..<9]
+ let range: CountableRange<Data.Index> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ let replacement = Data(bytes: [0xFF, 0xFF])
+ data.replaceSubrange(range, with: replacement)
+ expectEqual(data, Data(bytes: [4, 0xFF, 0xFF, 8]))
+ }
+
+ func test_validateMutation_slice_replaceSubrangeWithBuffer() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])[4..<9]
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer {
+ data.replaceSubrange(range, with: $0)
+ }
+ expectEqual(data, Data(bytes: [4, 0xFF, 0xFF, 8]))
+ }
+
+ func test_validateMutation_slice_replaceSubrangeWithCollection() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])[4..<9]
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ data.replaceSubrange(range, with: bytes)
+ expectEqual(data, Data(bytes: [4, 0xFF, 0xFF, 8]))
+ }
+
+ func test_validateMutation_slice_replaceSubrangeWithBytes() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])[4..<9]
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBytes {
+ data.replaceSubrange(range, with: $0.baseAddress!, count: 2)
+ }
+ expectEqual(data, Data(bytes: [4, 0xFF, 0xFF, 8]))
+ }
+
+ func test_validateMutation_cow_withUnsafeMutableBytes() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+ holdReference(data) {
+ data.withUnsafeMutableBytes { (ptr: UnsafeMutablePointer<UInt8>) in
+ ptr.advanced(by: 5).pointee = 0xFF
+ }
+ expectEqual(data, Data(bytes: [0, 1, 2, 3, 4, 0xFF, 6, 7, 8, 9]))
+ }
+ }
+
+ func test_validateMutation_cow_appendBytes() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+ holdReference(data) {
+ data.append("hello", count: 5)
+ expectEqual(data[data.startIndex.advanced(by: 9)], 0x9)
+ expectEqual(data[data.startIndex.advanced(by: 10)], 0x68)
+ }
+ }
+
+ func test_validateMutation_cow_appendData() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+ holdReference(data) {
+ let other = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+ data.append(other)
+ expectEqual(data[data.startIndex.advanced(by: 9)], 9)
+ expectEqual(data[data.startIndex.advanced(by: 10)], 0)
+ }
+ }
+
+ func test_validateMutation_cow_appendBuffer() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+ holdReference(data) {
+ let bytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ bytes.withUnsafeBufferPointer { data.append($0) }
+ expectEqual(data[data.startIndex.advanced(by: 9)], 9)
+ expectEqual(data[data.startIndex.advanced(by: 10)], 0)
+ }
+ }
+
+ func test_validateMutation_cow_appendSequence() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+ holdReference(data) {
+ let seq = repeatElement(UInt8(1), count: 10)
+ data.append(contentsOf: seq)
+ expectEqual(data[data.startIndex.advanced(by: 9)], 9)
+ expectEqual(data[data.startIndex.advanced(by: 10)], 1)
+ }
+ }
+
+ func test_validateMutation_cow_appendContentsOf() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+ holdReference(data) {
+ let bytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ data.append(contentsOf: bytes)
+ expectEqual(data[data.startIndex.advanced(by: 9)], 9)
+ expectEqual(data[data.startIndex.advanced(by: 10)], 0)
+ }
+ }
+
+ func test_validateMutation_cow_resetBytes() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+ holdReference(data) {
+ data.resetBytes(in: 5..<8)
+ expectEqual(data, Data(bytes: [0, 1, 2, 3, 4, 0, 0, 0, 8, 9]))
+ }
+ }
+
+ func test_validateMutation_cow_replaceSubrange() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+ holdReference(data) {
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 4)..<data.startIndex.advanced(by: 9)
+ let replacement = Data(bytes: [0xFF, 0xFF])
+ data.replaceSubrange(range, with: replacement)
+ expectEqual(data, Data(bytes: [0, 1, 2, 3, 0xFF, 0xFF, 9]))
+ }
+ }
+
+ func test_validateMutation_cow_replaceSubrangeCountableRange() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+ holdReference(data) {
+ let range: CountableRange<Data.Index> = data.startIndex.advanced(by: 4)..<data.startIndex.advanced(by: 9)
+ let replacement = Data(bytes: [0xFF, 0xFF])
+ data.replaceSubrange(range, with: replacement)
+ expectEqual(data, Data(bytes: [0, 1, 2, 3, 0xFF, 0xFF, 9]))
+ }
+ }
+
+ func test_validateMutation_cow_replaceSubrangeWithBuffer() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+ holdReference(data) {
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 4)..<data.startIndex.advanced(by: 9)
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer {
+ data.replaceSubrange(range, with: $0)
+ }
+ expectEqual(data, Data(bytes: [0, 1, 2, 3, 0xFF, 0xFF, 9]))
+ }
+ }
+
+ func test_validateMutation_cow_replaceSubrangeWithCollection() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+ holdReference(data) {
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 4)..<data.startIndex.advanced(by: 9)
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ data.replaceSubrange(range, with: bytes)
+ expectEqual(data, Data(bytes: [0, 1, 2, 3, 0xFF, 0xFF, 9]))
+ }
+ }
+
+ func test_validateMutation_cow_replaceSubrangeWithBytes() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+ holdReference(data) {
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 4)..<data.startIndex.advanced(by: 9)
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBytes {
+ data.replaceSubrange(range, with: $0.baseAddress!, count: 2)
+ }
+ expectEqual(data, Data(bytes: [0, 1, 2, 3, 0xFF, 0xFF, 9]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_withUnsafeMutableBytes() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])[4..<9]
+ holdReference(data) {
+ data.withUnsafeMutableBytes { (ptr: UnsafeMutablePointer<UInt8>) in
+ ptr.advanced(by: 1).pointee = 0xFF
+ }
+ expectEqual(data, Data(bytes: [4, 0xFF, 6, 7, 8]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_appendBytes() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])[4..<9]
+ holdReference(data) {
+ data.append("hello", count: 5)
+ expectEqual(data[data.startIndex.advanced(by: 4)], 0x8)
+ expectEqual(data[data.startIndex.advanced(by: 5)], 0x68)
+ }
+ }
+
+ func test_validateMutation_slice_cow_appendData() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])[4..<9]
+ holdReference(data) {
+ let other = Data(bytes: [0xFF, 0xFF])
+ data.append(other)
+ expectEqual(data, Data(bytes: [4, 5, 6, 7, 8, 0xFF, 0xFF]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_appendBuffer() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])[4..<9]
+ holdReference(data) {
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer { data.append($0) }
+ expectEqual(data, Data(bytes: [4, 5, 6, 7, 8, 0xFF, 0xFF]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_appendSequence() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])[4..<9]
+ holdReference(data) {
+ let seq = repeatElement(UInt8(0xFF), count: 2)
+ data.append(contentsOf: seq)
+ expectEqual(data, Data(bytes: [4, 5, 6, 7, 8, 0xFF, 0xFF]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_appendContentsOf() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])[4..<9]
+ holdReference(data) {
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ data.append(contentsOf: bytes)
+ expectEqual(data, Data(bytes: [4, 5, 6, 7, 8, 0xFF, 0xFF]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_resetBytes() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])[4..<9]
+ holdReference(data) {
+ data.resetBytes(in: 5..<8)
+ expectEqual(data, Data(bytes: [4, 0, 0, 0, 8]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_replaceSubrange() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])[4..<9]
+ holdReference(data) {
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ let replacement = Data(bytes: [0xFF, 0xFF])
+ data.replaceSubrange(range, with: replacement)
+ expectEqual(data, Data(bytes: [4, 0xFF, 0xFF, 8]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_replaceSubrangeCountableRange() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])[4..<9]
+ holdReference(data) {
+ let range: CountableRange<Data.Index> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ let replacement = Data(bytes: [0xFF, 0xFF])
+ data.replaceSubrange(range, with: replacement)
+ expectEqual(data, Data(bytes: [4, 0xFF, 0xFF, 8]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_replaceSubrangeWithBuffer() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])[4..<9]
+ holdReference(data) {
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer {
+ data.replaceSubrange(range, with: $0)
+ }
+ expectEqual(data, Data(bytes: [4, 0xFF, 0xFF, 8]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_replaceSubrangeWithCollection() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])[4..<9]
+ holdReference(data) {
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ data.replaceSubrange(range, with: bytes)
+ expectEqual(data, Data(bytes: [4, 0xFF, 0xFF, 8]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_replaceSubrangeWithBytes() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])[4..<9]
+ holdReference(data) {
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBytes {
+ data.replaceSubrange(range, with: $0.baseAddress!, count: 2)
+ }
+ expectEqual(data, Data(bytes: [4, 0xFF, 0xFF, 8]))
+ }
+ }
+
+ func test_validateMutation_immutableBacking_withUnsafeMutableBytes() {
+ var data = NSData(bytes: "hello world", length: 11) as Data
+ data.withUnsafeMutableBytes { (ptr: UnsafeMutablePointer<UInt8>) in
+ ptr.advanced(by: 5).pointee = 0xFF
+ }
+ expectEqual(data[data.startIndex.advanced(by: 5)], 0xFF)
+ }
+
+ func test_validateMutation_immutableBacking_appendBytes() {
+ var data = NSData(bytes: "hello world", length: 11) as Data
+ data.append("hello", count: 5)
+ expectEqual(data[data.startIndex.advanced(by: 10)], 0x64)
+ expectEqual(data[data.startIndex.advanced(by: 11)], 0x68)
+ }
+
+ func test_validateMutation_immutableBacking_appendData() {
+ var data = NSData(bytes: "hello world", length: 11) as Data
+ let other = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+ data.append(other)
+ expectEqual(data[data.startIndex.advanced(by: 10)], 0x64)
+ expectEqual(data[data.startIndex.advanced(by: 11)], 0)
+ }
+
+ func test_validateMutation_immutableBacking_appendBuffer() {
+ var data = NSData(bytes: "hello world", length: 11) as Data
+ let bytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ bytes.withUnsafeBufferPointer { data.append($0) }
+ expectEqual(data[data.startIndex.advanced(by: 10)], 0x64)
+ expectEqual(data[data.startIndex.advanced(by: 11)], 0)
+ }
+
+ func test_validateMutation_immutableBacking_appendSequence() {
+ var data = NSData(bytes: "hello world", length: 11) as Data
+ let seq = repeatElement(UInt8(1), count: 10)
+ data.append(contentsOf: seq)
+ expectEqual(data[data.startIndex.advanced(by: 10)], 0x64)
+ expectEqual(data[data.startIndex.advanced(by: 11)], 1)
+ }
+
+ func test_validateMutation_immutableBacking_appendContentsOf() {
+ var data = NSData(bytes: "hello world", length: 11) as Data
+ let bytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ data.append(contentsOf: bytes)
+ expectEqual(data[data.startIndex.advanced(by: 10)], 0x64)
+ expectEqual(data[data.startIndex.advanced(by: 11)], 0)
+ }
+
+ func test_validateMutation_immutableBacking_resetBytes() {
+ var data = NSData(bytes: "hello world", length: 11) as Data
+ data.resetBytes(in: 5..<8)
+ expectEqual(data, Data(bytes: [0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x00, 0x00, 0x72, 0x6c, 0x64]))
+ }
+
+ func test_validateMutation_immutableBacking_replaceSubrange() {
+ var data = NSData(bytes: "hello world", length: 11) as Data
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 4)..<data.startIndex.advanced(by: 9)
+ let replacement = Data(bytes: [0xFF, 0xFF])
+ data.replaceSubrange(range, with: replacement)
+ expectEqual(data, Data(bytes: [0x68, 0x65, 0x6c, 0x6c, 0xFF, 0xFF, 0x6c, 0x64]))
+ }
+
+ func test_validateMutation_immutableBacking_replaceSubrangeCountableRange() {
+ var data = NSData(bytes: "hello world", length: 11) as Data
+ let range: CountableRange<Data.Index> = data.startIndex.advanced(by: 4)..<data.startIndex.advanced(by: 9)
+ let replacement = Data(bytes: [0xFF, 0xFF])
+ data.replaceSubrange(range, with: replacement)
+ expectEqual(data, Data(bytes: [0x68, 0x65, 0x6c, 0x6c, 0xFF, 0xFF, 0x6c, 0x64]))
+ }
+
+ func test_validateMutation_immutableBacking_replaceSubrangeWithBuffer() {
+ var data = NSData(bytes: "hello world", length: 11) as Data
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 4)..<data.startIndex.advanced(by: 9)
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer {
+ data.replaceSubrange(range, with: $0)
+ }
+ expectEqual(data, Data(bytes: [0x68, 0x65, 0x6c, 0x6c, 0xFF, 0xFF, 0x6c, 0x64]))
+ }
+
+ func test_validateMutation_immutableBacking_replaceSubrangeWithCollection() {
+ var data = NSData(bytes: "hello world", length: 11) as Data
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 4)..<data.startIndex.advanced(by: 9)
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ data.replaceSubrange(range, with: bytes)
+ expectEqual(data, Data(bytes: [0x68, 0x65, 0x6c, 0x6c, 0xFF, 0xFF, 0x6c, 0x64]))
+ }
+
+ func test_validateMutation_immutableBacking_replaceSubrangeWithBytes() {
+ var data = NSData(bytes: "hello world", length: 11) as Data
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 4)..<data.startIndex.advanced(by: 9)
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ data.replaceSubrange(range, with: bytes)
+ expectEqual(data, Data(bytes: [0x68, 0x65, 0x6c, 0x6c, 0xFF, 0xFF, 0x6c, 0x64]))
+ }
+
+ func test_validateMutation_slice_immutableBacking_withUnsafeMutableBytes() {
+ var data = (NSData(bytes: "hello world", length: 11) as Data)[4..<9]
+ data.withUnsafeMutableBytes { (ptr: UnsafeMutablePointer<UInt8>) in
+ ptr.advanced(by: 1).pointee = 0xFF
+ }
+ expectEqual(data[data.startIndex.advanced(by: 1)], 0xFF)
+ }
+
+ func test_validateMutation_slice_immutableBacking_appendBytes() {
+ let base: [UInt8] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ var data = base.withUnsafeBufferPointer {
+ return (NSData(bytes: $0.baseAddress!, length: $0.count) as Data)[4..<9]
+ }
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer { data.append($0.baseAddress!, count: $0.count) }
+ expectEqual(data, Data(bytes: [4, 5, 6, 7, 8, 0xFF, 0xFF]))
+ }
+
+ func test_validateMutation_slice_immutableBacking_appendData() {
+ let base: [UInt8] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ var data = base.withUnsafeBufferPointer {
+ return (NSData(bytes: $0.baseAddress!, length: $0.count) as Data)[4..<9]
+ }
+ data.append(Data(bytes: [0xFF, 0xFF]))
+ expectEqual(data, Data(bytes: [4, 5, 6, 7, 8, 0xFF, 0xFF]))
+ }
+
+ func test_validateMutation_slice_immutableBacking_appendBuffer() {
+ let base: [UInt8] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ var data = base.withUnsafeBufferPointer {
+ return (NSData(bytes: $0.baseAddress!, length: $0.count) as Data)[4..<9]
+ }
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer { data.append($0) }
+ expectEqual(data, Data(bytes: [4, 5, 6, 7, 8, 0xFF, 0xFF]))
+ }
+
+ func test_validateMutation_slice_immutableBacking_appendSequence() {
+ let base: [UInt8] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ var data = base.withUnsafeBufferPointer {
+ return (NSData(bytes: $0.baseAddress!, length: $0.count) as Data)[4..<9]
+ }
+ data.append(contentsOf: repeatElement(UInt8(0xFF), count: 2))
+ expectEqual(data, Data(bytes: [4, 5, 6, 7, 8, 0xFF, 0xFF]))
+ }
+
+ func test_validateMutation_slice_immutableBacking_appendContentsOf() {
+ let base: [UInt8] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ var data = base.withUnsafeBufferPointer {
+ return (NSData(bytes: $0.baseAddress!, length: $0.count) as Data)[4..<9]
+ }
+ data.append(contentsOf: [0xFF, 0xFF])
+ expectEqual(data, Data(bytes: [4, 5, 6, 7, 8, 0xFF, 0xFF]))
+ }
+
+ func test_validateMutation_slice_immutableBacking_resetBytes() {
+ let base: [UInt8] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ var data = base.withUnsafeBufferPointer {
+ return (NSData(bytes: $0.baseAddress!, length: $0.count) as Data)[4..<9]
+ }
+ data.resetBytes(in: 5..<8)
+ expectEqual(data, Data(bytes: [4, 0, 0, 0, 8]))
+ }
+
+ func test_validateMutation_slice_immutableBacking_replaceSubrange() {
+ let base: [UInt8] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ var data = base.withUnsafeBufferPointer {
+ return (NSData(bytes: $0.baseAddress!, length: $0.count) as Data)[4..<9]
+ }
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ data.replaceSubrange(range, with: Data(bytes: [0xFF, 0xFF]))
+ expectEqual(data, Data(bytes: [4, 0xFF, 0xFF, 8]))
+ }
+
+ func test_validateMutation_slice_immutableBacking_replaceSubrangeCountableRange() {
+ let base: [UInt8] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ var data = base.withUnsafeBufferPointer {
+ return (NSData(bytes: $0.baseAddress!, length: $0.count) as Data)[4..<9]
+ }
+ let range: CountableRange<Data.Index> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ data.replaceSubrange(range, with: Data(bytes: [0xFF, 0xFF]))
+ expectEqual(data, Data(bytes: [4, 0xFF, 0xFF, 8]))
+ }
+
+ func test_validateMutation_slice_immutableBacking_replaceSubrangeWithBuffer() {
+ let base: [UInt8] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ var data = base.withUnsafeBufferPointer {
+ return (NSData(bytes: $0.baseAddress!, length: $0.count) as Data)[4..<9]
+ }
+ let replacement: [UInt8] = [0xFF, 0xFF]
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ replacement.withUnsafeBufferPointer { (buffer: UnsafeBufferPointer<UInt8>) in
+ data.replaceSubrange(range, with: buffer)
+ }
+ expectEqual(data, Data(bytes: [4, 0xFF, 0xFF, 8]))
+ }
+
+ func test_validateMutation_slice_immutableBacking_replaceSubrangeWithCollection() {
+ let base: [UInt8] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ var data = base.withUnsafeBufferPointer {
+ return (NSData(bytes: $0.baseAddress!, length: $0.count) as Data)[4..<9]
+ }
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ let replacement: [UInt8] = [0xFF, 0xFF]
+ data.replaceSubrange(range, with:replacement)
+ expectEqual(data, Data(bytes: [4, 0xFF, 0xFF, 8]))
+ }
+
+ func test_validateMutation_slice_immutableBacking_replaceSubrangeWithBytes() {
+ let base: [UInt8] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ var data = base.withUnsafeBufferPointer {
+ return (NSData(bytes: $0.baseAddress!, length: $0.count) as Data)[4..<9]
+ }
+ let replacement: [UInt8] = [0xFF, 0xFF]
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ replacement.withUnsafeBytes {
+ data.replaceSubrange(range, with: $0.baseAddress!, count: 2)
+ }
+ expectEqual(data, Data(bytes: [4, 0xFF, 0xFF, 8]))
+ }
+
+ func test_validateMutation_cow_immutableBacking_withUnsafeMutableBytes() {
+ var data = NSData(bytes: "hello world", length: 11) as Data
+ holdReference(data) {
+ data.withUnsafeMutableBytes { (ptr: UnsafeMutablePointer<UInt8>) in
+ ptr.advanced(by: 5).pointee = 0xFF
+ }
+ expectEqual(data[data.startIndex.advanced(by: 5)], 0xFF)
+ }
+ }
+
+ func test_validateMutation_cow_immutableBacking_appendBytes() {
+ var data = NSData(bytes: "hello world", length: 11) as Data
+ holdReference(data) {
+ data.append("hello", count: 5)
+ expectEqual(data[data.startIndex.advanced(by: 10)], 0x64)
+ expectEqual(data[data.startIndex.advanced(by: 11)], 0x68)
+ }
+ }
+
+ func test_validateMutation_cow_immutableBacking_appendData() {
+ var data = NSData(bytes: "hello world", length: 11) as Data
+ holdReference(data) {
+ let other = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+ data.append(other)
+ expectEqual(data[data.startIndex.advanced(by: 10)], 0x64)
+ expectEqual(data[data.startIndex.advanced(by: 11)], 0)
+ }
+ }
+
+ func test_validateMutation_cow_immutableBacking_appendBuffer() {
+ var data = NSData(bytes: "hello world", length: 11) as Data
+ holdReference(data) {
+ let bytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ bytes.withUnsafeBufferPointer { data.append($0) }
+ expectEqual(data[data.startIndex.advanced(by: 10)], 0x64)
+ expectEqual(data[data.startIndex.advanced(by: 11)], 0)
+ }
+ }
+
+ func test_validateMutation_cow_immutableBacking_appendSequence() {
+ var data = NSData(bytes: "hello world", length: 11) as Data
+ holdReference(data) {
+ let seq = repeatElement(UInt8(1), count: 10)
+ data.append(contentsOf: seq)
+ expectEqual(data[data.startIndex.advanced(by: 10)], 0x64)
+ expectEqual(data[data.startIndex.advanced(by: 11)], 1)
+ }
+ }
+
+ func test_validateMutation_cow_immutableBacking_appendContentsOf() {
+ var data = NSData(bytes: "hello world", length: 11) as Data
+ holdReference(data) {
+ let bytes: [UInt8] = [1, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ data.append(contentsOf: bytes)
+ expectEqual(data[data.startIndex.advanced(by: 10)], 0x64)
+ expectEqual(data[data.startIndex.advanced(by: 11)], 1)
+ }
+ }
+
+ func test_validateMutation_cow_immutableBacking_resetBytes() {
+ var data = NSData(bytes: "hello world", length: 11) as Data
+ holdReference(data) {
+ data.resetBytes(in: 5..<8)
+ expectEqual(data, Data(bytes: [0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x00, 0x00, 0x72, 0x6c, 0x64]))
+ }
+ }
+
+ func test_validateMutation_cow_immutableBacking_replaceSubrange() {
+ var data = NSData(bytes: "hello world", length: 11) as Data
+ holdReference(data) {
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 4)..<data.startIndex.advanced(by: 9)
+ let replacement = Data(bytes: [0xFF, 0xFF])
+ data.replaceSubrange(range, with: replacement)
+ expectEqual(data, Data(bytes: [0x68, 0x65, 0x6c, 0x6c, 0xff, 0xff, 0x6c, 0x64]))
+ }
+ }
+
+ func test_validateMutation_cow_immutableBacking_replaceSubrangeCountableRange() {
+ var data = NSData(bytes: "hello world", length: 11) as Data
+ holdReference(data) {
+ let range: CountableRange<Data.Index> = data.startIndex.advanced(by: 4)..<data.startIndex.advanced(by: 9)
+ let replacement = Data(bytes: [0xFF, 0xFF])
+ data.replaceSubrange(range, with: replacement)
+ expectEqual(data, Data(bytes: [0x68, 0x65, 0x6c, 0x6c, 0xff, 0xff, 0x6c, 0x64]))
+ }
+ }
+
+ func test_validateMutation_cow_immutableBacking_replaceSubrangeWithBuffer() {
+ var data = NSData(bytes: "hello world", length: 11) as Data
+ holdReference(data) {
+ let replacement: [UInt8] = [0xFF, 0xFF]
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ replacement.withUnsafeBufferPointer { (buffer: UnsafeBufferPointer<UInt8>) in
+ data.replaceSubrange(range, with: buffer)
+ }
+ expectEqual(data, Data(bytes: [0x68, 0xff, 0xff, 0x64]))
+ }
+ }
+
+ func test_validateMutation_cow_immutableBacking_replaceSubrangeWithCollection() {
+ var data = NSData(bytes: "hello world", length: 11) as Data
+ holdReference(data) {
+ let replacement: [UInt8] = [0xFF, 0xFF]
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ data.replaceSubrange(range, with: replacement)
+ expectEqual(data, Data(bytes: [0x68, 0xff, 0xff, 0x64]))
+ }
+ }
+
+ func test_validateMutation_cow_immutableBacking_replaceSubrangeWithBytes() {
+ var data = NSData(bytes: "hello world", length: 11) as Data
+ holdReference(data) {
+ let replacement: [UInt8] = [0xFF, 0xFF]
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ replacement.withUnsafeBytes {
+ data.replaceSubrange(range, with: $0.baseAddress!, count: 2)
+ }
+ expectEqual(data, Data(bytes: [0x68, 0xff, 0xff, 0x64]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_immutableBacking_withUnsafeMutableBytes() {
+ var data = (NSData(bytes: "hello world", length: 11) as Data)[4..<9]
+ holdReference(data) {
+ data.withUnsafeMutableBytes { (ptr: UnsafeMutablePointer<UInt8>) in
+ ptr.advanced(by: 1).pointee = 0xFF
+ }
+ expectEqual(data[data.startIndex.advanced(by: 1)], 0xFF)
+ }
+ }
+
+ func test_validateMutation_slice_cow_immutableBacking_appendBytes() {
+ let baseBytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ var data = baseBytes.withUnsafeBufferPointer {
+ return (NSData(bytes: $0.baseAddress!, length: $0.count) as Data)[4..<9]
+ }
+ holdReference(data) {
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer { data.append($0.baseAddress!, count: $0.count) }
+ expectEqual(data, Data(bytes: [4, 5, 6, 7, 8, 0xFF, 0xFF]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_immutableBacking_appendData() {
+ let baseBytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ var data = baseBytes.withUnsafeBufferPointer {
+ return (NSData(bytes: $0.baseAddress!, length: $0.count) as Data)[4..<9]
+ }
+ holdReference(data) {
+ data.append(Data(bytes: [0xFF, 0xFF]))
+ expectEqual(data, Data(bytes: [4, 5, 6, 7, 8, 0xFF, 0xFF]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_immutableBacking_appendBuffer() {
+ var data = (NSData(bytes: "hello world", length: 11) as Data)[4..<9]
+ holdReference(data) {
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer{ data.append($0) }
+ expectEqual(data, Data(bytes: [0x6f, 0x20, 0x77, 0x6f, 0x72, 0xFF, 0xFF]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_immutableBacking_appendSequence() {
+ let baseBytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ var data = baseBytes.withUnsafeBufferPointer {
+ return (NSData(bytes: $0.baseAddress!, length: $0.count) as Data)[4..<9]
+ }
+ holdReference(data) {
+ let bytes = repeatElement(UInt8(0xFF), count: 2)
+ data.append(contentsOf: bytes)
+ expectEqual(data, Data(bytes: [4, 5, 6, 7, 8, 0xFF, 0xFF]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_immutableBacking_appendContentsOf() {
+ let baseBytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ var data = baseBytes.withUnsafeBufferPointer {
+ return (NSData(bytes: $0.baseAddress!, length: $0.count) as Data)[4..<9]
+ }
+ holdReference(data) {
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ data.append(contentsOf: bytes)
+ expectEqual(data, Data(bytes: [4, 5, 6, 7, 8, 0xFF, 0xFF]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_immutableBacking_resetBytes() {
+ let baseBytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ var data = baseBytes.withUnsafeBufferPointer {
+ return (NSData(bytes: $0.baseAddress!, length: $0.count) as Data)[4..<9]
+ }
+ holdReference(data) {
+ data.resetBytes(in: 5..<8)
+ expectEqual(data, Data(bytes: [4, 0, 0, 0, 8]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_immutableBacking_replaceSubrange() {
+ let baseBytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ var data = baseBytes.withUnsafeBufferPointer {
+ return (NSData(bytes: $0.baseAddress!, length: $0.count) as Data)[4..<9]
+ }
+ holdReference(data) {
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ data.replaceSubrange(range, with: Data(bytes: [0xFF, 0xFF]))
+ expectEqual(data, Data(bytes: [4, 0xFF, 0xFF, 8]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_immutableBacking_replaceSubrangeCountableRange() {
+ let baseBytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ var data = baseBytes.withUnsafeBufferPointer {
+ return (NSData(bytes: $0.baseAddress!, length: $0.count) as Data)[4..<9]
+ }
+ holdReference(data) {
+ let range: CountableRange<Data.Index> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ data.replaceSubrange(range, with: Data(bytes: [0xFF, 0xFF]))
+ expectEqual(data, Data(bytes: [4, 0xFF, 0xFF, 8]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_immutableBacking_replaceSubrangeWithBuffer() {
+ let baseBytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ var data = baseBytes.withUnsafeBufferPointer {
+ return (NSData(bytes: $0.baseAddress!, length: $0.count) as Data)[4..<9]
+ }
+ holdReference(data) {
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer { data.replaceSubrange(range, with: $0) }
+ expectEqual(data, Data(bytes: [4, 0xFF, 0xFF, 8]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_immutableBacking_replaceSubrangeWithCollection() {
+ let baseBytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ var data = baseBytes.withUnsafeBufferPointer {
+ return (NSData(bytes: $0.baseAddress!, length: $0.count) as Data)[4..<9]
+ }
+ holdReference(data) {
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ data.replaceSubrange(range, with: bytes)
+ expectEqual(data, Data(bytes: [4, 0xFF, 0xFF, 8]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_immutableBacking_replaceSubrangeWithBytes() {
+ let baseBytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ var data = baseBytes.withUnsafeBufferPointer {
+ return (NSData(bytes: $0.baseAddress!, length: $0.count) as Data)[4..<9]
+ }
+ holdReference(data) {
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBytes { data.replaceSubrange(range, with: $0.baseAddress!, count: 2) }
+ expectEqual(data, Data(bytes: [4, 0xFF, 0xFF, 8]))
+ }
+ }
+
+ func test_validateMutation_mutableBacking_withUnsafeMutableBytes() {
+ let baseBytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6]
+ var data = baseBytes.withUnsafeBufferPointer {
+ return NSData(bytes: $0.baseAddress!, length: $0.count) as Data
+ }
+ data.append(contentsOf: [7, 8, 9])
+ data.withUnsafeMutableBytes { (ptr: UnsafeMutablePointer<UInt8>) in
+ ptr.advanced(by: 5).pointee = 0xFF
+ }
+ expectEqual(data[data.startIndex.advanced(by: 5)], 0xFF)
+ }
+
+ func test_validateMutation_mutableBacking_appendBytes() {
+ let baseBytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6]
+ var data = baseBytes.withUnsafeBufferPointer {
+ return NSData(bytes: $0.baseAddress!, length: $0.count) as Data
+ }
+ data.append(contentsOf: [7, 8, 9])
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer { data.append($0.baseAddress!, count: $0.count) }
+ expectEqual(data, Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xFF, 0xFF]))
+ }
+
+ func test_validateMutation_mutableBacking_appendData() {
+ let baseBytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6]
+ var data = baseBytes.withUnsafeBufferPointer {
+ return NSData(bytes: $0.baseAddress!, length: $0.count) as Data
+ }
+ data.append(contentsOf: [7, 8, 9])
+ data.append(Data(bytes: [0xFF, 0xFF]))
+ expectEqual(data, Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xFF, 0xFF]))
+ }
+
+ func test_validateMutation_mutableBacking_appendBuffer() {
+ let baseBytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6]
+ var data = baseBytes.withUnsafeBufferPointer {
+ return NSData(bytes: $0.baseAddress!, length: $0.count) as Data
+ }
+ data.append(contentsOf: [7, 8, 9])
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer { data.append($0) }
+ expectEqual(data, Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xFF, 0xFF]))
+ }
+
+ func test_validateMutation_mutableBacking_appendSequence() {
+ let baseBytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6]
+ var data = baseBytes.withUnsafeBufferPointer {
+ return NSData(bytes: $0.baseAddress!, length: $0.count) as Data
+ }
+ data.append(contentsOf: [7, 8, 9])
+ data.append(contentsOf: repeatElement(UInt8(0xFF), count: 2))
+ expectEqual(data, Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xFF, 0xFF]))
+ }
+
+ func test_validateMutation_mutableBacking_appendContentsOf() {
+ let baseBytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6]
+ var data = baseBytes.withUnsafeBufferPointer {
+ return NSData(bytes: $0.baseAddress!, length: $0.count) as Data
+ }
+ data.append(contentsOf: [7, 8, 9])
+ data.append(contentsOf: [0xFF, 0xFF])
+ expectEqual(data, Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xFF, 0xFF]))
+ }
+
+ func test_validateMutation_mutableBacking_resetBytes() {
+ let baseBytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6]
+ var data = baseBytes.withUnsafeBufferPointer {
+ return NSData(bytes: $0.baseAddress!, length: $0.count) as Data
+ }
+ data.append(contentsOf: [7, 8, 9])
+ data.resetBytes(in: 5..<8)
+ expectEqual(data, Data(bytes: [0, 1, 2, 3, 4, 0, 0, 0, 8, 9]))
+ }
+
+ func test_validateMutation_mutableBacking_replaceSubrange() {
+ let baseBytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6]
+ var data = baseBytes.withUnsafeBufferPointer {
+ return NSData(bytes: $0.baseAddress!, length: $0.count) as Data
+ }
+ data.append(contentsOf: [7, 8, 9])
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ let replacement = Data(bytes: [0xFF, 0xFF])
+ data.replaceSubrange(range, with: replacement)
+ expectEqual(data, Data(bytes: [0, 0xFF, 0xFF, 9]))
+ }
+
+ func test_validateMutation_mutableBacking_replaceSubrangeCountableRange() {
+ let baseBytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6]
+ var data = baseBytes.withUnsafeBufferPointer {
+ return NSData(bytes: $0.baseAddress!, length: $0.count) as Data
+ }
+ data.append(contentsOf: [7, 8, 9])
+ let range: CountableRange<Data.Index> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ let replacement = Data(bytes: [0xFF, 0xFF])
+ data.replaceSubrange(range, with: replacement)
+ expectEqual(data, Data(bytes: [0, 0xFF, 0xFF, 9]))
+ }
+
+ func test_validateMutation_mutableBacking_replaceSubrangeWithBuffer() {
+ let baseBytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6]
+ var data = baseBytes.withUnsafeBufferPointer {
+ return NSData(bytes: $0.baseAddress!, length: $0.count) as Data
+ }
+ data.append(contentsOf: [7, 8, 9])
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer {
+ data.replaceSubrange(range, with: $0)
+ }
+ expectEqual(data, Data(bytes: [0, 0xFF, 0xFF, 9]))
+ }
+
+ func test_validateMutation_mutableBacking_replaceSubrangeWithCollection() {
+ let baseBytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6]
+ var data = baseBytes.withUnsafeBufferPointer {
+ return NSData(bytes: $0.baseAddress!, length: $0.count) as Data
+ }
+ data.append(contentsOf: [7, 8, 9])
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ data.replaceSubrange(range, with: [0xFF, 0xFF])
+ expectEqual(data, Data(bytes: [0, 0xFF, 0xFF, 9]))
+ }
+
+ func test_validateMutation_mutableBacking_replaceSubrangeWithBytes() {
+ let baseBytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6]
+ var data = baseBytes.withUnsafeBufferPointer {
+ return NSData(bytes: $0.baseAddress!, length: $0.count) as Data
+ }
+ data.append(contentsOf: [7, 8, 9])
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBytes {
+ data.replaceSubrange(range, with: $0.baseAddress!, count: $0.count)
+ }
+ expectEqual(data, Data(bytes: [0, 0xFF, 0xFF, 9]))
+ }
+
+ func test_validateMutation_slice_mutableBacking_withUnsafeMutableBytes() {
+ var base = NSData(bytes: "hello world", length: 11) as Data
+ base.append(contentsOf: [1, 2, 3, 4, 5, 6])
+ var data = base[4..<9]
+ data.withUnsafeMutableBytes { (ptr: UnsafeMutablePointer<UInt8>) in
+ ptr.advanced(by: 1).pointee = 0xFF
+ }
+ expectEqual(data[data.startIndex.advanced(by: 1)], 0xFF)
+ }
+
+ func test_validateMutation_slice_mutableBacking_appendBytes() {
+ let baseBytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6]
+ var base = baseBytes.withUnsafeBufferPointer {
+ return NSData(bytes: $0.baseAddress!, length: $0.count) as Data
+ }
+ base.append(contentsOf: [7, 8, 9])
+ var data = base[4..<9]
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer { data.append($0.baseAddress!, count: $0.count) }
+ expectEqual(data, Data(bytes: [4, 5, 6, 7, 8, 0xFF, 0xFF]))
+ }
+
+ func test_validateMutation_slice_mutableBacking_appendData() {
+ let baseBytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6]
+ var base = baseBytes.withUnsafeBufferPointer {
+ return NSData(bytes: $0.baseAddress!, length: $0.count) as Data
+ }
+ base.append(contentsOf: [7, 8, 9])
+ var data = base[4..<9]
+ data.append(Data(bytes: [0xFF, 0xFF]))
+ expectEqual(data, Data(bytes: [4, 5, 6, 7, 8, 0xFF, 0xFF]))
+ }
+
+ func test_validateMutation_slice_mutableBacking_appendBuffer() {
+ var base = NSData(bytes: "hello world", length: 11) as Data
+ base.append(contentsOf: [1, 2, 3, 4, 5, 6])
+ var data = base[4..<9]
+ let bytes: [UInt8] = [1, 2, 3]
+ bytes.withUnsafeBufferPointer { data.append($0) }
+ expectEqual(data, Data(bytes: [0x6f, 0x20, 0x77, 0x6f, 0x72, 0x1, 0x2, 0x3]))
+ }
+
+ func test_validateMutation_slice_mutableBacking_appendSequence() {
+ var base = NSData(bytes: "hello world", length: 11) as Data
+ base.append(contentsOf: [1, 2, 3, 4, 5, 6])
+ var data = base[4..<9]
+ let seq = repeatElement(UInt8(1), count: 3)
+ data.append(contentsOf: seq)
+ expectEqual(data, Data(bytes: [0x6f, 0x20, 0x77, 0x6f, 0x72, 0x1, 0x1, 0x1]))
+ }
+
+ func test_validateMutation_slice_mutableBacking_appendContentsOf() {
+ var base = NSData(bytes: "hello world", length: 11) as Data
+ base.append(contentsOf: [1, 2, 3, 4, 5, 6])
+ var data = base[4..<9]
+ let bytes: [UInt8] = [1, 2, 3]
+ data.append(contentsOf: bytes)
+ expectEqual(data, Data(bytes: [0x6f, 0x20, 0x77, 0x6f, 0x72, 0x1, 0x2, 0x3]))
+ }
+
+ func test_validateMutation_slice_mutableBacking_resetBytes() {
+ let baseBytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6]
+ var base = baseBytes.withUnsafeBufferPointer {
+ return NSData(bytes: $0.baseAddress!, length: $0.count) as Data
+ }
+ base.append(contentsOf: [7, 8, 9])
+ var data = base[4..<9]
+ data.resetBytes(in: 5..<8)
+ expectEqual(data, Data(bytes: [4, 0, 0, 0, 8]))
+ }
+
+ func test_validateMutation_slice_mutableBacking_replaceSubrange() {
+ var base = NSData(bytes: "hello world", length: 11) as Data
+ base.append(contentsOf: [1, 2, 3, 4, 5, 6])
+ var data = base[4..<9]
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ data.replaceSubrange(range, with: Data(bytes: [0xFF, 0xFF]))
+ expectEqual(data, Data(bytes: [0x6f, 0xFF, 0xFF, 0x72]))
+ }
+
+ func test_validateMutation_slice_mutableBacking_replaceSubrangeCountableRange() {
+ var base = NSData(bytes: "hello world", length: 11) as Data
+ base.append(contentsOf: [1, 2, 3, 4, 5, 6])
+ var data = base[4..<9]
+ let range: CountableRange<Data.Index> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ data.replaceSubrange(range, with: Data(bytes: [0xFF, 0xFF]))
+ expectEqual(data, Data(bytes: [0x6f, 0xFF, 0xFF, 0x72]))
+ }
+
+ func test_validateMutation_slice_mutableBacking_replaceSubrangeWithBuffer() {
+ var base = NSData(bytes: "hello world", length: 11) as Data
+ base.append(contentsOf: [1, 2, 3, 4, 5, 6])
+ var data = base[4..<9]
+ let replacement: [UInt8] = [0xFF, 0xFF]
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ replacement.withUnsafeBufferPointer { (buffer: UnsafeBufferPointer<UInt8>) in
+ data.replaceSubrange(range, with: buffer)
+ }
+ expectEqual(data, Data(bytes: [0x6f, 0xFF, 0xFF, 0x72]))
+ }
+
+ func test_validateMutation_slice_mutableBacking_replaceSubrangeWithCollection() {
+ var base = NSData(bytes: "hello world", length: 11) as Data
+ base.append(contentsOf: [1, 2, 3, 4, 5, 6])
+ var data = base[4..<9]
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ let replacement: [UInt8] = [0xFF, 0xFF]
+ data.replaceSubrange(range, with:replacement)
+ expectEqual(data, Data(bytes: [0x6f, 0xFF, 0xFF, 0x72]))
+ }
+
+ func test_validateMutation_slice_mutableBacking_replaceSubrangeWithBytes() {
+ var base = NSData(bytes: "hello world", length: 11) as Data
+ base.append(contentsOf: [1, 2, 3, 4, 5, 6])
+ var data = base[4..<9]
+ let replacement: [UInt8] = [0xFF, 0xFF]
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ replacement.withUnsafeBytes {
+ data.replaceSubrange(range, with: $0.baseAddress!, count: 2)
+ }
+ expectEqual(data, Data(bytes: [0x6f, 0xFF, 0xFF, 0x72]))
+ }
+
+ func test_validateMutation_cow_mutableBacking_withUnsafeMutableBytes() {
+ var data = NSData(bytes: "hello world", length: 11) as Data
+ data.append(contentsOf: [1, 2, 3, 4, 5, 6])
+ holdReference(data) {
+ data.withUnsafeMutableBytes { (ptr: UnsafeMutablePointer<UInt8>) in
+ ptr.advanced(by: 5).pointee = 0xFF
+ }
+ expectEqual(data[data.startIndex.advanced(by: 5)], 0xFF)
+ }
+ }
+
+ func test_validateMutation_cow_mutableBacking_appendBytes() {
+ var data = NSData(bytes: "hello world", length: 11) as Data
+ data.append(contentsOf: [1, 2, 3, 4, 5, 6])
+ holdReference(data) {
+ data.append("hello", count: 5)
+ expectEqual(data[data.startIndex.advanced(by: 16)], 6)
+ expectEqual(data[data.startIndex.advanced(by: 17)], 0x68)
+ }
+ }
+
+ func test_validateMutation_cow_mutableBacking_appendData() {
+ var data = NSData(bytes: "hello world", length: 11) as Data
+ data.append(contentsOf: [1, 2, 3, 4, 5, 6])
+ holdReference(data) {
+ data.append("hello", count: 5)
+ expectEqual(data[data.startIndex.advanced(by: 16)], 6)
+ expectEqual(data[data.startIndex.advanced(by: 17)], 0x68)
+ }
+ }
+
+ func test_validateMutation_cow_mutableBacking_appendBuffer() {
+ var data = NSData(bytes: "hello world", length: 11) as Data
+ data.append(contentsOf: [1, 2, 3, 4, 5, 6])
+ holdReference(data) {
+ let other = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+ data.append(other)
+ expectEqual(data[data.startIndex.advanced(by: 16)], 6)
+ expectEqual(data[data.startIndex.advanced(by: 17)], 0)
+ }
+ }
+
+ func test_validateMutation_cow_mutableBacking_appendSequence() {
+ var data = NSData(bytes: "hello world", length: 11) as Data
+ data.append(contentsOf: [1, 2, 3, 4, 5, 6])
+ holdReference(data) {
+ let seq = repeatElement(UInt8(1), count: 10)
+ data.append(contentsOf: seq)
+ expectEqual(data[data.startIndex.advanced(by: 16)], 6)
+ expectEqual(data[data.startIndex.advanced(by: 17)], 1)
+ }
+ }
+
+ func test_validateMutation_cow_mutableBacking_appendContentsOf() {
+ var data = NSData(bytes: "hello world", length: 11) as Data
+ data.append(contentsOf: [1, 2, 3, 4, 5, 6])
+ holdReference(data) {
+ let bytes: [UInt8] = [1, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ data.append(contentsOf: bytes)
+ expectEqual(data[data.startIndex.advanced(by: 16)], 6)
+ expectEqual(data[data.startIndex.advanced(by: 17)], 1)
+ }
+ }
+
+ func test_validateMutation_cow_mutableBacking_resetBytes() {
+ var data = NSData(bytes: "hello world", length: 11) as Data
+ data.append(contentsOf: [1, 2, 3, 4, 5, 6])
+ holdReference(data) {
+ data.resetBytes(in: 5..<8)
+ expectEqual(data, Data(bytes: [0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x00, 0x00, 0x72, 0x6c, 0x64, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06]))
+ }
+ }
+
+ func test_validateMutation_cow_mutableBacking_replaceSubrange() {
+ var data = NSData(bytes: "hello world", length: 11) as Data
+ data.append(contentsOf: [1, 2, 3, 4, 5, 6])
+ holdReference(data) {
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 4)..<data.startIndex.advanced(by: 9)
+ let replacement = Data(bytes: [0xFF, 0xFF])
+ data.replaceSubrange(range, with: replacement)
+ expectEqual(data, Data(bytes: [0x68, 0x65, 0x6c, 0x6c, 0xff, 0xff, 0x6c, 0x64, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06]))
+ }
+ }
+
+ func test_validateMutation_cow_mutableBacking_replaceSubrangeCountableRange() {
+ var data = NSData(bytes: "hello world", length: 11) as Data
+ data.append(contentsOf: [1, 2, 3, 4, 5, 6])
+ holdReference(data) {
+ let range: CountableRange<Data.Index> = data.startIndex.advanced(by: 4)..<data.startIndex.advanced(by: 9)
+ let replacement = Data(bytes: [0xFF, 0xFF])
+ data.replaceSubrange(range, with: replacement)
+ expectEqual(data, Data(bytes: [0x68, 0x65, 0x6c, 0x6c, 0xff, 0xff, 0x6c, 0x64, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06]))
+ }
+ }
+
+ func test_validateMutation_cow_mutableBacking_replaceSubrangeWithBuffer() {
+ var data = NSData(bytes: "hello world", length: 11) as Data
+ data.append(contentsOf: [1, 2, 3, 4, 5, 6])
+ holdReference(data) {
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 4)..<data.startIndex.advanced(by: 9)
+ let replacement: [UInt8] = [0xFF, 0xFF]
+ replacement.withUnsafeBufferPointer { (buffer: UnsafeBufferPointer<UInt8>) in
+ data.replaceSubrange(range, with: buffer)
+ }
+ expectEqual(data, Data(bytes: [0x68, 0x65, 0x6c, 0x6c, 0xff, 0xff, 0x6c, 0x64, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06]))
+ }
+ }
+
+ func test_validateMutation_cow_mutableBacking_replaceSubrangeWithCollection() {
+ var data = NSData(bytes: "hello world", length: 11) as Data
+ data.append(contentsOf: [1, 2, 3, 4, 5, 6])
+ holdReference(data) {
+ let replacement: [UInt8] = [0xFF, 0xFF]
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 4)..<data.startIndex.advanced(by: 9)
+ data.replaceSubrange(range, with: replacement)
+ expectEqual(data, Data(bytes: [0x68, 0x65, 0x6c, 0x6c, 0xff, 0xff, 0x6c, 0x64, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06]))
+ }
+ }
+
+ func test_validateMutation_cow_mutableBacking_replaceSubrangeWithBytes() {
+ var data = NSData(bytes: "hello world", length: 11) as Data
+ data.append(contentsOf: [1, 2, 3, 4, 5, 6])
+ holdReference(data) {
+ let replacement: [UInt8] = [0xFF, 0xFF]
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 4)..<data.startIndex.advanced(by: 9)
+ replacement.withUnsafeBytes {
+ data.replaceSubrange(range, with: $0.baseAddress!, count: 2)
+ }
+ expectEqual(data, Data(bytes: [0x68, 0x65, 0x6c, 0x6c, 0xff, 0xff, 0x6c, 0x64, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_mutableBacking_withUnsafeMutableBytes() {
+ var base = NSData(bytes: "hello world", length: 11) as Data
+ base.append(contentsOf: [1, 2, 3, 4, 5, 6])
+ var data = base[4..<9]
+ holdReference(data) {
+ data.withUnsafeMutableBytes { (ptr: UnsafeMutablePointer<UInt8>) in
+ ptr.advanced(by: 1).pointee = 0xFF
+ }
+ expectEqual(data[data.startIndex.advanced(by: 1)], 0xFF)
+ }
+ }
+
+ func test_validateMutation_slice_cow_mutableBacking_appendBytes() {
+ let bytes: [UInt8] = [0, 1, 2]
+ var base = bytes.withUnsafeBytes { (ptr) in
+ return NSData(bytes: ptr.baseAddress!, length: ptr.count) as Data
+ }
+ base.append(contentsOf: [3, 4, 5])
+ var data = base[1..<4]
+ holdReference(data) {
+ let bytesToAppend: [UInt8] = [6, 7, 8]
+ bytesToAppend.withUnsafeBytes { (ptr) in
+ data.append(ptr.baseAddress!.assumingMemoryBound(to: UInt8.self), count: ptr.count)
+ }
+ expectEqual(data, Data(bytes: [1, 2, 3, 6, 7, 8]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_mutableBacking_appendData() {
+ let baseBytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6]
+ var base = baseBytes.withUnsafeBufferPointer {
+ return NSData(bytes: $0.baseAddress!, length: $0.count) as Data
+ }
+ base.append(contentsOf: [7, 8, 9])
+ var data = base[4..<9]
+ holdReference(data) {
+ data.append(Data(bytes: [0xFF, 0xFF]))
+ expectEqual(data, Data(bytes: [4, 5, 6, 7, 8, 0xFF, 0xFF]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_mutableBacking_appendBuffer() {
+ let baseBytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6]
+ var base = baseBytes.withUnsafeBufferPointer {
+ return NSData(bytes: $0.baseAddress!, length: $0.count) as Data
+ }
+ base.append(contentsOf: [7, 8, 9])
+ var data = base[4..<9]
+ holdReference(data) {
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer{ data.append($0) }
+ expectEqual(data, Data(bytes: [4, 5, 6, 7, 8, 0xFF, 0xFF]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_mutableBacking_appendSequence() {
+ let baseBytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6]
+ var base = baseBytes.withUnsafeBufferPointer {
+ return NSData(bytes: $0.baseAddress!, length: $0.count) as Data
+ }
+ base.append(contentsOf: [7, 8, 9])
+ var data = base[4..<9]
+ holdReference(data) {
+ let bytes = repeatElement(UInt8(0xFF), count: 2)
+ data.append(contentsOf: bytes)
+ expectEqual(data, Data(bytes: [4, 5, 6, 7, 8, 0xFF, 0xFF]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_mutableBacking_appendContentsOf() {
+ let baseBytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6]
+ var base = baseBytes.withUnsafeBufferPointer {
+ return NSData(bytes: $0.baseAddress!, length: $0.count) as Data
+ }
+ base.append(contentsOf: [7, 8, 9])
+ var data = base[4..<9]
+ holdReference(data) {
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ data.append(contentsOf: bytes)
+ expectEqual(data, Data(bytes: [4, 5, 6, 7, 8, 0xFF, 0xFF]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_mutableBacking_resetBytes() {
+ let baseBytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6]
+ var base = baseBytes.withUnsafeBufferPointer {
+ return NSData(bytes: $0.baseAddress!, length: $0.count) as Data
+ }
+ base.append(contentsOf: [7, 8, 9])
+ var data = base[4..<9]
+ holdReference(data) {
+ data.resetBytes(in: 5..<8)
+ expectEqual(data, Data(bytes: [4, 0, 0, 0, 8]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_mutableBacking_replaceSubrange() {
+ let baseBytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6]
+ var base = baseBytes.withUnsafeBufferPointer {
+ return NSData(bytes: $0.baseAddress!, length: $0.count) as Data
+ }
+ base.append(contentsOf: [7, 8, 9])
+ var data = base[4..<9]
+ holdReference(data) {
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ data.replaceSubrange(range, with: Data(bytes: [0xFF, 0xFF]))
+ expectEqual(data, Data(bytes: [4, 0xFF, 0xFF, 8]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_mutableBacking_replaceSubrangeCountableRange() {
+ let baseBytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6]
+ var base = baseBytes.withUnsafeBufferPointer {
+ return NSData(bytes: $0.baseAddress!, length: $0.count) as Data
+ }
+ base.append(contentsOf: [7, 8, 9])
+ var data = base[4..<9]
+ holdReference(data) {
+ let range: CountableRange<Data.Index> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ data.replaceSubrange(range, with: Data(bytes: [0xFF, 0xFF]))
+ expectEqual(data, Data(bytes: [4, 0xFF, 0xFF, 8]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_mutableBacking_replaceSubrangeWithBuffer() {
+ let baseBytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6]
+ var base = baseBytes.withUnsafeBufferPointer {
+ return NSData(bytes: $0.baseAddress!, length: $0.count) as Data
+ }
+ base.append(contentsOf: [7, 8, 9])
+ var data = base[4..<9]
+ holdReference(data) {
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer { data.replaceSubrange(range, with: $0) }
+ expectEqual(data, Data(bytes: [4, 0xFF, 0xFF, 8]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_mutableBacking_replaceSubrangeWithCollection() {
+ let baseBytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6]
+ var base = baseBytes.withUnsafeBufferPointer {
+ return NSData(bytes: $0.baseAddress!, length: $0.count) as Data
+ }
+ base.append(contentsOf: [7, 8, 9])
+ var data = base[4..<9]
+ holdReference(data) {
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ data.replaceSubrange(range, with: bytes)
+ expectEqual(data, Data(bytes: [4, 0xFF, 0xFF, 8]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_mutableBacking_replaceSubrangeWithBytes() {
+ let baseBytes: [UInt8] = [0, 1, 2, 3, 4, 5, 6]
+ var base = baseBytes.withUnsafeBufferPointer {
+ return NSData(bytes: $0.baseAddress!, length: $0.count) as Data
+ }
+ base.append(contentsOf: [7, 8, 9])
+ var data = base[4..<9]
+ holdReference(data) {
+ let range: Range<Data.Index> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBytes { data.replaceSubrange(range, with: $0.baseAddress!, count: 2) }
+ expectEqual(data, Data(bytes: [4, 0xFF, 0xFF, 8]))
+ }
+ }
+
+ func test_validateMutation_customBacking_withUnsafeMutableBytes() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))
+ data.withUnsafeMutableBytes { (ptr: UnsafeMutablePointer<UInt8>) in
+ ptr.advanced(by: 5).pointee = 0xFF
+ }
+ expectEqual(data, Data(bytes: [1, 1, 1, 1, 1, 0xFF, 1, 1, 1, 1]))
+ }
+
+ func test_validateMutation_customBacking_appendBytes() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer { data.append($0.baseAddress!, count: $0.count) }
+ expectEqual(data, Data(bytes: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0xFF, 0xFF]))
+ }
+
+ func test_validateMutation_customBacking_appendData() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))
+ data.append(Data(bytes: [0xFF, 0xFF]))
+ expectEqual(data, Data(bytes: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0xFF, 0xFF]))
+ }
+
+ func test_validateMutation_customBacking_appendBuffer() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer { (buffer) in
+ data.append(buffer)
+ }
+ expectEqual(data, Data(bytes: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0xFF, 0xFF]))
+
+ }
+
+ func test_validateMutation_customBacking_appendSequence() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))
+ data.append(contentsOf: repeatElement(UInt8(0xFF), count: 2))
+ expectEqual(data, Data(bytes: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0xFF, 0xFF]))
+ }
+
+ func test_validateMutation_customBacking_appendContentsOf() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))
+ data.append(contentsOf: [0xFF, 0xFF])
+ expectEqual(data, Data(bytes: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0xFF, 0xFF]))
+ }
+
+ func test_validateMutation_customBacking_resetBytes() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))
+ data.resetBytes(in: 5..<8)
+ expectEqual(data, Data(bytes: [1, 1, 1, 1, 1, 0, 0, 0, 1, 1]))
+ }
+
+ func test_validateMutation_customBacking_replaceSubrange() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))
+ let range: Range<Int> = 1..<4
+ data.replaceSubrange(range, with: Data(bytes: [0xFF, 0xFF]))
+ expectEqual(data, Data(bytes: [1, 0xFF, 0xFF, 1, 1, 1, 1, 1, 1]))
+ }
+
+ func test_validateMutation_customBacking_replaceSubrangeCountableRange() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))
+ let range: CountableRange<Int> = 1..<4
+ data.replaceSubrange(range, with: Data(bytes: [0xFF, 0xFF]))
+ expectEqual(data, Data(bytes: [1, 0xFF, 0xFF, 1, 1, 1, 1, 1, 1]))
+ }
+
+ func test_validateMutation_customBacking_replaceSubrangeWithBuffer() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ let range: Range<Int> = 1..<4
+ bytes.withUnsafeBufferPointer { (buffer) in
+ data.replaceSubrange(range, with: buffer)
+ }
+ expectEqual(data, Data(bytes: [1, 0xFF, 0xFF, 1, 1, 1, 1, 1, 1]))
+ }
+
+ func test_validateMutation_customBacking_replaceSubrangeWithCollection() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))
+ let range: Range<Int> = 1..<4
+ data.replaceSubrange(range, with: [0xFF, 0xFF])
+ expectEqual(data, Data(bytes: [1, 0xFF, 0xFF, 1, 1, 1, 1, 1, 1]))
+ }
+
+ func test_validateMutation_customBacking_replaceSubrangeWithBytes() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ let range: Range<Int> = 1..<5
+ bytes.withUnsafeBufferPointer { (buffer) in
+ data.replaceSubrange(range, with: buffer.baseAddress!, count: buffer.count)
+ }
+ expectEqual(data, Data(bytes: [1, 0xFF, 0xFF, 1, 1, 1, 1, 1]))
+ }
+
+ func test_validateMutation_slice_customBacking_withUnsafeMutableBytes() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))[4..<9]
+ data.withUnsafeMutableBytes { (ptr: UnsafeMutablePointer<UInt8>) in
+ ptr.advanced(by: 1).pointee = 0xFF
+ }
+ expectEqual(data[data.startIndex.advanced(by: 1)], 0xFF)
+ }
+
+ func test_validateMutation_slice_customBacking_appendBytes() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))[4..<9]
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBytes { ptr in
+ data.append(ptr.baseAddress!.assumingMemoryBound(to: UInt8.self), count: ptr.count)
+ }
+ expectEqual(data, Data(bytes: [1, 1, 1, 1, 1, 0xFF, 0xFF]))
+ }
+
+ func test_validateMutation_slice_customBacking_appendData() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))[4..<9]
+ data.append(Data(bytes: [0xFF, 0xFF]))
+ expectEqual(data, Data(bytes: [1, 1, 1, 1, 1, 0xFF, 0xFF]))
+ }
+
+ func test_validateMutation_slice_customBacking_appendBuffer() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))[4..<9]
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer { (buffer) in
+ data.append(buffer)
+ }
+ expectEqual(data, Data(bytes: [1, 1, 1, 1, 1, 0xFF, 0xFF]))
+ }
+
+ func test_validateMutation_slice_customBacking_appendSequence() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))[4..<9]
+ let seq = repeatElement(UInt8(0xFF), count: 2)
+ data.append(contentsOf: seq)
+ expectEqual(data, Data(bytes: [1, 1, 1, 1, 1, 0xFF, 0xFF]))
+ }
+
+ func test_validateMutation_slice_customBacking_appendContentsOf() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))[4..<9]
+ data.append(contentsOf: [0xFF, 0xFF])
+ expectEqual(data, Data(bytes: [1, 1, 1, 1, 1, 0xFF, 0xFF]))
+ }
+
+ func test_validateMutation_slice_customBacking_resetBytes() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))[4..<9]
+ data.resetBytes(in: 5..<8)
+ expectEqual(data, Data(bytes: [1, 0, 0, 0, 1]))
+ }
+
+ func test_validateMutation_slice_customBacking_replaceSubrange() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))[4..<9]
+ let range: Range<Int> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ data.replaceSubrange(range, with: Data(bytes: [0xFF, 0xFF]))
+ expectEqual(data, Data(bytes: [1, 0xFF, 0xFF, 1]))
+ }
+
+ func test_validateMutation_slice_customBacking_replaceSubrangeCountableRange() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))[4..<9]
+ let range: CountableRange<Int> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ data.replaceSubrange(range, with: Data(bytes: [0xFF, 0xFF]))
+ expectEqual(data, Data(bytes: [1, 0xFF, 0xFF, 1]))
+ }
+
+ func test_validateMutation_slice_customBacking_replaceSubrangeWithBuffer() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))[4..<9]
+ let range: Range<Int> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer { (buffer) in
+ data.replaceSubrange(range, with: buffer)
+ }
+ expectEqual(data, Data(bytes: [1, 0xFF, 0xFF, 1]))
+ }
+
+ func test_validateMutation_slice_customBacking_replaceSubrangeWithCollection() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))[4..<9]
+ let range: Range<Int> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ data.replaceSubrange(range, with: [0xFF, 0xFF])
+ expectEqual(data, Data(bytes: [1, 0xFF, 0xFF, 1]))
+ }
+
+ func test_validateMutation_slice_customBacking_replaceSubrangeWithBytes() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))[4..<9]
+ let range: Range<Int> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBytes { buffer in
+ data.replaceSubrange(range, with: buffer.baseAddress!, count: 2)
+ }
+ expectEqual(data, Data(bytes: [1, 0xFF, 0xFF, 1]))
+ }
+
+ func test_validateMutation_cow_customBacking_withUnsafeMutableBytes() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))
+ holdReference(data) {
+ data.withUnsafeMutableBytes { (ptr: UnsafeMutablePointer<UInt8>) in
+ ptr.advanced(by: 5).pointee = 0xFF
+ }
+ expectEqual(data[data.startIndex.advanced(by: 5)], 0xFF)
+ }
+ }
+
+ func test_validateMutation_cow_customBacking_appendBytes() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))
+ holdReference(data) {
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer { (buffer) in
+ data.append(buffer.baseAddress!, count: buffer.count)
+ }
+ expectEqual(data, Data(bytes: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0xFF, 0xFF]))
+ }
+ }
+
+ func test_validateMutation_cow_customBacking_appendData() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))
+ holdReference(data) {
+ data.append(Data(bytes: [0xFF, 0xFF]))
+ expectEqual(data, Data(bytes: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0xFF, 0xFF]))
+ }
+ }
+
+ func test_validateMutation_cow_customBacking_appendBuffer() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))
+ holdReference(data) {
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer { data.append($0) }
+ expectEqual(data, Data(bytes: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0xFF, 0xFF]))
+ }
+ }
+
+ func test_validateMutation_cow_customBacking_appendSequence() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))
+ holdReference(data) {
+ data.append(contentsOf: repeatElement(UInt8(0xFF), count: 2))
+ expectEqual(data, Data(bytes: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0xFF, 0xFF]))
+ }
+ }
+
+ func test_validateMutation_cow_customBacking_appendContentsOf() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))
+ holdReference(data) {
+ data.append(contentsOf: [0xFF, 0xFF])
+ expectEqual(data, Data(bytes: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0xFF, 0xFF]))
+ }
+ }
+
+ func test_validateMutation_cow_customBacking_resetBytes() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))
+ holdReference(data) {
+ data.resetBytes(in: 5..<8)
+ expectEqual(data, Data(bytes: [1, 1, 1, 1, 1, 0, 0, 0, 1, 1]))
+ }
+ }
+
+ func test_validateMutation_cow_customBacking_replaceSubrange() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))
+ holdReference(data) {
+ let range: Range<Int> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ data.replaceSubrange(range, with: Data(bytes: [0xFF, 0xFF]))
+ expectEqual(data, Data(bytes: [1, 0xFF, 0xFF, 1]))
+ }
+ }
+
+ func test_validateMutation_cow_customBacking_replaceSubrangeCountableRange() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))
+ holdReference(data) {
+ let range: CountableRange<Int> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ data.replaceSubrange(range, with: Data(bytes: [0xFF, 0xFF]))
+ expectEqual(data, Data(bytes: [1, 0xFF, 0xFF, 1]))
+ }
+ }
+
+ func test_validateMutation_cow_customBacking_replaceSubrangeWithBuffer() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))
+ holdReference(data) {
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ let range: Range<Int> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ bytes.withUnsafeBufferPointer { data.replaceSubrange(range, with: $0) }
+ expectEqual(data, Data(bytes: [1, 0xFF, 0xFF, 1]))
+ }
+ }
+
+ func test_validateMutation_cow_customBacking_replaceSubrangeWithCollection() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))
+ holdReference(data) {
+ let range: Range<Int> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ data.replaceSubrange(range, with: [0xFF, 0xFF])
+ expectEqual(data, Data(bytes: [1, 0xFF, 0xFF, 1]))
+ }
+ }
+
+ func test_validateMutation_cow_customBacking_replaceSubrangeWithBytes() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))
+ holdReference(data) {
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ let range: Range<Int> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ bytes.withUnsafeBytes {
+ data.replaceSubrange(range, with: $0.baseAddress!, count: $0.count)
+ }
+ expectEqual(data, Data(bytes: [1, 0xFF, 0xFF, 1]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_customBacking_withUnsafeMutableBytes() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))[4..<9]
+ holdReference(data) {
+ data.withUnsafeMutableBytes { (ptr: UnsafeMutablePointer<UInt8>) in
+ ptr.advanced(by: 1).pointee = 0xFF
+ }
+ expectEqual(data[data.startIndex.advanced(by: 1)], 0xFF)
+ }
+ }
+
+ func test_validateMutation_slice_cow_customBacking_appendBytes() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))[4..<9]
+ holdReference(data) {
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer { (buffer) in
+ data.append(buffer.baseAddress!, count: buffer.count)
+ }
+ expectEqual(data, Data(bytes: [1, 1, 1, 1, 1, 0xFF, 0xFF]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_customBacking_appendData() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))[4..<9]
+ holdReference(data) {
+ data.append(Data(bytes: [0xFF, 0xFF]))
+ expectEqual(data, Data(bytes: [1, 1, 1, 1, 1, 0xFF, 0xFF]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_customBacking_appendBuffer() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))[4..<9]
+ holdReference(data) {
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer { data.append($0) }
+ expectEqual(data, Data(bytes: [1, 1, 1, 1, 1, 0xFF, 0xFF]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_customBacking_appendSequence() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))[4..<9]
+ holdReference(data) {
+ data.append(contentsOf: repeatElement(UInt8(0xFF), count: 2))
+ expectEqual(data, Data(bytes: [1, 1, 1, 1, 1, 0xFF, 0xFF]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_customBacking_appendContentsOf() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))[4..<9]
+ holdReference(data) {
+ data.append(contentsOf: [0xFF, 0xFF])
+ expectEqual(data, Data(bytes: [1, 1, 1, 1, 1, 0xFF, 0xFF]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_customBacking_resetBytes() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))[4..<9]
+ holdReference(data) {
+ data.resetBytes(in: 5..<8)
+ expectEqual(data, Data(bytes: [1, 0, 0, 0, 1]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_customBacking_replaceSubrange() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))[4..<9]
+ holdReference(data) {
+ let range: Range<Int> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ data.replaceSubrange(range, with: Data(bytes: [0xFF, 0xFF]))
+ expectEqual(data, Data(bytes: [1, 0xFF, 0xFF, 1]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_customBacking_replaceSubrangeCountableRange() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))[4..<9]
+ holdReference(data) {
+ let range: CountableRange<Int> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ data.replaceSubrange(range, with: Data(bytes: [0xFF, 0xFF]))
+ expectEqual(data, Data(bytes: [1, 0xFF, 0xFF, 1]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_customBacking_replaceSubrangeWithBuffer() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))[4..<9]
+ holdReference(data) {
+ let range: Range<Int> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer { data.replaceSubrange(range, with: $0) }
+ expectEqual(data, Data(bytes: [1, 0xFF, 0xFF, 1]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_customBacking_replaceSubrangeWithCollection() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))[4..<9]
+ holdReference(data) {
+ let range: Range<Int> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ data.replaceSubrange(range, with: [0xFF, 0xFF])
+ expectEqual(data, Data(bytes: [1, 0xFF, 0xFF, 1]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_customBacking_replaceSubrangeWithBytes() {
+ var data = Data(referencing: AllOnesImmutableData(length: 10))[4..<9]
+ holdReference(data) {
+ let range: Range<Int> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBytes {
+ data.replaceSubrange(range, with: $0.baseAddress!, count: $0.count)
+ }
+ expectEqual(data, Data(bytes: [1, 0xFF, 0xFF, 1]))
+ }
+ }
+
+ func test_validateMutation_customMutableBacking_withUnsafeMutableBytes() {
+ var data = Data(referencing: AllOnesData(length: 1))
+ data.count = 10
+ data.withUnsafeMutableBytes { (ptr: UnsafeMutablePointer<UInt8>) in
+ ptr.advanced(by: 5).pointee = 0xFF
+ }
+ expectEqual(data[data.startIndex.advanced(by: 5)], 0xFF)
+ }
+
+ func test_validateMutation_customMutableBacking_appendBytes() {
+ var data = Data(referencing: AllOnesData(length: 1))
+ data.count = 10
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer { data.append($0.baseAddress!, count: $0.count) }
+ expectEqual(data, Data(bytes: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF]))
+ }
+
+ func test_validateMutation_customMutableBacking_appendData() {
+ var data = Data(referencing: AllOnesData(length: 1))
+ data.count = 10
+ data.append(Data(bytes: [0xFF, 0xFF]))
+ expectEqual(data, Data(bytes: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF]))
+ }
+
+ func test_validateMutation_customMutableBacking_appendBuffer() {
+ var data = Data(referencing: AllOnesData(length: 1))
+ data.count = 10
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer { data.append($0) }
+ expectEqual(data, Data(bytes: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF]))
+ }
+
+ func test_validateMutation_customMutableBacking_appendSequence() {
+ var data = Data(referencing: AllOnesData(length: 1))
+ data.count = 10
+ data.append(contentsOf: repeatElement(UInt8(0xFF), count: 2))
+ expectEqual(data, Data(bytes: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF]))
+ }
+
+ func test_validateMutation_customMutableBacking_appendContentsOf() {
+ var data = Data(referencing: AllOnesData(length: 1))
+ data.count = 10
+ data.append(contentsOf: [0xFF, 0xFF])
+ expectEqual(data, Data(bytes: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF]))
+ }
+
+ func test_validateMutation_customMutableBacking_resetBytes() {
+ var data = Data(referencing: AllOnesData(length: 1))
+ data.count = 10
+ data.resetBytes(in: 5..<8)
+ expectEqual(data.count, 10)
+ expectEqual(data[data.startIndex.advanced(by: 0)], 1)
+ expectEqual(data[data.startIndex.advanced(by: 5)], 0)
+ expectEqual(data[data.startIndex.advanced(by: 6)], 0)
+ expectEqual(data[data.startIndex.advanced(by: 7)], 0)
+ }
+
+ func test_validateMutation_customMutableBacking_replaceSubrange() {
+ var data = Data(referencing: AllOnesData(length: 1))
+ data.count = 10
+ let range: Range<Int> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ data.replaceSubrange(range, with: Data(bytes: [0xFF, 0xFF]))
+ expectEqual(data, Data(bytes: [1, 0xFF, 0xFF, 0]))
+ }
+
+ func test_validateMutation_customMutableBacking_replaceSubrangeCountableRange() {
+ var data = Data(referencing: AllOnesData(length: 1))
+ data.count = 10
+ let range: CountableRange<Int> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ data.replaceSubrange(range, with: Data(bytes: [0xFF, 0xFF]))
+ expectEqual(data, Data(bytes: [1, 0xFF, 0xFF, 0]))
+ }
+
+ func test_validateMutation_customMutableBacking_replaceSubrangeWithBuffer() {
+ var data = Data(referencing: AllOnesData(length: 1))
+ data.count = 10
+ let range: Range<Int> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer { data.replaceSubrange(range, with: $0) }
+ expectEqual(data, Data(bytes: [1, 0xFF, 0xFF, 0]))
+ }
+
+ func test_validateMutation_customMutableBacking_replaceSubrangeWithCollection() {
+ var data = Data(referencing: AllOnesData(length: 1))
+ data.count = 10
+ let range: Range<Int> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ data.replaceSubrange(range, with: [0xFF, 0xFF])
+ expectEqual(data, Data(bytes: [1, 0xFF, 0xFF, 0]))
+ }
+
+ func test_validateMutation_customMutableBacking_replaceSubrangeWithBytes() {
+ var data = Data(referencing: AllOnesData(length: 1))
+ data.count = 10
+ let range: Range<Int> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer { data.replaceSubrange(range, with: $0.baseAddress!, count: $0.count) }
+ expectEqual(data, Data(bytes: [1, 0xFF, 0xFF, 0]))
+ }
+
+ func test_validateMutation_slice_customMutableBacking_withUnsafeMutableBytes() {
+ var base = Data(referencing: AllOnesData(length: 1))
+ base.count = 10
+ var data = base[4..<9]
+ data.withUnsafeMutableBytes { (ptr: UnsafeMutablePointer<UInt8>) in
+ ptr.advanced(by: 1).pointee = 0xFF
+ }
+ expectEqual(data[data.startIndex.advanced(by: 1)], 0xFF)
+ }
+
+ func test_validateMutation_slice_customMutableBacking_appendBytes() {
+ var base = Data(referencing: AllOnesData(length: 1))
+ base.count = 10
+ var data = base[4..<9]
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer { data.append($0.baseAddress!, count: $0.count) }
+ expectEqual(data, Data(bytes: [0, 0, 0, 0, 0, 0xFF, 0xFF]))
+ }
+
+ func test_validateMutation_slice_customMutableBacking_appendData() {
+ var base = Data(referencing: AllOnesData(length: 1))
+ base.count = 10
+ var data = base[4..<9]
+ data.append(Data(bytes: [0xFF, 0xFF]))
+ expectEqual(data, Data(bytes: [0, 0, 0, 0, 0, 0xFF, 0xFF]))
+ }
+
+ func test_validateMutation_slice_customMutableBacking_appendBuffer() {
+ var base = Data(referencing: AllOnesData(length: 1))
+ base.count = 10
+ var data = base[4..<9]
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer { data.append($0) }
+ expectEqual(data, Data(bytes: [0, 0, 0, 0, 0, 0xFF, 0xFF]))
+ }
+
+ func test_validateMutation_slice_customMutableBacking_appendSequence() {
+ var base = Data(referencing: AllOnesData(length: 1))
+ base.count = 10
+ var data = base[4..<9]
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer { data.append($0) }
+ expectEqual(data, Data(bytes: [0, 0, 0, 0, 0, 0xFF, 0xFF]))
+ }
+
+ func test_validateMutation_slice_customMutableBacking_appendContentsOf() {
+ var base = Data(referencing: AllOnesData(length: 1))
+ base.count = 10
+ var data = base[4..<9]
+ data.append(contentsOf: [0xFF, 0xFF])
+ expectEqual(data, Data(bytes: [0, 0, 0, 0, 0, 0xFF, 0xFF]))
+ }
+
+ func test_validateMutation_slice_customMutableBacking_resetBytes() {
+ var base = Data(referencing: AllOnesData(length: 1))
+ base.count = 10
+ var data = base[4..<9]
+ data.resetBytes(in: 5..<8)
+
+ expectEqual(data[data.startIndex.advanced(by: 1)], 0)
+ expectEqual(data[data.startIndex.advanced(by: 2)], 0)
+ expectEqual(data[data.startIndex.advanced(by: 3)], 0)
+ }
+
+ func test_validateMutation_slice_customMutableBacking_replaceSubrange() {
+ var base = Data(referencing: AllOnesData(length: 1))
+ base.count = 10
+ var data = base[4..<9]
+ let range: Range<Int> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ data.replaceSubrange(range, with: Data(bytes: [0xFF, 0xFF]))
+ expectEqual(data, Data(bytes: [0, 0xFF, 0xFF, 0]))
+ }
+
+ func test_validateMutation_slice_customMutableBacking_replaceSubrangeCountableRange() {
+ var base = Data(referencing: AllOnesData(length: 1))
+ base.count = 10
+ var data = base[4..<9]
+ let range: CountableRange<Int> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ data.replaceSubrange(range, with: Data(bytes: [0xFF, 0xFF]))
+ expectEqual(data, Data(bytes: [0, 0xFF, 0xFF, 0]))
+ }
+
+ func test_validateMutation_slice_customMutableBacking_replaceSubrangeWithBuffer() {
+ var base = Data(referencing: AllOnesData(length: 1))
+ base.count = 10
+ var data = base[4..<9]
+ let range: Range<Int> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer { data.replaceSubrange(range, with: $0) }
+ expectEqual(data, Data(bytes: [0, 0xFF, 0xFF, 0]))
+ }
+
+ func test_validateMutation_slice_customMutableBacking_replaceSubrangeWithCollection() {
+ var base = Data(referencing: AllOnesData(length: 1))
+ base.count = 10
+ var data = base[4..<9]
+ let range: Range<Int> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ data.replaceSubrange(range, with: [0xFF, 0xFF])
+ expectEqual(data, Data(bytes: [0, 0xFF, 0xFF, 0]))
+ }
+
+ func test_validateMutation_slice_customMutableBacking_replaceSubrangeWithBytes() {
+ var base = Data(referencing: AllOnesData(length: 1))
+ base.count = 10
+ var data = base[4..<9]
+ let range: Range<Int> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer { data.replaceSubrange(range, with: $0.baseAddress!, count: $0.count) }
+ expectEqual(data, Data(bytes: [0, 0xFF, 0xFF, 0]))
+ }
+
+ func test_validateMutation_cow_customMutableBacking_withUnsafeMutableBytes() {
+ var data = Data(referencing: AllOnesData(length: 1))
+ data.count = 10
+ holdReference(data) {
+ data.withUnsafeMutableBytes { (ptr: UnsafeMutablePointer<UInt8>) in
+ ptr.advanced(by: 5).pointee = 0xFF
+ }
+ expectEqual(data[data.startIndex.advanced(by: 5)], 0xFF)
+ }
+ }
+
+ func test_validateMutation_cow_customMutableBacking_appendBytes() {
+ var data = Data(referencing: AllOnesData(length: 1))
+ data.count = 10
+ holdReference(data) {
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer { data.append($0.baseAddress!, count: $0.count) }
+ expectEqual(data, Data(bytes: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF]))
+ }
+ }
+
+ func test_validateMutation_cow_customMutableBacking_appendData() {
+ var data = Data(referencing: AllOnesData(length: 1))
+ data.count = 10
+ holdReference(data) {
+ data.append(Data(bytes: [0xFF, 0xFF]))
+ expectEqual(data, Data(bytes: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF]))
+ }
+ }
+
+ func test_validateMutation_cow_customMutableBacking_appendBuffer() {
+ var data = Data(referencing: AllOnesData(length: 1))
+ data.count = 10
+ holdReference(data) {
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer { data.append($0) }
+ expectEqual(data, Data(bytes: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF]))
+ }
+ }
+
+ func test_validateMutation_cow_customMutableBacking_appendSequence() {
+ var data = Data(referencing: AllOnesData(length: 1))
+ data.count = 10
+ holdReference(data) {
+ data.append(contentsOf: repeatElement(UInt8(0xFF), count: 2))
+ expectEqual(data, Data(bytes: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF]))
+ }
+ }
+
+ func test_validateMutation_cow_customMutableBacking_appendContentsOf() {
+ var data = Data(referencing: AllOnesData(length: 1))
+ data.count = 10
+ holdReference(data) {
+ data.append(contentsOf: [0xFF, 0xFF])
+ expectEqual(data, Data(bytes: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF]))
+ }
+ }
+
+ func test_validateMutation_cow_customMutableBacking_resetBytes() {
+ var data = Data(referencing: AllOnesData(length: 10))
+ holdReference(data) {
+ data.resetBytes(in: 5..<8)
+ expectEqual(data.count, 10)
+ expectEqual(data[data.startIndex.advanced(by: 0)], 1)
+ expectEqual(data[data.startIndex.advanced(by: 5)], 0)
+ expectEqual(data[data.startIndex.advanced(by: 6)], 0)
+ expectEqual(data[data.startIndex.advanced(by: 7)], 0)
+ }
+ }
+
+ func test_validateMutation_cow_customMutableBacking_replaceSubrange() {
+ var data = Data(referencing: AllOnesData(length: 1))
+ data.count = 10
+ holdReference(data) {
+ let range: Range<Int> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ data.replaceSubrange(range, with: Data(bytes: [0xFF, 0xFF]))
+ expectEqual(data, Data(bytes: [1, 0xFF, 0xFF, 0]))
+ }
+ }
+
+ func test_validateMutation_cow_customMutableBacking_replaceSubrangeCountableRange() {
+ var data = Data(referencing: AllOnesData(length: 1))
+ data.count = 10
+ holdReference(data) {
+ let range: CountableRange<Int> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ data.replaceSubrange(range, with: Data(bytes: [0xFF, 0xFF]))
+ expectEqual(data, Data(bytes: [1, 0xFF, 0xFF, 0]))
+ }
+ }
+
+ func test_validateMutation_cow_customMutableBacking_replaceSubrangeWithBuffer() {
+ var data = Data(referencing: AllOnesData(length: 1))
+ data.count = 10
+ holdReference(data) {
+ let range: Range<Int> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer { data.replaceSubrange(range, with: $0) }
+ expectEqual(data, Data(bytes: [1, 0xFF, 0xFF, 0]))
+ }
+ }
+
+ func test_validateMutation_cow_customMutableBacking_replaceSubrangeWithCollection() {
+ var data = Data(referencing: AllOnesData(length: 1))
+ data.count = 10
+ holdReference(data) {
+ let range: Range<Int> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ data.replaceSubrange(range, with: [0xFF, 0xFF])
+ expectEqual(data, Data(bytes: [1, 0xFF, 0xFF, 0]))
+ }
+ }
+
+ func test_validateMutation_cow_customMutableBacking_replaceSubrangeWithBytes() {
+ var data = Data(referencing: AllOnesData(length: 1))
+ data.count = 10
+ holdReference(data) {
+ let range: Range<Int> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer { data.replaceSubrange(range, with: $0.baseAddress!, count: $0.count) }
+ expectEqual(data, Data(bytes: [1, 0xFF, 0xFF, 0]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_customMutableBacking_withUnsafeMutableBytes() {
+ var base = Data(referencing: AllOnesData(length: 1))
+ base.count = 10
+ var data = base[4..<9]
+ holdReference(data) {
+ data.withUnsafeMutableBytes { (ptr: UnsafeMutablePointer<UInt8>) in
+ ptr.advanced(by: 1).pointee = 0xFF
+ }
+ expectEqual(data[data.startIndex.advanced(by: 1)], 0xFF)
+ }
+ }
+
+ func test_validateMutation_slice_cow_customMutableBacking_appendBytes() {
+ var base = Data(referencing: AllOnesData(length: 1))
+ base.count = 10
+ var data = base[4..<9]
+ holdReference(data) {
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer { data.append($0.baseAddress!, count: $0.count) }
+ expectEqual(data, Data(bytes: [0, 0, 0, 0, 0, 0xFF, 0xFF]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_customMutableBacking_appendData() {
+ var base = Data(referencing: AllOnesData(length: 1))
+ base.count = 10
+ var data = base[4..<9]
+ holdReference(data) {
+ data.append(Data(bytes: [0xFF, 0xFF]))
+ expectEqual(data, Data(bytes: [0, 0, 0, 0, 0, 0xFF, 0xFF]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_customMutableBacking_appendBuffer() {
+ var base = Data(referencing: AllOnesData(length: 1))
+ base.count = 10
+ var data = base[4..<9]
+ holdReference(data) {
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer { data.append($0) }
+ expectEqual(data, Data(bytes: [0, 0, 0, 0, 0, 0xFF, 0xFF]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_customMutableBacking_appendSequence() {
+ var base = Data(referencing: AllOnesData(length: 1))
+ base.count = 10
+ var data = base[4..<9]
+ holdReference(data) {
+ data.append(contentsOf: repeatElement(UInt8(0xFF), count: 2))
+ expectEqual(data, Data(bytes: [0, 0, 0, 0, 0, 0xFF, 0xFF]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_customMutableBacking_appendContentsOf() {
+ var base = Data(referencing: AllOnesData(length: 1))
+ base.count = 10
+ var data = base[4..<9]
+ holdReference(data) {
+ data.append(contentsOf: [0xFF, 0xFF])
+ expectEqual(data, Data(bytes: [0, 0, 0, 0, 0, 0xFF, 0xFF]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_customMutableBacking_resetBytes() {
+ var base = Data(referencing: AllOnesData(length: 1))
+ base.count = 10
+ var data = base[4..<9]
+ holdReference(data) {
+ data.resetBytes(in: 5..<8)
+ expectEqual(data[data.startIndex.advanced(by: 1)], 0)
+ expectEqual(data[data.startIndex.advanced(by: 2)], 0)
+ expectEqual(data[data.startIndex.advanced(by: 3)], 0)
+ }
+ }
+
+ func test_validateMutation_slice_cow_customMutableBacking_replaceSubrange() {
+ var base = Data(referencing: AllOnesData(length: 1))
+ base.count = 10
+ var data = base[4..<9]
+ holdReference(data) {
+ let range: Range<Int> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ data.replaceSubrange(range, with: Data(bytes: [0xFF, 0xFF]))
+ expectEqual(data, Data(bytes: [0, 0xFF, 0xFF, 0]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_customMutableBacking_replaceSubrangeCountableRange() {
+ var base = Data(referencing: AllOnesData(length: 1))
+ base.count = 10
+ var data = base[4..<9]
+ holdReference(data) {
+ let range: CountableRange<Int> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ data.replaceSubrange(range, with: Data(bytes: [0xFF, 0xFF]))
+ expectEqual(data, Data(bytes: [0, 0xFF, 0xFF, 0]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_customMutableBacking_replaceSubrangeWithBuffer() {
+ var base = Data(referencing: AllOnesData(length: 1))
+ base.count = 10
+ var data = base[4..<9]
+ holdReference(data) {
+ let range: Range<Int> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer { data.replaceSubrange(range, with: $0) }
+ expectEqual(data, Data(bytes: [0, 0xFF, 0xFF, 0]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_customMutableBacking_replaceSubrangeWithCollection() {
+ var base = Data(referencing: AllOnesData(length: 1))
+ base.count = 10
+ var data = base[4..<9]
+ holdReference(data) {
+ let range: Range<Int> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ data.replaceSubrange(range, with: [0xFF, 0xFF])
+ expectEqual(data, Data(bytes: [0, 0xFF, 0xFF, 0]))
+ }
+ }
+
+ func test_validateMutation_slice_cow_customMutableBacking_replaceSubrangeWithBytes() {
+ var base = Data(referencing: AllOnesData(length: 1))
+ base.count = 10
+ var data = base[4..<9]
+ holdReference(data) {
+ let range: Range<Int> = data.startIndex.advanced(by: 1)..<data.endIndex.advanced(by: -1)
+ let bytes: [UInt8] = [0xFF, 0xFF]
+ bytes.withUnsafeBufferPointer { data.replaceSubrange(range, with: $0.baseAddress!, count: $0.count) }
+ expectEqual(data, Data(bytes: [0, 0xFF, 0xFF, 0]))
+ }
+ }
+
+ func test_sliceHash() {
+ let base1 = Data(bytes: [0, 0xFF, 0xFF, 0])
+ let base2 = Data(bytes: [0, 0xFF, 0xFF, 0])
+ let base3 = Data(bytes: [0xFF, 0xFF, 0xFF, 0])
+ let sliceEmulation = Data(bytes: [0xFF, 0xFF])
+ expectEqual(base1.hashValue, base2.hashValue)
+ let slice1 = base1[base1.startIndex.advanced(by: 1)..<base1.endIndex.advanced(by: -1)]
+ let slice2 = base2[base2.startIndex.advanced(by: 1)..<base2.endIndex.advanced(by: -1)]
+ let slice3 = base3[base3.startIndex.advanced(by: 1)..<base3.endIndex.advanced(by: -1)]
+ expectEqual(slice1.hashValue, sliceEmulation.hashValue)
+ expectEqual(slice1.hashValue, slice2.hashValue)
+ expectEqual(slice2.hashValue, slice3.hashValue)
+ }
+
+ func test_slice_resize_growth() {
+ var data = Data(bytes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])[4..<9]
+ data.resetBytes(in: data.endIndex.advanced(by: -1)..<data.endIndex.advanced(by: 1))
+ expectEqual(data, Data(bytes: [4, 5, 6, 7, 0, 0]))
+ }
+
+ func test_sliceEnumeration() {
+ var base = DispatchData.empty
+ let bytes: [UInt8] = [0, 1, 2, 3, 4]
+ base.append(bytes.withUnsafeBytes { DispatchData(bytes: $0) })
+ base.append(bytes.withUnsafeBytes { DispatchData(bytes: $0) })
+ base.append(bytes.withUnsafeBytes { DispatchData(bytes: $0) })
+ let data = ((base as AnyObject) as! Data)[3..<11]
+ var regionRanges: [Range<Int>] = []
+ var regionData: [Data] = []
+ data.enumerateBytes { (buffer, index, _) in
+ regionData.append(Data(bytes: buffer.baseAddress!, count: buffer.count))
+ regionRanges.append(index..<index + buffer.count)
+ }
+ expectEqual(regionRanges.count, 3)
+ expectEqual(Range<Data.Index>(3..<5), regionRanges[0])
+ expectEqual(Range<Data.Index>(5..<10), regionRanges[1])
+ expectEqual(Range<Data.Index>(10..<11), regionRanges[2])
+ expectEqual(Data(bytes: [3, 4]), regionData[0]) //fails
+ expectEqual(Data(bytes: [0, 1, 2, 3, 4]), regionData[1]) //passes
+ expectEqual(Data(bytes: [0]), regionData[2]) //fails
+ }
}
#if !FOUNDATION_XCTEST
@@ -1275,6 +3723,249 @@
DataTests.test("test_replaceSubrangeReferencingMutable") { TestData().test_replaceSubrangeReferencingMutable() }
DataTests.test("test_replaceSubrangeReferencingImmutable") { TestData().test_replaceSubrangeReferencingImmutable() }
DataTests.test("test_replaceSubrangeFromBridged") { TestData().test_replaceSubrangeFromBridged() }
+DataTests.test("test_validateMutation_withUnsafeMutableBytes") { TestData().test_validateMutation_withUnsafeMutableBytes() }
+DataTests.test("test_validateMutation_appendBytes") { TestData().test_validateMutation_appendBytes() }
+DataTests.test("test_validateMutation_appendData") { TestData().test_validateMutation_appendData() }
+DataTests.test("test_validateMutation_appendBuffer") { TestData().test_validateMutation_appendBuffer() }
+DataTests.test("test_validateMutation_appendSequence") { TestData().test_validateMutation_appendSequence() }
+DataTests.test("test_validateMutation_appendContentsOf") { TestData().test_validateMutation_appendContentsOf() }
+DataTests.test("test_validateMutation_resetBytes") { TestData().test_validateMutation_resetBytes() }
+DataTests.test("test_validateMutation_replaceSubrange") { TestData().test_validateMutation_replaceSubrange() }
+DataTests.test("test_validateMutation_replaceSubrangeCountableRange") { TestData().test_validateMutation_replaceSubrangeCountableRange() }
+DataTests.test("test_validateMutation_replaceSubrangeWithBuffer") { TestData().test_validateMutation_replaceSubrangeWithBuffer() }
+DataTests.test("test_validateMutation_replaceSubrangeWithCollection") { TestData().test_validateMutation_replaceSubrangeWithCollection() }
+DataTests.test("test_validateMutation_replaceSubrangeWithBytes") { TestData().test_validateMutation_replaceSubrangeWithBytes() }
+DataTests.test("test_validateMutation_slice_withUnsafeMutableBytes") { TestData().test_validateMutation_slice_withUnsafeMutableBytes() }
+DataTests.test("test_validateMutation_slice_appendBytes") { TestData().test_validateMutation_slice_appendBytes() }
+DataTests.test("test_validateMutation_slice_appendData") { TestData().test_validateMutation_slice_appendData() }
+DataTests.test("test_validateMutation_slice_appendBuffer") { TestData().test_validateMutation_slice_appendBuffer() }
+DataTests.test("test_validateMutation_slice_appendSequence") { TestData().test_validateMutation_slice_appendSequence() }
+DataTests.test("test_validateMutation_slice_appendContentsOf") { TestData().test_validateMutation_slice_appendContentsOf() }
+DataTests.test("test_validateMutation_slice_resetBytes") { TestData().test_validateMutation_slice_resetBytes() }
+DataTests.test("test_validateMutation_slice_replaceSubrange") { TestData().test_validateMutation_slice_replaceSubrange() }
+DataTests.test("test_validateMutation_slice_replaceSubrangeCountableRange") { TestData().test_validateMutation_slice_replaceSubrangeCountableRange() }
+DataTests.test("test_validateMutation_slice_replaceSubrangeWithBuffer") { TestData().test_validateMutation_slice_replaceSubrangeWithBuffer() }
+DataTests.test("test_validateMutation_slice_replaceSubrangeWithCollection") { TestData().test_validateMutation_slice_replaceSubrangeWithCollection() }
+DataTests.test("test_validateMutation_slice_replaceSubrangeWithBytes") { TestData().test_validateMutation_slice_replaceSubrangeWithBytes() }
+DataTests.test("test_validateMutation_cow_withUnsafeMutableBytes") { TestData().test_validateMutation_cow_withUnsafeMutableBytes() }
+DataTests.test("test_validateMutation_cow_appendBytes") { TestData().test_validateMutation_cow_appendBytes() }
+DataTests.test("test_validateMutation_cow_appendData") { TestData().test_validateMutation_cow_appendData() }
+DataTests.test("test_validateMutation_cow_appendBuffer") { TestData().test_validateMutation_cow_appendBuffer() }
+DataTests.test("test_validateMutation_cow_appendSequence") { TestData().test_validateMutation_cow_appendSequence() }
+DataTests.test("test_validateMutation_cow_appendContentsOf") { TestData().test_validateMutation_cow_appendContentsOf() }
+DataTests.test("test_validateMutation_cow_resetBytes") { TestData().test_validateMutation_cow_resetBytes() }
+DataTests.test("test_validateMutation_cow_replaceSubrange") { TestData().test_validateMutation_cow_replaceSubrange() }
+DataTests.test("test_validateMutation_cow_replaceSubrangeCountableRange") { TestData().test_validateMutation_cow_replaceSubrangeCountableRange() }
+DataTests.test("test_validateMutation_cow_replaceSubrangeWithBuffer") { TestData().test_validateMutation_cow_replaceSubrangeWithBuffer() }
+DataTests.test("test_validateMutation_cow_replaceSubrangeWithCollection") { TestData().test_validateMutation_cow_replaceSubrangeWithCollection() }
+DataTests.test("test_validateMutation_cow_replaceSubrangeWithBytes") { TestData().test_validateMutation_cow_replaceSubrangeWithBytes() }
+DataTests.test("test_validateMutation_slice_cow_withUnsafeMutableBytes") { TestData().test_validateMutation_slice_cow_withUnsafeMutableBytes() }
+DataTests.test("test_validateMutation_slice_cow_appendBytes") { TestData().test_validateMutation_slice_cow_appendBytes() }
+DataTests.test("test_validateMutation_slice_cow_appendData") { TestData().test_validateMutation_slice_cow_appendData() }
+DataTests.test("test_validateMutation_slice_cow_appendBuffer") { TestData().test_validateMutation_slice_cow_appendBuffer() }
+DataTests.test("test_validateMutation_slice_cow_appendSequence") { TestData().test_validateMutation_slice_cow_appendSequence() }
+DataTests.test("test_validateMutation_slice_cow_appendContentsOf") { TestData().test_validateMutation_slice_cow_appendContentsOf() }
+DataTests.test("test_validateMutation_slice_cow_resetBytes") { TestData().test_validateMutation_slice_cow_resetBytes() }
+DataTests.test("test_validateMutation_slice_cow_replaceSubrange") { TestData().test_validateMutation_slice_cow_replaceSubrange() }
+DataTests.test("test_validateMutation_slice_cow_replaceSubrangeCountableRange") { TestData().test_validateMutation_slice_cow_replaceSubrangeCountableRange() }
+DataTests.test("test_validateMutation_slice_cow_replaceSubrangeWithBuffer") { TestData().test_validateMutation_slice_cow_replaceSubrangeWithBuffer() }
+DataTests.test("test_validateMutation_slice_cow_replaceSubrangeWithCollection") { TestData().test_validateMutation_slice_cow_replaceSubrangeWithCollection() }
+DataTests.test("test_validateMutation_slice_cow_replaceSubrangeWithBytes") { TestData().test_validateMutation_slice_cow_replaceSubrangeWithBytes() }
+DataTests.test("test_validateMutation_immutableBacking_withUnsafeMutableBytes") { TestData().test_validateMutation_immutableBacking_withUnsafeMutableBytes() }
+DataTests.test("test_validateMutation_immutableBacking_appendBytes") { TestData().test_validateMutation_immutableBacking_appendBytes() }
+DataTests.test("test_validateMutation_immutableBacking_appendData") { TestData().test_validateMutation_immutableBacking_appendData() }
+DataTests.test("test_validateMutation_immutableBacking_appendBuffer") { TestData().test_validateMutation_immutableBacking_appendBuffer() }
+DataTests.test("test_validateMutation_immutableBacking_appendSequence") { TestData().test_validateMutation_immutableBacking_appendSequence() }
+DataTests.test("test_validateMutation_immutableBacking_appendContentsOf") { TestData().test_validateMutation_immutableBacking_appendContentsOf() }
+DataTests.test("test_validateMutation_immutableBacking_resetBytes") { TestData().test_validateMutation_immutableBacking_resetBytes() }
+DataTests.test("test_validateMutation_immutableBacking_replaceSubrange") { TestData().test_validateMutation_immutableBacking_replaceSubrange() }
+DataTests.test("test_validateMutation_immutableBacking_replaceSubrangeCountableRange") { TestData().test_validateMutation_immutableBacking_replaceSubrangeCountableRange() }
+DataTests.test("test_validateMutation_immutableBacking_replaceSubrangeWithBuffer") { TestData().test_validateMutation_immutableBacking_replaceSubrangeWithBuffer() }
+DataTests.test("test_validateMutation_immutableBacking_replaceSubrangeWithCollection") { TestData().test_validateMutation_immutableBacking_replaceSubrangeWithCollection() }
+DataTests.test("test_validateMutation_immutableBacking_replaceSubrangeWithBytes") { TestData().test_validateMutation_immutableBacking_replaceSubrangeWithBytes() }
+DataTests.test("test_validateMutation_slice_immutableBacking_withUnsafeMutableBytes") { TestData().test_validateMutation_slice_immutableBacking_withUnsafeMutableBytes() }
+DataTests.test("test_validateMutation_slice_immutableBacking_appendBytes") { TestData().test_validateMutation_slice_immutableBacking_appendBytes() }
+DataTests.test("test_validateMutation_slice_immutableBacking_appendData") { TestData().test_validateMutation_slice_immutableBacking_appendData() }
+DataTests.test("test_validateMutation_slice_immutableBacking_appendBuffer") { TestData().test_validateMutation_slice_immutableBacking_appendBuffer() }
+DataTests.test("test_validateMutation_slice_immutableBacking_appendSequence") { TestData().test_validateMutation_slice_immutableBacking_appendSequence() }
+DataTests.test("test_validateMutation_slice_immutableBacking_appendContentsOf") { TestData().test_validateMutation_slice_immutableBacking_appendContentsOf() }
+DataTests.test("test_validateMutation_slice_immutableBacking_resetBytes") { TestData().test_validateMutation_slice_immutableBacking_resetBytes() }
+DataTests.test("test_validateMutation_slice_immutableBacking_replaceSubrange") { TestData().test_validateMutation_slice_immutableBacking_replaceSubrange() }
+DataTests.test("test_validateMutation_slice_immutableBacking_replaceSubrangeCountableRange") { TestData().test_validateMutation_slice_immutableBacking_replaceSubrangeCountableRange() }
+DataTests.test("test_validateMutation_slice_immutableBacking_replaceSubrangeWithBuffer") { TestData().test_validateMutation_slice_immutableBacking_replaceSubrangeWithBuffer() }
+DataTests.test("test_validateMutation_slice_immutableBacking_replaceSubrangeWithCollection") { TestData().test_validateMutation_slice_immutableBacking_replaceSubrangeWithCollection() }
+DataTests.test("test_validateMutation_slice_immutableBacking_replaceSubrangeWithBytes") { TestData().test_validateMutation_slice_immutableBacking_replaceSubrangeWithBytes() }
+DataTests.test("test_validateMutation_cow_immutableBacking_withUnsafeMutableBytes") { TestData().test_validateMutation_cow_immutableBacking_withUnsafeMutableBytes() }
+DataTests.test("test_validateMutation_cow_immutableBacking_appendBytes") { TestData().test_validateMutation_cow_immutableBacking_appendBytes() }
+DataTests.test("test_validateMutation_cow_immutableBacking_appendData") { TestData().test_validateMutation_cow_immutableBacking_appendData() }
+DataTests.test("test_validateMutation_cow_immutableBacking_appendBuffer") { TestData().test_validateMutation_cow_immutableBacking_appendBuffer() }
+DataTests.test("test_validateMutation_cow_immutableBacking_appendSequence") { TestData().test_validateMutation_cow_immutableBacking_appendSequence() }
+DataTests.test("test_validateMutation_cow_immutableBacking_appendContentsOf") { TestData().test_validateMutation_cow_immutableBacking_appendContentsOf() }
+DataTests.test("test_validateMutation_cow_immutableBacking_resetBytes") { TestData().test_validateMutation_cow_immutableBacking_resetBytes() }
+DataTests.test("test_validateMutation_cow_immutableBacking_replaceSubrange") { TestData().test_validateMutation_cow_immutableBacking_replaceSubrange() }
+DataTests.test("test_validateMutation_cow_immutableBacking_replaceSubrangeCountableRange") { TestData().test_validateMutation_cow_immutableBacking_replaceSubrangeCountableRange() }
+DataTests.test("test_validateMutation_cow_immutableBacking_replaceSubrangeWithBuffer") { TestData().test_validateMutation_cow_immutableBacking_replaceSubrangeWithBuffer() }
+DataTests.test("test_validateMutation_cow_immutableBacking_replaceSubrangeWithCollection") { TestData().test_validateMutation_cow_immutableBacking_replaceSubrangeWithCollection() }
+DataTests.test("test_validateMutation_cow_immutableBacking_replaceSubrangeWithBytes") { TestData().test_validateMutation_cow_immutableBacking_replaceSubrangeWithBytes() }
+DataTests.test("test_validateMutation_slice_cow_immutableBacking_withUnsafeMutableBytes") { TestData().test_validateMutation_slice_cow_immutableBacking_withUnsafeMutableBytes() }
+DataTests.test("test_validateMutation_slice_cow_immutableBacking_appendBytes") { TestData().test_validateMutation_slice_cow_immutableBacking_appendBytes() }
+DataTests.test("test_validateMutation_slice_cow_immutableBacking_appendData") { TestData().test_validateMutation_slice_cow_immutableBacking_appendData() }
+DataTests.test("test_validateMutation_slice_cow_immutableBacking_appendBuffer") { TestData().test_validateMutation_slice_cow_immutableBacking_appendBuffer() }
+DataTests.test("test_validateMutation_slice_cow_immutableBacking_appendSequence") { TestData().test_validateMutation_slice_cow_immutableBacking_appendSequence() }
+DataTests.test("test_validateMutation_slice_cow_immutableBacking_appendContentsOf") { TestData().test_validateMutation_slice_cow_immutableBacking_appendContentsOf() }
+DataTests.test("test_validateMutation_slice_cow_immutableBacking_resetBytes") { TestData().test_validateMutation_slice_cow_immutableBacking_resetBytes() }
+DataTests.test("test_validateMutation_slice_cow_immutableBacking_replaceSubrange") { TestData().test_validateMutation_slice_cow_immutableBacking_replaceSubrange() }
+DataTests.test("test_validateMutation_slice_cow_immutableBacking_replaceSubrangeCountableRange") { TestData().test_validateMutation_slice_cow_immutableBacking_replaceSubrangeCountableRange() }
+DataTests.test("test_validateMutation_slice_cow_immutableBacking_replaceSubrangeWithBuffer") { TestData().test_validateMutation_slice_cow_immutableBacking_replaceSubrangeWithBuffer() }
+DataTests.test("test_validateMutation_slice_cow_immutableBacking_replaceSubrangeWithCollection") { TestData().test_validateMutation_slice_cow_immutableBacking_replaceSubrangeWithCollection() }
+DataTests.test("test_validateMutation_slice_cow_immutableBacking_replaceSubrangeWithBytes") { TestData().test_validateMutation_slice_cow_immutableBacking_replaceSubrangeWithBytes() }
+DataTests.test("test_validateMutation_mutableBacking_withUnsafeMutableBytes") { TestData().test_validateMutation_mutableBacking_withUnsafeMutableBytes() }
+DataTests.test("test_validateMutation_mutableBacking_appendBytes") { TestData().test_validateMutation_mutableBacking_appendBytes() }
+DataTests.test("test_validateMutation_mutableBacking_appendData") { TestData().test_validateMutation_mutableBacking_appendData() }
+DataTests.test("test_validateMutation_mutableBacking_appendBuffer") { TestData().test_validateMutation_mutableBacking_appendBuffer() }
+DataTests.test("test_validateMutation_mutableBacking_appendSequence") { TestData().test_validateMutation_mutableBacking_appendSequence() }
+DataTests.test("test_validateMutation_mutableBacking_appendContentsOf") { TestData().test_validateMutation_mutableBacking_appendContentsOf() }
+DataTests.test("test_validateMutation_mutableBacking_resetBytes") { TestData().test_validateMutation_mutableBacking_resetBytes() }
+DataTests.test("test_validateMutation_mutableBacking_replaceSubrange") { TestData().test_validateMutation_mutableBacking_replaceSubrange() }
+DataTests.test("test_validateMutation_mutableBacking_replaceSubrangeCountableRange") { TestData().test_validateMutation_mutableBacking_replaceSubrangeCountableRange() }
+DataTests.test("test_validateMutation_mutableBacking_replaceSubrangeWithBuffer") { TestData().test_validateMutation_mutableBacking_replaceSubrangeWithBuffer() }
+DataTests.test("test_validateMutation_mutableBacking_replaceSubrangeWithCollection") { TestData().test_validateMutation_mutableBacking_replaceSubrangeWithCollection() }
+DataTests.test("test_validateMutation_mutableBacking_replaceSubrangeWithBytes") { TestData().test_validateMutation_mutableBacking_replaceSubrangeWithBytes() }
+DataTests.test("test_validateMutation_slice_mutableBacking_withUnsafeMutableBytes") { TestData().test_validateMutation_slice_mutableBacking_withUnsafeMutableBytes() }
+DataTests.test("test_validateMutation_slice_mutableBacking_appendBytes") { TestData().test_validateMutation_slice_mutableBacking_appendBytes() }
+DataTests.test("test_validateMutation_slice_mutableBacking_appendData") { TestData().test_validateMutation_slice_mutableBacking_appendData() }
+DataTests.test("test_validateMutation_slice_mutableBacking_appendBuffer") { TestData().test_validateMutation_slice_mutableBacking_appendBuffer() }
+DataTests.test("test_validateMutation_slice_mutableBacking_appendSequence") { TestData().test_validateMutation_slice_mutableBacking_appendSequence() }
+DataTests.test("test_validateMutation_slice_mutableBacking_appendContentsOf") { TestData().test_validateMutation_slice_mutableBacking_appendContentsOf() }
+DataTests.test("test_validateMutation_slice_mutableBacking_resetBytes") { TestData().test_validateMutation_slice_mutableBacking_resetBytes() }
+DataTests.test("test_validateMutation_slice_mutableBacking_replaceSubrange") { TestData().test_validateMutation_slice_mutableBacking_replaceSubrange() }
+DataTests.test("test_validateMutation_slice_mutableBacking_replaceSubrangeCountableRange") { TestData().test_validateMutation_slice_mutableBacking_replaceSubrangeCountableRange() }
+DataTests.test("test_validateMutation_slice_mutableBacking_replaceSubrangeWithBuffer") { TestData().test_validateMutation_slice_mutableBacking_replaceSubrangeWithBuffer() }
+DataTests.test("test_validateMutation_slice_mutableBacking_replaceSubrangeWithCollection") { TestData().test_validateMutation_slice_mutableBacking_replaceSubrangeWithCollection() }
+DataTests.test("test_validateMutation_slice_mutableBacking_replaceSubrangeWithBytes") { TestData().test_validateMutation_slice_mutableBacking_replaceSubrangeWithBytes() }
+DataTests.test("test_validateMutation_cow_mutableBacking_withUnsafeMutableBytes") { TestData().test_validateMutation_cow_mutableBacking_withUnsafeMutableBytes() }
+DataTests.test("test_validateMutation_cow_mutableBacking_appendBytes") { TestData().test_validateMutation_cow_mutableBacking_appendBytes() }
+DataTests.test("test_validateMutation_cow_mutableBacking_appendData") { TestData().test_validateMutation_cow_mutableBacking_appendData() }
+DataTests.test("test_validateMutation_cow_mutableBacking_appendBuffer") { TestData().test_validateMutation_cow_mutableBacking_appendBuffer() }
+DataTests.test("test_validateMutation_cow_mutableBacking_appendSequence") { TestData().test_validateMutation_cow_mutableBacking_appendSequence() }
+DataTests.test("test_validateMutation_cow_mutableBacking_appendContentsOf") { TestData().test_validateMutation_cow_mutableBacking_appendContentsOf() }
+DataTests.test("test_validateMutation_cow_mutableBacking_resetBytes") { TestData().test_validateMutation_cow_mutableBacking_resetBytes() }
+DataTests.test("test_validateMutation_cow_mutableBacking_replaceSubrange") { TestData().test_validateMutation_cow_mutableBacking_replaceSubrange() }
+DataTests.test("test_validateMutation_cow_mutableBacking_replaceSubrangeCountableRange") { TestData().test_validateMutation_cow_mutableBacking_replaceSubrangeCountableRange() }
+DataTests.test("test_validateMutation_cow_mutableBacking_replaceSubrangeWithBuffer") { TestData().test_validateMutation_cow_mutableBacking_replaceSubrangeWithBuffer() }
+DataTests.test("test_validateMutation_cow_mutableBacking_replaceSubrangeWithCollection") { TestData().test_validateMutation_cow_mutableBacking_replaceSubrangeWithCollection() }
+DataTests.test("test_validateMutation_cow_mutableBacking_replaceSubrangeWithBytes") { TestData().test_validateMutation_cow_mutableBacking_replaceSubrangeWithBytes() }
+DataTests.test("test_validateMutation_slice_cow_mutableBacking_withUnsafeMutableBytes") { TestData().test_validateMutation_slice_cow_mutableBacking_withUnsafeMutableBytes() }
+DataTests.test("test_validateMutation_slice_cow_mutableBacking_appendBytes") { TestData().test_validateMutation_slice_cow_mutableBacking_appendBytes() }
+DataTests.test("test_validateMutation_slice_cow_mutableBacking_appendData") { TestData().test_validateMutation_slice_cow_mutableBacking_appendData() }
+DataTests.test("test_validateMutation_slice_cow_mutableBacking_appendBuffer") { TestData().test_validateMutation_slice_cow_mutableBacking_appendBuffer() }
+DataTests.test("test_validateMutation_slice_cow_mutableBacking_appendSequence") { TestData().test_validateMutation_slice_cow_mutableBacking_appendSequence() }
+DataTests.test("test_validateMutation_slice_cow_mutableBacking_appendContentsOf") { TestData().test_validateMutation_slice_cow_mutableBacking_appendContentsOf() }
+DataTests.test("test_validateMutation_slice_cow_mutableBacking_resetBytes") { TestData().test_validateMutation_slice_cow_mutableBacking_resetBytes() }
+DataTests.test("test_validateMutation_slice_cow_mutableBacking_replaceSubrange") { TestData().test_validateMutation_slice_cow_mutableBacking_replaceSubrange() }
+DataTests.test("test_validateMutation_slice_cow_mutableBacking_replaceSubrangeCountableRange") { TestData().test_validateMutation_slice_cow_mutableBacking_replaceSubrangeCountableRange() }
+DataTests.test("test_validateMutation_slice_cow_mutableBacking_replaceSubrangeWithBuffer") { TestData().test_validateMutation_slice_cow_mutableBacking_replaceSubrangeWithBuffer() }
+DataTests.test("test_validateMutation_slice_cow_mutableBacking_replaceSubrangeWithCollection") { TestData().test_validateMutation_slice_cow_mutableBacking_replaceSubrangeWithCollection() }
+DataTests.test("test_validateMutation_slice_cow_mutableBacking_replaceSubrangeWithBytes") { TestData().test_validateMutation_slice_cow_mutableBacking_replaceSubrangeWithBytes() }
+DataTests.test("test_validateMutation_customBacking_withUnsafeMutableBytes") { TestData().test_validateMutation_customBacking_withUnsafeMutableBytes() }
+DataTests.test("test_validateMutation_customBacking_appendBytes") { TestData().test_validateMutation_customBacking_appendBytes() }
+DataTests.test("test_validateMutation_customBacking_appendData") { TestData().test_validateMutation_customBacking_appendData() }
+DataTests.test("test_validateMutation_customBacking_appendBuffer") { TestData().test_validateMutation_customBacking_appendBuffer() }
+DataTests.test("test_validateMutation_customBacking_appendSequence") { TestData().test_validateMutation_customBacking_appendSequence() }
+DataTests.test("test_validateMutation_customBacking_appendContentsOf") { TestData().test_validateMutation_customBacking_appendContentsOf() }
+DataTests.test("test_validateMutation_customBacking_resetBytes") { TestData().test_validateMutation_customBacking_resetBytes() }
+DataTests.test("test_validateMutation_customBacking_replaceSubrange") { TestData().test_validateMutation_customBacking_replaceSubrange() }
+DataTests.test("test_validateMutation_customBacking_replaceSubrangeCountableRange") { TestData().test_validateMutation_customBacking_replaceSubrangeCountableRange() }
+DataTests.test("test_validateMutation_customBacking_replaceSubrangeWithBuffer") { TestData().test_validateMutation_customBacking_replaceSubrangeWithBuffer() }
+DataTests.test("test_validateMutation_customBacking_replaceSubrangeWithCollection") { TestData().test_validateMutation_customBacking_replaceSubrangeWithCollection() }
+DataTests.test("test_validateMutation_customBacking_replaceSubrangeWithBytes") { TestData().test_validateMutation_customBacking_replaceSubrangeWithBytes() }
+DataTests.test("test_validateMutation_slice_customBacking_withUnsafeMutableBytes") { TestData().test_validateMutation_slice_customBacking_withUnsafeMutableBytes() }
+DataTests.test("test_validateMutation_slice_customBacking_appendBytes") { TestData().test_validateMutation_slice_customBacking_appendBytes() }
+DataTests.test("test_validateMutation_slice_customBacking_appendData") { TestData().test_validateMutation_slice_customBacking_appendData() }
+DataTests.test("test_validateMutation_slice_customBacking_appendBuffer") { TestData().test_validateMutation_slice_customBacking_appendBuffer() }
+DataTests.test("test_validateMutation_slice_customBacking_appendSequence") { TestData().test_validateMutation_slice_customBacking_appendSequence() }
+DataTests.test("test_validateMutation_slice_customBacking_appendContentsOf") { TestData().test_validateMutation_slice_customBacking_appendContentsOf() }
+DataTests.test("test_validateMutation_slice_customBacking_resetBytes") { TestData().test_validateMutation_slice_customBacking_resetBytes() }
+DataTests.test("test_validateMutation_slice_customBacking_replaceSubrange") { TestData().test_validateMutation_slice_customBacking_replaceSubrange() }
+DataTests.test("test_validateMutation_slice_customBacking_replaceSubrangeCountableRange") { TestData().test_validateMutation_slice_customBacking_replaceSubrangeCountableRange() }
+DataTests.test("test_validateMutation_slice_customBacking_replaceSubrangeWithBuffer") { TestData().test_validateMutation_slice_customBacking_replaceSubrangeWithBuffer() }
+DataTests.test("test_validateMutation_slice_customBacking_replaceSubrangeWithCollection") { TestData().test_validateMutation_slice_customBacking_replaceSubrangeWithCollection() }
+DataTests.test("test_validateMutation_slice_customBacking_replaceSubrangeWithBytes") { TestData().test_validateMutation_slice_customBacking_replaceSubrangeWithBytes() }
+DataTests.test("test_validateMutation_cow_customBacking_withUnsafeMutableBytes") { TestData().test_validateMutation_cow_customBacking_withUnsafeMutableBytes() }
+DataTests.test("test_validateMutation_cow_customBacking_appendBytes") { TestData().test_validateMutation_cow_customBacking_appendBytes() }
+DataTests.test("test_validateMutation_cow_customBacking_appendData") { TestData().test_validateMutation_cow_customBacking_appendData() }
+DataTests.test("test_validateMutation_cow_customBacking_appendBuffer") { TestData().test_validateMutation_cow_customBacking_appendBuffer() }
+DataTests.test("test_validateMutation_cow_customBacking_appendSequence") { TestData().test_validateMutation_cow_customBacking_appendSequence() }
+DataTests.test("test_validateMutation_cow_customBacking_appendContentsOf") { TestData().test_validateMutation_cow_customBacking_appendContentsOf() }
+DataTests.test("test_validateMutation_cow_customBacking_resetBytes") { TestData().test_validateMutation_cow_customBacking_resetBytes() }
+DataTests.test("test_validateMutation_cow_customBacking_replaceSubrange") { TestData().test_validateMutation_cow_customBacking_replaceSubrange() }
+DataTests.test("test_validateMutation_cow_customBacking_replaceSubrangeCountableRange") { TestData().test_validateMutation_cow_customBacking_replaceSubrangeCountableRange() }
+DataTests.test("test_validateMutation_cow_customBacking_replaceSubrangeWithBuffer") { TestData().test_validateMutation_cow_customBacking_replaceSubrangeWithBuffer() }
+DataTests.test("test_validateMutation_cow_customBacking_replaceSubrangeWithCollection") { TestData().test_validateMutation_cow_customBacking_replaceSubrangeWithCollection() }
+DataTests.test("test_validateMutation_cow_customBacking_replaceSubrangeWithBytes") { TestData().test_validateMutation_cow_customBacking_replaceSubrangeWithBytes() }
+DataTests.test("test_validateMutation_slice_cow_customBacking_withUnsafeMutableBytes") { TestData().test_validateMutation_slice_cow_customBacking_withUnsafeMutableBytes() }
+DataTests.test("test_validateMutation_slice_cow_customBacking_appendBytes") { TestData().test_validateMutation_slice_cow_customBacking_appendBytes() }
+DataTests.test("test_validateMutation_slice_cow_customBacking_appendData") { TestData().test_validateMutation_slice_cow_customBacking_appendData() }
+DataTests.test("test_validateMutation_slice_cow_customBacking_appendBuffer") { TestData().test_validateMutation_slice_cow_customBacking_appendBuffer() }
+DataTests.test("test_validateMutation_slice_cow_customBacking_appendSequence") { TestData().test_validateMutation_slice_cow_customBacking_appendSequence() }
+DataTests.test("test_validateMutation_slice_cow_customBacking_appendContentsOf") { TestData().test_validateMutation_slice_cow_customBacking_appendContentsOf() }
+DataTests.test("test_validateMutation_slice_cow_customBacking_resetBytes") { TestData().test_validateMutation_slice_cow_customBacking_resetBytes() }
+DataTests.test("test_validateMutation_slice_cow_customBacking_replaceSubrange") { TestData().test_validateMutation_slice_cow_customBacking_replaceSubrange() }
+DataTests.test("test_validateMutation_slice_cow_customBacking_replaceSubrangeCountableRange") { TestData().test_validateMutation_slice_cow_customBacking_replaceSubrangeCountableRange() }
+DataTests.test("test_validateMutation_slice_cow_customBacking_replaceSubrangeWithBuffer") { TestData().test_validateMutation_slice_cow_customBacking_replaceSubrangeWithBuffer() }
+DataTests.test("test_validateMutation_slice_cow_customBacking_replaceSubrangeWithCollection") { TestData().test_validateMutation_slice_cow_customBacking_replaceSubrangeWithCollection() }
+DataTests.test("test_validateMutation_slice_cow_customBacking_replaceSubrangeWithBytes") { TestData().test_validateMutation_slice_cow_customBacking_replaceSubrangeWithBytes() }
+DataTests.test("test_validateMutation_customMutableBacking_withUnsafeMutableBytes") { TestData().test_validateMutation_customMutableBacking_withUnsafeMutableBytes() }
+DataTests.test("test_validateMutation_customMutableBacking_appendBytes") { TestData().test_validateMutation_customMutableBacking_appendBytes() }
+DataTests.test("test_validateMutation_customMutableBacking_appendData") { TestData().test_validateMutation_customMutableBacking_appendData() }
+DataTests.test("test_validateMutation_customMutableBacking_appendBuffer") { TestData().test_validateMutation_customMutableBacking_appendBuffer() }
+DataTests.test("test_validateMutation_customMutableBacking_appendSequence") { TestData().test_validateMutation_customMutableBacking_appendSequence() }
+DataTests.test("test_validateMutation_customMutableBacking_appendContentsOf") { TestData().test_validateMutation_customMutableBacking_appendContentsOf() }
+DataTests.test("test_validateMutation_customMutableBacking_resetBytes") { TestData().test_validateMutation_customMutableBacking_resetBytes() }
+DataTests.test("test_validateMutation_customMutableBacking_replaceSubrange") { TestData().test_validateMutation_customMutableBacking_replaceSubrange() }
+DataTests.test("test_validateMutation_customMutableBacking_replaceSubrangeCountableRange") { TestData().test_validateMutation_customMutableBacking_replaceSubrangeCountableRange() }
+DataTests.test("test_validateMutation_customMutableBacking_replaceSubrangeWithBuffer") { TestData().test_validateMutation_customMutableBacking_replaceSubrangeWithBuffer() }
+DataTests.test("test_validateMutation_customMutableBacking_replaceSubrangeWithCollection") { TestData().test_validateMutation_customMutableBacking_replaceSubrangeWithCollection() }
+DataTests.test("test_validateMutation_customMutableBacking_replaceSubrangeWithBytes") { TestData().test_validateMutation_customMutableBacking_replaceSubrangeWithBytes() }
+DataTests.test("test_validateMutation_slice_customMutableBacking_withUnsafeMutableBytes") { TestData().test_validateMutation_slice_customMutableBacking_withUnsafeMutableBytes() }
+DataTests.test("test_validateMutation_slice_customMutableBacking_appendBytes") { TestData().test_validateMutation_slice_customMutableBacking_appendBytes() }
+DataTests.test("test_validateMutation_slice_customMutableBacking_appendData") { TestData().test_validateMutation_slice_customMutableBacking_appendData() }
+DataTests.test("test_validateMutation_slice_customMutableBacking_appendBuffer") { TestData().test_validateMutation_slice_customMutableBacking_appendBuffer() }
+DataTests.test("test_validateMutation_slice_customMutableBacking_appendSequence") { TestData().test_validateMutation_slice_customMutableBacking_appendSequence() }
+DataTests.test("test_validateMutation_slice_customMutableBacking_appendContentsOf") { TestData().test_validateMutation_slice_customMutableBacking_appendContentsOf() }
+DataTests.test("test_validateMutation_slice_customMutableBacking_resetBytes") { TestData().test_validateMutation_slice_customMutableBacking_resetBytes() }
+DataTests.test("test_validateMutation_slice_customMutableBacking_replaceSubrange") { TestData().test_validateMutation_slice_customMutableBacking_replaceSubrange() }
+DataTests.test("test_validateMutation_slice_customMutableBacking_replaceSubrangeCountableRange") { TestData().test_validateMutation_slice_customMutableBacking_replaceSubrangeCountableRange() }
+DataTests.test("test_validateMutation_slice_customMutableBacking_replaceSubrangeWithBuffer") { TestData().test_validateMutation_slice_customMutableBacking_replaceSubrangeWithBuffer() }
+DataTests.test("test_validateMutation_slice_customMutableBacking_replaceSubrangeWithCollection") { TestData().test_validateMutation_slice_customMutableBacking_replaceSubrangeWithCollection() }
+DataTests.test("test_validateMutation_slice_customMutableBacking_replaceSubrangeWithBytes") { TestData().test_validateMutation_slice_customMutableBacking_replaceSubrangeWithBytes() }
+DataTests.test("test_validateMutation_cow_customMutableBacking_withUnsafeMutableBytes") { TestData().test_validateMutation_cow_customMutableBacking_withUnsafeMutableBytes() }
+DataTests.test("test_validateMutation_cow_customMutableBacking_appendBytes") { TestData().test_validateMutation_cow_customMutableBacking_appendBytes() }
+DataTests.test("test_validateMutation_cow_customMutableBacking_appendData") { TestData().test_validateMutation_cow_customMutableBacking_appendData() }
+DataTests.test("test_validateMutation_cow_customMutableBacking_appendBuffer") { TestData().test_validateMutation_cow_customMutableBacking_appendBuffer() }
+DataTests.test("test_validateMutation_cow_customMutableBacking_appendSequence") { TestData().test_validateMutation_cow_customMutableBacking_appendSequence() }
+DataTests.test("test_validateMutation_cow_customMutableBacking_appendContentsOf") { TestData().test_validateMutation_cow_customMutableBacking_appendContentsOf() }
+DataTests.test("test_validateMutation_cow_customMutableBacking_resetBytes") { TestData().test_validateMutation_cow_customMutableBacking_resetBytes() }
+DataTests.test("test_validateMutation_cow_customMutableBacking_replaceSubrange") { TestData().test_validateMutation_cow_customMutableBacking_replaceSubrange() }
+DataTests.test("test_validateMutation_cow_customMutableBacking_replaceSubrangeCountableRange") { TestData().test_validateMutation_cow_customMutableBacking_replaceSubrangeCountableRange() }
+DataTests.test("test_validateMutation_cow_customMutableBacking_replaceSubrangeWithBuffer") { TestData().test_validateMutation_cow_customMutableBacking_replaceSubrangeWithBuffer() }
+DataTests.test("test_validateMutation_cow_customMutableBacking_replaceSubrangeWithCollection") { TestData().test_validateMutation_cow_customMutableBacking_replaceSubrangeWithCollection() }
+DataTests.test("test_validateMutation_cow_customMutableBacking_replaceSubrangeWithBytes") { TestData().test_validateMutation_cow_customMutableBacking_replaceSubrangeWithBytes() }
+DataTests.test("test_validateMutation_slice_cow_customMutableBacking_withUnsafeMutableBytes") { TestData().test_validateMutation_slice_cow_customMutableBacking_withUnsafeMutableBytes() }
+DataTests.test("test_validateMutation_slice_cow_customMutableBacking_appendBytes") { TestData().test_validateMutation_slice_cow_customMutableBacking_appendBytes() }
+DataTests.test("test_validateMutation_slice_cow_customMutableBacking_appendData") { TestData().test_validateMutation_slice_cow_customMutableBacking_appendData() }
+DataTests.test("test_validateMutation_slice_cow_customMutableBacking_appendBuffer") { TestData().test_validateMutation_slice_cow_customMutableBacking_appendBuffer() }
+DataTests.test("test_validateMutation_slice_cow_customMutableBacking_appendSequence") { TestData().test_validateMutation_slice_cow_customMutableBacking_appendSequence() }
+DataTests.test("test_validateMutation_slice_cow_customMutableBacking_appendContentsOf") { TestData().test_validateMutation_slice_cow_customMutableBacking_appendContentsOf() }
+DataTests.test("test_validateMutation_slice_cow_customMutableBacking_resetBytes") { TestData().test_validateMutation_slice_cow_customMutableBacking_resetBytes() }
+DataTests.test("test_validateMutation_slice_cow_customMutableBacking_replaceSubrange") { TestData().test_validateMutation_slice_cow_customMutableBacking_replaceSubrange() }
+DataTests.test("test_validateMutation_slice_cow_customMutableBacking_replaceSubrangeCountableRange") { TestData().test_validateMutation_slice_cow_customMutableBacking_replaceSubrangeCountableRange() }
+DataTests.test("test_validateMutation_slice_cow_customMutableBacking_replaceSubrangeWithBuffer") { TestData().test_validateMutation_slice_cow_customMutableBacking_replaceSubrangeWithBuffer() }
+DataTests.test("test_validateMutation_slice_cow_customMutableBacking_replaceSubrangeWithCollection") { TestData().test_validateMutation_slice_cow_customMutableBacking_replaceSubrangeWithCollection() }
+DataTests.test("test_validateMutation_slice_cow_customMutableBacking_replaceSubrangeWithBytes") { TestData().test_validateMutation_slice_cow_customMutableBacking_replaceSubrangeWithBytes() }
+DataTests.test("test_sliceHash") { TestData().test_sliceHash() }
+DataTests.test("test_slice_resize_growth") { TestData().test_slice_resize_growth() }
+DataTests.test("test_sliceEnumeration") { TestData().test_sliceEnumeration() }
// XCTest does not have a crash detection, whereas lit does
