Merge pull request #826 from ikesyo/nsgeometry-operator-static-func
diff --git a/Docs/Status.md b/Docs/Status.md
index 92f3393..d47cabf 100644
--- a/Docs/Status.md
+++ b/Docs/Status.md
@@ -123,7 +123,7 @@
| Entity Name | Status | Test Coverage | Notes |
|-----------------------------|-----------------|---------------|-------------------------------------------------------------------------------|
| `NSJSONSerialization` | Mostly Complete | Substantial | `jsonObject(with:options:)` with streams remains unimplemented |
- | `NSKeyedArchiver` | Mostly Complete | Substantial | `init()` and `encodedData` remain unimplemented |
+ | `NSKeyedArchiver` | Complete | Substantial | |
| `NSKeyedCoderOldStyleArray` | N/A | N/A | For internal use only |
| `NSKeyedUnarchiver` | Mostly Complete | Substantial | `decodingFailurePolicy.set` remains unimplemented |
| `NSKeyedArchiverHelpers` | N/A | N/A | For internal use only |
diff --git a/Foundation/Data.swift b/Foundation/Data.swift
index 842f1ea..5bfdfe3 100644
--- a/Foundation/Data.swift
+++ b/Foundation/Data.swift
@@ -1277,7 +1277,7 @@
/// - parameter buffer: The buffer of bytes to append. The size is calculated from `SourceType` and `buffer.count`.
@inline(__always)
public mutating func append<SourceType>(_ buffer : UnsafeBufferPointer<SourceType>) {
- if buffer.count == 0 { return }
+ if buffer.isEmpty { return }
if !isKnownUniquelyReferenced(&_backing) {
_backing = _backing.mutableCopy()
}
diff --git a/Foundation/Locale.swift b/Foundation/Locale.swift
index f5b9eab..29b58ba 100644
--- a/Foundation/Locale.swift
+++ b/Foundation/Locale.swift
@@ -428,13 +428,13 @@
return _wrapped.hash
}
}
-}
-public func ==(lhs: Locale, rhs: Locale) -> Bool {
- if lhs._autoupdating || rhs._autoupdating {
- return lhs._autoupdating == rhs._autoupdating
- } else {
- return lhs._wrapped.isEqual(rhs._wrapped)
+ public static func ==(lhs: Locale, rhs: Locale) -> Bool {
+ if lhs._autoupdating || rhs._autoupdating {
+ return lhs._autoupdating == rhs._autoupdating
+ } else {
+ return lhs._wrapped.isEqual(rhs._wrapped)
+ }
}
}
diff --git a/Foundation/NSCFArray.swift b/Foundation/NSCFArray.swift
index 17a13cf..b7ba101 100644
--- a/Foundation/NSCFArray.swift
+++ b/Foundation/NSCFArray.swift
@@ -62,7 +62,7 @@
} else {
let value = _SwiftValue.store(arr.object(at: index))
let container: NSMutableDictionary
- if arr._storage.count == 0 {
+ if arr._storage.isEmpty {
container = NSMutableDictionary()
arr._storage.append(container)
} else {
@@ -84,7 +84,7 @@
let index = idx + range.location
let value = _SwiftValue.store(arr.object(at: index))
let container: NSMutableDictionary
- if arr._storage.count == 0 {
+ if arr._storage.isEmpty {
container = NSMutableDictionary()
arr._storage.append(container)
} else {
diff --git a/Foundation/NSCalendar.swift b/Foundation/NSCalendar.swift
index 3391919..d350d6f 100644
--- a/Foundation/NSCalendar.swift
+++ b/Foundation/NSCalendar.swift
@@ -112,12 +112,14 @@
}
}
-public func ==(_ lhs: NSCalendar.Identifier, _ rhs: NSCalendar.Identifier) -> Bool {
- return lhs.rawValue == rhs.rawValue
-}
+extension NSCalendar.Identifier {
+ public static func ==(_ lhs: NSCalendar.Identifier, _ rhs: NSCalendar.Identifier) -> Bool {
+ return lhs.rawValue == rhs.rawValue
+ }
-public func <(_ lhs: NSCalendar.Identifier, _ rhs: NSCalendar.Identifier) -> Bool {
- return lhs.rawValue < rhs.rawValue
+ public static func <(_ lhs: NSCalendar.Identifier, _ rhs: NSCalendar.Identifier) -> Bool {
+ return lhs.rawValue < rhs.rawValue
+ }
}
open class NSCalendar : NSObject, NSCopying, NSSecureCoding {
@@ -603,8 +605,7 @@
}
return vector.withUnsafeMutableBufferPointer { (vecBuffer: inout UnsafeMutableBufferPointer<UnsafeMutablePointer<Int32>>) in
- _CFCalendarGetComponentDifferenceV(_cfObject, startingDate.timeIntervalSinceReferenceDate, resultDate.timeIntervalSinceReferenceDate, CFOptionFlags(opts.rawValue), compDesc, vecBuffer.baseAddress!, Int32(vector.count))
- return false
+ return _CFCalendarGetComponentDifferenceV(_cfObject, startingDate.timeIntervalSinceReferenceDate, resultDate.timeIntervalSinceReferenceDate, CFOptionFlags(opts.rawValue), compDesc, vecBuffer.baseAddress!, Int32(vector.count))
}
}
if res {
diff --git a/Foundation/NSCompoundPredicate.swift b/Foundation/NSCompoundPredicate.swift
index c7a83ac..0efd6ab 100644
--- a/Foundation/NSCompoundPredicate.swift
+++ b/Foundation/NSCompoundPredicate.swift
@@ -20,7 +20,7 @@
open class NSCompoundPredicate : NSPredicate {
public init(type: LogicalType, subpredicates: [NSPredicate]) {
- if type == .not && subpredicates.count == 0 {
+ if type == .not && subpredicates.isEmpty {
preconditionFailure("Unsupported predicate count of \(subpredicates.count) for \(type)")
}
diff --git a/Foundation/NSData.swift b/Foundation/NSData.swift
index 0d1918b..fe42548 100644
--- a/Foundation/NSData.swift
+++ b/Foundation/NSData.swift
@@ -800,7 +800,7 @@
if options.contains(.endLineWithLineFeed) { separator.append(10) }
//if the kind of line ending to insert is not specified, the default line ending is Carriage Return + Line Feed.
- if separator.count == 0 {separator = [13,10]}
+ if separator.isEmpty { separator = [13,10] }
return (lineLength,separator)
}()
diff --git a/Foundation/NSGeometry.swift b/Foundation/NSGeometry.swift
index 8fc702a..7730764 100644
--- a/Foundation/NSGeometry.swift
+++ b/Foundation/NSGeometry.swift
@@ -321,38 +321,38 @@
}
}
-public struct NSAlignmentOptions : OptionSet {
+public struct AlignmentOptions : OptionSet {
public var rawValue : UInt64
public init(rawValue: UInt64) { self.rawValue = rawValue }
- public static let AlignMinXInward = NSAlignmentOptions(rawValue: 1 << 0)
- public static let AlignMinYInward = NSAlignmentOptions(rawValue: 1 << 1)
- public static let AlignMaxXInward = NSAlignmentOptions(rawValue: 1 << 2)
- public static let AlignMaxYInward = NSAlignmentOptions(rawValue: 1 << 3)
- public static let AlignWidthInward = NSAlignmentOptions(rawValue: 1 << 4)
- public static let AlignHeightInward = NSAlignmentOptions(rawValue: 1 << 5)
+ public static let alignMinXInward = AlignmentOptions(rawValue: 1 << 0)
+ public static let alignMinYInward = AlignmentOptions(rawValue: 1 << 1)
+ public static let alignMaxXInward = AlignmentOptions(rawValue: 1 << 2)
+ public static let alignMaxYInward = AlignmentOptions(rawValue: 1 << 3)
+ public static let alignWidthInward = AlignmentOptions(rawValue: 1 << 4)
+ public static let alignHeightInward = AlignmentOptions(rawValue: 1 << 5)
- public static let AlignMinXOutward = NSAlignmentOptions(rawValue: 1 << 8)
- public static let AlignMinYOutward = NSAlignmentOptions(rawValue: 1 << 9)
- public static let AlignMaxXOutward = NSAlignmentOptions(rawValue: 1 << 10)
- public static let AlignMaxYOutward = NSAlignmentOptions(rawValue: 1 << 11)
- public static let AlignWidthOutward = NSAlignmentOptions(rawValue: 1 << 12)
- public static let AlignHeightOutward = NSAlignmentOptions(rawValue: 1 << 13)
+ public static let alignMinXOutward = AlignmentOptions(rawValue: 1 << 8)
+ public static let alignMinYOutward = AlignmentOptions(rawValue: 1 << 9)
+ public static let alignMaxXOutward = AlignmentOptions(rawValue: 1 << 10)
+ public static let alignMaxYOutward = AlignmentOptions(rawValue: 1 << 11)
+ public static let alignWidthOutward = AlignmentOptions(rawValue: 1 << 12)
+ public static let alignHeightOutward = AlignmentOptions(rawValue: 1 << 13)
- public static let AlignMinXNearest = NSAlignmentOptions(rawValue: 1 << 16)
- public static let AlignMinYNearest = NSAlignmentOptions(rawValue: 1 << 17)
- public static let AlignMaxXNearest = NSAlignmentOptions(rawValue: 1 << 18)
- public static let AlignMaxYNearest = NSAlignmentOptions(rawValue: 1 << 19)
- public static let AlignWidthNearest = NSAlignmentOptions(rawValue: 1 << 20)
- public static let AlignHeightNearest = NSAlignmentOptions(rawValue: 1 << 21)
+ public static let alignMinXNearest = AlignmentOptions(rawValue: 1 << 16)
+ public static let alignMinYNearest = AlignmentOptions(rawValue: 1 << 17)
+ public static let alignMaxXNearest = AlignmentOptions(rawValue: 1 << 18)
+ public static let alignMaxYNearest = AlignmentOptions(rawValue: 1 << 19)
+ public static let alignWidthNearest = AlignmentOptions(rawValue: 1 << 20)
+ public static let alignHeightNearest = AlignmentOptions(rawValue: 1 << 21)
// pass this if the rect is in a flipped coordinate system. This allows 0.5 to be treated in a visually consistent way.
- public static let AlignRectFlipped = NSAlignmentOptions(rawValue: 1 << 63)
+ public static let alignRectFlipped = AlignmentOptions(rawValue: 1 << 63)
// convenience combinations
- public static let AlignAllEdgesInward = [NSAlignmentOptions.AlignMinXInward, NSAlignmentOptions.AlignMaxXInward, NSAlignmentOptions.AlignMinYInward, NSAlignmentOptions.AlignMaxYInward]
- public static let AlignAllEdgesOutward = [NSAlignmentOptions.AlignMinXOutward, NSAlignmentOptions.AlignMaxXOutward, NSAlignmentOptions.AlignMinYOutward, NSAlignmentOptions.AlignMaxYOutward]
- public static let AlignAllEdgesNearest = [NSAlignmentOptions.AlignMinXNearest, NSAlignmentOptions.AlignMaxXNearest, NSAlignmentOptions.AlignMinYNearest, NSAlignmentOptions.AlignMaxYNearest]
+ public static let alignAllEdgesInward: AlignmentOptions = [.alignMinXInward, .alignMaxXInward, .alignMinYInward, .alignMaxYInward]
+ public static let alignAllEdgesOutward: AlignmentOptions = [.alignMinXOutward, .alignMaxXOutward, .alignMinYOutward, .alignMaxYOutward]
+ public static let alignAllEdgesNearest: AlignmentOptions = [.alignMinXNearest, .alignMaxXNearest, .alignMinYNearest, .alignMaxYNearest]
}
public let NSZeroPoint: NSPoint = NSPoint()
@@ -429,12 +429,12 @@
return NSZeroRect
}
- return NSIntegralRectWithOptions(aRect, [.AlignMinXOutward, .AlignMaxXOutward, .AlignMinYOutward, .AlignMaxYOutward])
+ return NSIntegralRectWithOptions(aRect, [.alignMinXOutward, .alignMaxXOutward, .alignMinYOutward, .alignMaxYOutward])
}
-public func NSIntegralRectWithOptions(_ aRect: NSRect, _ opts: NSAlignmentOptions) -> NSRect {
+public func NSIntegralRectWithOptions(_ aRect: NSRect, _ opts: AlignmentOptions) -> NSRect {
let listOfOptionsIsInconsistentErrorMessage = "List of options is inconsistent"
- if opts.contains(.AlignRectFlipped) {
+ if opts.contains(.alignRectFlipped) {
NSUnimplemented()
}
@@ -453,81 +453,81 @@
}
- if opts.contains(.AlignWidthInward) && width != 0 {
+ if opts.contains(.alignWidthInward) && width != 0 {
guard width.isNaN else { fatalError(listOfOptionsIsInconsistentErrorMessage) }
width = floor(aRect.size.width.native)
}
- if opts.contains(.AlignHeightInward) && height != 0 {
+ if opts.contains(.alignHeightInward) && height != 0 {
guard height.isNaN else { fatalError(listOfOptionsIsInconsistentErrorMessage) }
height = floor(aRect.size.height.native)
}
- if opts.contains(.AlignWidthOutward) && width != 0 {
+ if opts.contains(.alignWidthOutward) && width != 0 {
guard width.isNaN else { fatalError(listOfOptionsIsInconsistentErrorMessage) }
width = ceil(aRect.size.width.native)
}
- if opts.contains(.AlignHeightOutward) && height != 0 {
+ if opts.contains(.alignHeightOutward) && height != 0 {
guard height.isNaN else { fatalError(listOfOptionsIsInconsistentErrorMessage) }
height = ceil(aRect.size.height.native)
}
- if opts.contains(.AlignWidthNearest) && width != 0 {
+ if opts.contains(.alignWidthNearest) && width != 0 {
guard width.isNaN else { fatalError(listOfOptionsIsInconsistentErrorMessage) }
width = round(aRect.size.width.native)
}
- if opts.contains(.AlignHeightNearest) && height != 0 {
+ if opts.contains(.alignHeightNearest) && height != 0 {
guard height.isNaN else { fatalError(listOfOptionsIsInconsistentErrorMessage) }
height = round(aRect.size.height.native)
}
- if opts.contains(.AlignMinXInward) {
+ if opts.contains(.alignMinXInward) {
guard minX.isNaN else { fatalError(listOfOptionsIsInconsistentErrorMessage) }
minX = ceil(aRect.origin.x.native)
}
- if opts.contains(.AlignMinYInward) {
+ if opts.contains(.alignMinYInward) {
guard minY.isNaN else { fatalError(listOfOptionsIsInconsistentErrorMessage) }
minY = ceil(aRect.origin.y.native)
}
- if opts.contains(.AlignMaxXInward) {
+ if opts.contains(.alignMaxXInward) {
guard maxX.isNaN else { fatalError(listOfOptionsIsInconsistentErrorMessage) }
maxX = floor(aRect.origin.x.native + aRect.size.width.native)
}
- if opts.contains(.AlignMaxYInward) {
+ if opts.contains(.alignMaxYInward) {
guard maxY.isNaN else { fatalError(listOfOptionsIsInconsistentErrorMessage) }
maxY = floor(aRect.origin.y.native + aRect.size.height.native)
}
- if opts.contains(.AlignMinXOutward) {
+ if opts.contains(.alignMinXOutward) {
guard minX.isNaN else { fatalError(listOfOptionsIsInconsistentErrorMessage) }
minX = floor(aRect.origin.x.native)
}
- if opts.contains(.AlignMinYOutward) {
+ if opts.contains(.alignMinYOutward) {
guard minY.isNaN else { fatalError(listOfOptionsIsInconsistentErrorMessage) }
minY = floor(aRect.origin.y.native)
}
- if opts.contains(.AlignMaxXOutward) {
+ if opts.contains(.alignMaxXOutward) {
guard maxX.isNaN else { fatalError(listOfOptionsIsInconsistentErrorMessage) }
maxX = ceil(aRect.origin.x.native + aRect.size.width.native)
}
- if opts.contains(.AlignMaxYOutward) {
+ if opts.contains(.alignMaxYOutward) {
guard maxY.isNaN else { fatalError(listOfOptionsIsInconsistentErrorMessage) }
maxY = ceil(aRect.origin.y.native + aRect.size.height.native)
}
- if opts.contains(.AlignMinXNearest) {
+ if opts.contains(.alignMinXNearest) {
guard minX.isNaN else { fatalError(listOfOptionsIsInconsistentErrorMessage) }
minX = round(aRect.origin.x.native)
}
- if opts.contains(.AlignMinYNearest) {
+ if opts.contains(.alignMinYNearest) {
guard minY.isNaN else { fatalError(listOfOptionsIsInconsistentErrorMessage) }
minY = round(aRect.origin.y.native)
}
- if opts.contains(.AlignMaxXNearest) {
+ if opts.contains(.alignMaxXNearest) {
guard maxX.isNaN else { fatalError(listOfOptionsIsInconsistentErrorMessage) }
maxX = round(aRect.origin.x.native + aRect.size.width.native)
}
- if opts.contains(.AlignMaxYNearest) {
+ if opts.contains(.alignMaxYNearest) {
guard maxY.isNaN else { fatalError(listOfOptionsIsInconsistentErrorMessage) }
maxY = round(aRect.origin.y.native + aRect.size.height.native)
}
diff --git a/Foundation/NSHTTPCookie.swift b/Foundation/NSHTTPCookie.swift
index f78dd5d..73563c7 100644
--- a/Foundation/NSHTTPCookie.swift
+++ b/Foundation/NSHTTPCookie.swift
@@ -255,7 +255,7 @@
_domain = canonicalDomain
if let
- secureString = properties[.secure] as? String, secureString.characters.count > 0
+ secureString = properties[.secure] as? String, !secureString.characters.isEmpty
{
_secure = true
} else {
diff --git a/Foundation/NSIndexSet.swift b/Foundation/NSIndexSet.swift
index 7b0cf52..6c5490d 100644
--- a/Foundation/NSIndexSet.swift
+++ b/Foundation/NSIndexSet.swift
@@ -133,7 +133,7 @@
return _ranges.first?.location ?? NSNotFound
}
open var lastIndex: Int {
- guard _ranges.count > 0 else {
+ guard !_ranges.isEmpty else {
return NSNotFound
}
return NSMaxRange(_ranges.last!) - 1
@@ -557,7 +557,7 @@
internal func _mergeOverlappingRangesStartingAtIndex(_ index: Int) {
var rangeIndex = index
- while _ranges.count > 0 && rangeIndex < _ranges.count - 1 {
+ while !_ranges.isEmpty && rangeIndex < _ranges.count - 1 {
let curRange = _ranges[rangeIndex]
let nextRange = _ranges[rangeIndex + 1]
let curEnd = NSMaxRange(curRange)
diff --git a/Foundation/NSKeyedArchiver.swift b/Foundation/NSKeyedArchiver.swift
index e4298b4..476ca03 100644
--- a/Foundation/NSKeyedArchiver.swift
+++ b/Foundation/NSKeyedArchiver.swift
@@ -126,8 +126,8 @@
return finishedEncoding
}
- public override init() {
- NSUnimplemented()
+ public override convenience init() {
+ self.init(forWritingWith: NSMutableData())
}
private init(output: AnyObject) {
@@ -165,7 +165,12 @@
/// If encoding has not yet finished, then invoking this property will call finishEncoding and return the data. If you initialized the keyed archiver with a specific mutable data instance, then it will be returned from this property after finishEncoding is called.
open var encodedData: Data {
- NSUnimplemented()
+
+ if !_flags.contains(.finishedEncoding) {
+ finishEncoding()
+ }
+
+ return (_stream as! NSData)._swiftObject
}
open func finishEncoding() {
@@ -428,7 +433,7 @@
if let ns = clsv as? NSObject.Type {
let classHints = ns.classFallbacksForKeyedArchiver()
- if classHints.count > 0 {
+ if !classHints.isEmpty {
classDict["$classhints"] = classHints
}
}
diff --git a/Foundation/NSObject.swift b/Foundation/NSObject.swift
index 9bb2e53..df463f3 100644
--- a/Foundation/NSObject.swift
+++ b/Foundation/NSObject.swift
@@ -7,30 +7,78 @@
// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
-
import CoreFoundation
-public protocol NSObjectProtocol: class {
+/// The `NSObjectProtocol` groups methods that are fundamental to all Foundation objects.
+///
+/// If an object conforms to this protocol, it can be considered a first-class object.
+///
+/// The Cocoa root class, NSObject, adopts this protocol, so all objects inheriting
+/// from NSObject have the features described by this protocol.
+public protocol NSObjectProtocol : class {
+ /// Returns a Boolean value that indicates whether the instance
+ /// and a given `object` are equal.
+ ///
+ /// This method defines what it means for instances to be equal. For example, a container
+ /// object might define two containers as equal if their corresponding objects all respond
+ /// true to an `isEqual(_:)` request. See the `NSData`, `NSDictionary`, `NSArray`,
+ /// and `NSString` class specifications for examples of the use of this method.
+ ///
+ /// If two objects are equal, they must have the same hash value.
+ /// This last point is particularly important if you define `isEqual(_:)` in a subclass
+ /// and intend to put instances of that subclass into a collection.
+ /// Make sure you also define hash in your subclass.
+ ///
+ /// - Parameter object: The object to be compared to the instance.
+ /// May be `nil`, in which case this method returns `false`.
+ /// - Returns: `true` if the instance and `object` are equal, otherwise `false`.
func isEqual(_ object: Any?) -> Bool
+
+ /// Returns an integer that can be used as a table address in a hash table structure.
+ ///
+ /// If two objects are equal (as determined by the `isEqual(_:)` method),
+ /// they must have the same hash value. This last point is particularly important
+ /// if you define `hash` in a subclass and intend to put instances of that subclass
+ /// into a collection.
+ ///
+ /// If a mutable object is added to a collection that uses hash values to determine
+ /// the object’s position in the collection, the value returned by the `hash` property
+ /// of the object must not change while the object is in the collection. Therefore, either
+ /// the `hash` property must not rely on any of the object’s internal state information
+ /// or you must make sure the object’s internal state information does not change while
+ /// the object is in the collection. Thus, for example, a mutable dictionary can be put
+ /// in a hash table but you must not change it while it is in there.
+ /// (Note that it can be difficult to know whether or not a given object is in a collection.)
var hash: Int { get }
+ /// Returns the instance itself.
+ ///
+ /// - Returns: The instance itself.
func `self`() -> Self
+ /// Returns a Boolean value that indicates whether the instance does not descend from NSObject.
+ ///
+ /// - Returns: `false` if the instance really descends from `NSObject`, otherwise `true`.
func isProxy() -> Bool
+ /// Returns a string that describes the contents of the instance.
var description: String { get }
+ /// Returns a string that describes the contents of the instance for presentation
+ /// in the debugger.
var debugDescription: String { get }
}
extension NSObjectProtocol {
+
public var debugDescription: String {
return description
}
}
public struct NSZone : ExpressibleByNilLiteral {
+
public init() {
}
@@ -40,35 +88,76 @@
}
}
+/// The `NSCopying` protocol declares a method for providing functional copies of an object.
+/// The exact meaning of “copy” can vary from class to class, but a copy must be a functionally
+/// independent object with values identical to the original at the time the copy was made.
+///
+/// NSCopying declares one method, `copy(with:)`, but copying is commonly invoked with the
+/// convenience method `copy`. The copy method is defined for all objects inheriting from NSObject
+/// and simply invokes `copy(with:)` with the `nil` zone.
+///
+/// If a subclass inherits `NSCopying` from its superclass and declares additional instance variables,
+/// the subclass has to override `copy(with:)` to properly handle its own instance variables,
+/// invoking the superclass’s implementation first.
public protocol NSCopying {
+ /// Returns a new instance that’s a copy of the current one.
+ ///
+ /// - Parameter zone: This parameter is ignored. Memory zones are no longer used.
+ /// - Returns: A new instance that’s a copy of the current one.
func copy(with zone: NSZone?) -> Any
}
extension NSCopying {
+
+ /// Returns a new instance that’s a copy of the current one.
+ ///
+ /// - Returns: A new instance that’s a copy of the current one.
public func copy() -> Any {
return copy(with: nil)
}
}
+/// The `NSMutableCopying` protocol declares a method for providing mutable
+/// copies of an object. Only classes that define an “immutable vs. mutable” distinction
+/// should adopt this protocol. Classes that don’t define such a distinction should
+/// adopt `NSCopying` instead.
public protocol NSMutableCopying {
+ /// Returns a new instance that’s a mutable copy of the current one.
+ ///
+ /// - Parameter zone: This parameter is ignored. Memory zones are no longer used.
+ /// - Returns: A new instance that’s a mutable copy of the current one.
func mutableCopy(with zone: NSZone?) -> Any
}
extension NSMutableCopying {
+
+ /// Returns a new instance that’s a mutable copy of the current one.
+ ///
+ /// - Returns: A new instance that’s a mutable copy of the current one.
public func mutableCopy() -> Any {
return mutableCopy(with: nil)
}
}
+/// The root class of most Foundation class hierarchies.
open class NSObject : NSObjectProtocol, Equatable, Hashable {
// Important: add no ivars here. It will subvert the careful layout of subclasses that bridge into CF.
- public init() {
-
- }
+ /// Implemented by subclasses to initialize a new object immediately after memory
+ /// for it has been allocated.
+ public init() {}
+ /// Returns the object returned by `copy(with:)`.
+ ///
+ /// This is a convenience method for classes that adopt the `NSCopying` protocol.
+ /// `NSObject` does not itself support the `NSCopying` protocol.
+ /// Subclasses must support the protocol and implement the `copy(with:)` method.
+ /// A subclass version of the `copy(with:)` method should invoke `super`'s method first,
+ /// to incorporate its implementation, unless the subclass descends directly from `NSObject`.
+ ///
+ /// - Returns: The object returned by the `NSCopying` protocol method `copy(with:)`.
open func copy() -> Any {
if let copyable = self as? NSCopying {
return copyable.copy(with: nil)
@@ -76,6 +165,12 @@
return self
}
+ /// Returns the object returned by `mutableCopy(with:)` where the zone is `nil.`
+ ///
+ /// This is a convenience method for classes that adopt the `NSMutableCopying` protocol.
+ ///
+ /// - Returns: The object returned by the `NSMutableCopying` protocol method
+ /// `mutableCopy(with:)`, where the zone is `nil`.
open func mutableCopy() -> Any {
if let copyable = self as? NSMutableCopying {
return copyable.mutableCopy(with: nil)
@@ -83,6 +178,13 @@
return self
}
+ /// Returns a Boolean value that indicates whether the instance is equal to another given object.
+ ///
+ /// The default implementation for this method provided by `NSObject` returns `true` if
+ /// the objects being compared refer to the same instance.
+ ///
+ /// - Parameter object: The object with which to compare the instance.
+ /// - Returns: `true` if the instance is equal to `object`, otherwise `false`.
open func isEqual(_ object: Any?) -> Bool {
if let obj = object as? NSObject {
return obj === self
@@ -90,22 +192,46 @@
return false
}
+ /// Returns an integer that can be used as a table address in a hash table structure.
+ ///
+ /// If two objects are equal (as determined by the `isEqual(_:)` method),
+ /// they must have the same hash value. This last point is particularly important
+ /// if you define `hash` in a subclass and intend to put instances of that subclass
+ /// into a collection.
+ ///
+ /// If a mutable object is added to a collection that uses hash values to determine
+ /// the object’s position in the collection, the value returned by the `hash` property
+ /// of the object must not change while the object is in the collection. Therefore, either
+ /// the `hash` property must not rely on any of the object’s internal state information
+ /// or you must make sure the object’s internal state information does not change while
+ /// the object is in the collection. Thus, for example, a mutable dictionary can be put
+ /// in a hash table but you must not change it while it is in there.
+ /// (Note that it can be difficult to know whether or not a given object is in a collection.)
open var hash: Int {
return ObjectIdentifier(self).hashValue
}
+ /// Returns the instance itself.
+ ///
+ /// - Returns: The instance itself.
open func `self`() -> Self {
return self
}
+ /// Returns a Boolean value that indicates whether the instance does not descend from NSObject.
+ ///
+ /// - Returns: `false` if the instance really descends from `NSObject`, otherwise `true`.
open func isProxy() -> Bool {
return false
}
+ /// Returns a string that describes the contents of the instance.
open var description: String {
return "<\(type(of: self)): \(Unmanaged.passUnretained(self).toOpaque())>"
}
+ /// Returns a string that describes the contents of the instance for presentation
+ /// in the debugger.
open var debugDescription: String {
return description
}
@@ -114,46 +240,82 @@
return 0
}
- // TODO move these back into extensions once extension methods can be overriden
+ // TODO: move these back into extensions once extension methods can be overriden
+
+ /// Overridden by subclasses to substitute a class other than its own during coding.
+ ///
+ /// This property is needed for `NSCoder`.
+ /// `NSObject`’s implementation returns the instance's class.
+ /// The private subclasses of a class cluster substitute the name of their public
+ /// superclass when being archived.
open var classForCoder: AnyClass {
return type(of: self)
}
+ /// Overridden by subclasses to substitute another object for itself during encoding.
+ ///
+ /// An object might encode itself into an archive, but encode a proxy for itself if
+ /// it’s being encoded for distribution. This method is invoked by `NSCoder`.
+ /// `NSObject`’s implementation returns `self`.
+ ///
+ /// - Parameter aCoder: The coder encoding the instance.
+ /// - Returns: The object encode instead of the instance (if different).
open func replacementObjectForCoder(_ aCoder: NSCoder) -> AnyObject? {
return self
}
- // TODO: Could perhaps be an extension of NSCoding instead. The reason it is an extension of NSObject is the lack of default implementations on protocols in Objective-C.
+ // TODO: Could perhaps be an extension of NSCoding instead.
+ // The reason it is an extension of NSObject is the lack of default
+ // implementations on protocols in Objective-C.
+
+ /// Subclasses to substitute a new class for instances during keyed archiving.
+ ///
+ /// The object will be encoded as if it were a member of the class. This property is
+ /// overridden by the encoder class and instance name to class encoding tables.
+ /// If this property is `nil`, the result of this property is ignored.
open var classForKeyedArchiver: AnyClass? {
return self.classForCoder
}
- // Implemented by classes to substitute a new class for instances during
- // encoding. The object will be encoded as if it were a member of the
- // returned class. The results of this method are overridden by the archiver
- // class and instance name<->class encoding tables. If nil is returned,
- // then the null object is encoded. This method returns the result of
- // [self classForArchiver] by default, NOT -classForCoder as might be
- // expected. This is a concession to source compatibility.
-
+ /// Overridden by subclasses to substitute another object for itself during keyed archiving.
+ ///
+ /// This method is called only if no replacement mapping for the object has been set up
+ /// in the encoder (for example, due to a previous call of `replacementObject(for:)` to that object).
+ ///
+ /// - Parameter archiver: A keyed archiver creating an archive.
+ /// - Returns: The object encode instead of the instance (if different).
open func replacementObjectForKeyedArchiver(_ archiver: NSKeyedArchiver) -> AnyObject? {
return self.replacementObjectForCoder(archiver)
}
- // Implemented by classes to substitute new instances for the receiving
- // instance during encoding. The returned object will be encoded instead
- // of the receiver (if different). This method is called only if no
- // replacement mapping for the object has been set up in the archiver yet
- // (for example, due to a previous call of replacementObjectForKeyedArchiver:
- // to that object). This method returns the result of
- // [self replacementObjectForArchiver:nil] by default, NOT
- // -replacementObjectForCoder: as might be expected. This is a concession
- // to source compatibility.
-
+ /// Overridden to return the names of classes that can be used to decode
+ /// objects if their class is unavailable.
+ ///
+ /// `NSKeyedArchiver` calls this method and stores the result inside the archive.
+ /// If the actual class of an object doesn’t exist at the time of unarchiving,
+ /// `NSKeyedUnarchiver` goes through the stored list of classes and uses the first one
+ /// that does exists as a substitute class for decoding the object.
+ /// The default implementation of this method returns empty array.
+ ///
+ /// You can use this method if you introduce a new class into your application to provide
+ /// some backwards compatibility in case the archive will be read on a system that does not
+ /// have that class. Sometimes there may be another class which may work nearly as well as
+ /// a substitute for the new class, and the archive keys and archived state for the new class
+ /// can be carefully chosen (or compatibility written out) so that the object can be unarchived
+ /// as the substitute class if necessary.
+ ///
+ /// - Returns: An array of strings that specify the names of classes in preferred order for unarchiving.
open class func classFallbacksForKeyedArchiver() -> [String] {
return []
}
+ /// Overridden by subclasses to substitute a new class during keyed unarchiving.
+ ///
+ /// During keyed unarchiving, instances of the class will be decoded as members
+ /// of the returned class. This method overrides the results of the decoder’s class
+ /// and instance name to class encoding tables.
+ ///
+ /// - Returns: The class to substitute for the current class during keyed unarchiving.
open class func classForKeyedUnarchiver() -> AnyClass {
return self
}
@@ -163,6 +325,14 @@
}
}
+/// Returns a Boolean value indicating whether two values are equal.
+///
+/// Equality is the inverse of inequality. For any values `a` and `b`,
+/// `a == b` implies that `a != b` is `false`.
+///
+/// - Parameters:
+/// - lhs: A value to compare.
+/// - rhs: Another value to compare.
public func ==(lhs: NSObject, rhs: NSObject) -> Bool {
return lhs.isEqual(rhs)
}
diff --git a/Foundation/NSOperation.swift b/Foundation/NSOperation.swift
index a9e1058..fcc9b38 100644
--- a/Foundation/NSOperation.swift
+++ b/Foundation/NSOperation.swift
@@ -258,19 +258,19 @@
}
mutating func dequeue() -> Operation? {
- if veryHigh.count > 0 {
+ if !veryHigh.isEmpty {
return veryHigh.remove(at: 0)
}
- if high.count > 0 {
+ if !high.isEmpty {
return high.remove(at: 0)
}
- if normal.count > 0 {
+ if !normal.isEmpty {
return normal.remove(at: 0)
}
- if low.count > 0 {
+ if !low.isEmpty {
return low.remove(at: 0)
}
- if veryLow.count > 0 {
+ if !veryLow.isEmpty {
return veryLow.remove(at: 0)
}
return nil
diff --git a/Foundation/NSPathUtilities.swift b/Foundation/NSPathUtilities.swift
index 95d1f1c..4590787 100644
--- a/Foundation/NSPathUtilities.swift
+++ b/Foundation/NSPathUtilities.swift
@@ -470,7 +470,7 @@
}
internal func _longestCommonPrefix(_ strings: [String], caseSensitive: Bool) -> String? {
- guard strings.count > 0 else {
+ guard !strings.isEmpty else {
return nil
}
diff --git a/Foundation/NSString.swift b/Foundation/NSString.swift
index 34badff..158de3e 100644
--- a/Foundation/NSString.swift
+++ b/Foundation/NSString.swift
@@ -1183,7 +1183,7 @@
}
public convenience init?(data: Data, encoding: UInt) {
- if data.count == 0 {
+ if data.isEmpty {
self.init("")
} else {
guard let cf = data.withUnsafeBytes({ (bytes: UnsafePointer<UInt8>) -> CFString? in
diff --git a/Foundation/NSURLSession/HTTPBodySource.swift b/Foundation/NSURLSession/HTTPBodySource.swift
index 03ebd4c..f732638 100644
--- a/Foundation/NSURLSession/HTTPBodySource.swift
+++ b/Foundation/NSURLSession/HTTPBodySource.swift
@@ -167,7 +167,7 @@
switch (done, data, errno) {
case (true, _, errno) where errno != 0:
self.availableChunk = .errorDetected(Int(errno))
- case (true, .some(let d), 0) where d.count == 0:
+ case (true, .some(let d), 0) where d.isEmpty:
self.append(data: d, endOfFile: true)
case (true, .some(let d), 0):
self.append(data: d, endOfFile: false)
@@ -220,10 +220,10 @@
let l = min(length, data.count)
let (head, tail) = splitData(dispatchData: data, atPosition: l)
- availableChunk = (tail.count == 0) ? .empty : .data(tail)
+ availableChunk = tail.isEmpty ? .empty : .data(tail)
readNextChunk()
- if head.count == 0 {
+ if head.isEmpty {
return .retryLater
} else {
return .data(head)
@@ -231,8 +231,8 @@
case .done(.some(let data)):
let l = min(length, data.count)
let (head, tail) = splitData(dispatchData: data, atPosition: l)
- availableChunk = (tail.count == 0) ? .done(nil) : .done(tail)
- if (head.count == 0) {
+ availableChunk = tail.isEmpty ? .done(nil) : .done(tail)
+ if head.isEmpty {
return .done
} else {
return .data(head)
diff --git a/Foundation/NSXMLElement.swift b/Foundation/NSXMLElement.swift
index 3c3b853..aa12142 100644
--- a/Foundation/NSXMLElement.swift
+++ b/Foundation/NSXMLElement.swift
@@ -109,7 +109,7 @@
result.append(XMLNode._objectNodeForNode(attribute))
nextAttribute = _CFXMLNodeGetNextSibling(attribute)
}
- return result.count > 0 ? result : nil // This appears to be how Darwin does it
+ return !result.isEmpty ? result : nil // This appears to be how Darwin does it
}
set {
diff --git a/Foundation/URL.swift b/Foundation/URL.swift
index e9ace98..8e1dc04 100644
--- a/Foundation/URL.swift
+++ b/Foundation/URL.swift
@@ -489,7 +489,7 @@
///
/// If the data representation is not a legal URL string as ASCII bytes, the URL object may not behave as expected. If the URL cannot be formed then this will return nil.
public init?(dataRepresentation: Data, relativeTo url: URL?, isAbsolute: Bool = false) {
- guard dataRepresentation.count > 0 else { return nil }
+ guard !dataRepresentation.isEmpty else { return nil }
if isAbsolute {
_url = URL._converted(from: NSURL(absoluteURLWithDataRepresentation: dataRepresentation, relativeTo: url))
diff --git a/TestFoundation/TestNSCalendar.swift b/TestFoundation/TestNSCalendar.swift
index 191b212..dde03e6 100644
--- a/TestFoundation/TestNSCalendar.swift
+++ b/TestFoundation/TestNSCalendar.swift
@@ -63,11 +63,29 @@
var calendar = Calendar(identifier: .gregorian)
calendar.timeZone = TimeZone(identifier: "UTC")!
- let components = calendar.dateComponents([.year, .month, .day], from: date)
+ let components = calendar.dateComponents([.year, .month, .day], from: date)
XCTAssertEqual(components.year, 2015)
XCTAssertEqual(components.month, 12)
XCTAssertEqual(components.day, 5)
+
+ // Test for problem reported by Malcolm Barclay via swift-corelibs-dev
+ // https://lists.swift.org/pipermail/swift-corelibs-dev/Week-of-Mon-20161128/001031.html
+ let fromDate = Date()
+ let interval = 200
+ let toDate = Date(timeInterval: TimeInterval(interval), since: fromDate)
+ let fromToComponents = calendar.dateComponents([.second], from: fromDate, to: toDate)
+ XCTAssertEqual(fromToComponents.second, interval);
+
+ // Issue with 32-bit CF calendar vector on Linux
+ // Crashes on macOS 10.12.2/Foundation 1349.25
+ // (Possibly related) rdar://24384757
+ /*
+ let interval2 = Int(INT32_MAX) + 1
+ let toDate2 = Date(timeInterval: TimeInterval(interval2), since: fromDate)
+ let fromToComponents2 = calendar.dateComponents([.second], from: fromDate, to: toDate2)
+ XCTAssertEqual(fromToComponents2.second, interval2);
+ */
}
func test_gettingDatesOnISO8601Calendar() {
diff --git a/TestFoundation/TestNSGeometry.swift b/TestFoundation/TestNSGeometry.swift
index 53bcde3..edd9d37 100644
--- a/TestFoundation/TestNSGeometry.swift
+++ b/TestFoundation/TestNSGeometry.swift
@@ -29,9 +29,12 @@
("test_CGPoint_BasicConstruction", test_CGPoint_BasicConstruction),
("test_CGSize_BasicConstruction", test_CGSize_BasicConstruction),
("test_CGRect_BasicConstruction", test_CGRect_BasicConstruction),
+ ("test_NSEdgeInsets_BasicConstruction", test_NSEdgeInsets_BasicConstruction),
+ ("test_NSEdgeInsetsEqual", test_NSEdgeInsetsEqual),
("test_NSMakePoint", test_NSMakePoint),
("test_NSMakeSize", test_NSMakeSize),
("test_NSMakeRect", test_NSMakeRect),
+ ("test_NSEdgeInsetsMake", test_NSEdgeInsetsMake),
("test_NSUnionRect", test_NSUnionRect),
("test_NSIntersectionRect", test_NSIntersectionRect),
("test_NSOffsetRect", test_NSOffsetRect),
@@ -136,6 +139,28 @@
XCTAssertEqual(r2.size.height, s.height)
}
+ func test_NSEdgeInsets_BasicConstruction() {
+ let i1 = NSEdgeInsets()
+ XCTAssertEqual(i1.top, CGFloat(0.0))
+ XCTAssertEqual(i1.left, CGFloat(0.0))
+ XCTAssertEqual(i1.bottom, CGFloat(0.0))
+ XCTAssertEqual(i1.right, CGFloat(0.0))
+
+ let i2 = NSEdgeInsets(top: CGFloat(3.6), left: CGFloat(4.5), bottom: CGFloat(5.0), right: CGFloat(-1.0))
+ XCTAssertEqual(i2.top, CGFloat(3.6))
+ XCTAssertEqual(i2.left, CGFloat(4.5))
+ XCTAssertEqual(i2.bottom, CGFloat(5.0))
+ XCTAssertEqual(i2.right, CGFloat(-1.0))
+ }
+
+ func test_NSEdgeInsetsEqual() {
+ let variant1 = NSEdgeInsets(top: CGFloat(3.6), left: CGFloat(4.5), bottom: CGFloat(5.0), right: CGFloat(-1.0))
+ let variant1Copy = NSEdgeInsets(top: CGFloat(3.6), left: CGFloat(4.5), bottom: CGFloat(5.0), right: CGFloat(-1.0))
+ let variant2 = NSEdgeInsets(top: CGFloat(3.1), left: CGFloat(4.5), bottom: CGFloat(5.0), right: CGFloat(-1.0))
+ XCTAssertTrue(NSEdgeInsetsEqual(variant1, variant1Copy))
+ XCTAssertFalse(NSEdgeInsetsEqual(variant1, variant2))
+ }
+
func test_NSMakePoint() {
let p2 = NSMakePoint(CGFloat(3.6), CGFloat(4.5))
XCTAssertEqual(p2.x, CGFloat(3.6))
@@ -156,6 +181,14 @@
XCTAssertEqual(r2.size.height, CGFloat(5.0))
}
+ func test_NSEdgeInsetsMake() {
+ let i2 = NSEdgeInsetsMake(CGFloat(2.2), CGFloat(3.0), CGFloat(5.0), CGFloat(5.0))
+ XCTAssertEqual(i2.top, CGFloat(2.2))
+ XCTAssertEqual(i2.left, CGFloat(3.0))
+ XCTAssertEqual(i2.bottom, CGFloat(5.0))
+ XCTAssertEqual(i2.right, CGFloat(5.0))
+ }
+
func test_NSUnionRect() {
let r1 = NSMakeRect(CGFloat(1.2), CGFloat(3.1), CGFloat(10.0), CGFloat(10.0))
let r2 = NSMakeRect(CGFloat(10.2), CGFloat(2.5), CGFloat(5.0), CGFloat(5.0))
@@ -275,87 +308,87 @@
let referenceNegativeRect = NSMakeRect(CGFloat(-0.6), CGFloat(-5.4), CGFloat(-105.7), CGFloat(-24.3))
let referenceNegativeOriginRect = NSMakeRect(CGFloat(-0.6), CGFloat(-5.4), CGFloat(105.7), CGFloat(24.3))
- var options: NSAlignmentOptions = [.AlignMinXInward, .AlignMinYInward, .AlignHeightInward, .AlignWidthInward]
+ var options: AlignmentOptions = [.alignMinXInward, .alignMinYInward, .alignHeightInward, .alignWidthInward]
var expectedResult = NSMakeRect(CGFloat(1.0), CGFloat(6.0), CGFloat(105.0), CGFloat(24.0))
var result = NSIntegralRectWithOptions(referenceRect, options)
XCTAssertEqual(result, expectedResult)
- options = [.AlignMinXOutward, .AlignMinYOutward, .AlignHeightOutward, .AlignWidthOutward]
+ options = [.alignMinXOutward, .alignMinYOutward, .alignHeightOutward, .alignWidthOutward]
expectedResult = NSMakeRect(CGFloat(0.0), CGFloat(5.0), CGFloat(106.0), CGFloat(25.0))
result = NSIntegralRectWithOptions(referenceRect, options)
XCTAssertEqual(result, expectedResult)
- options = [.AlignMinXInward, .AlignMinYInward, .AlignHeightInward, .AlignWidthInward]
+ options = [.alignMinXInward, .alignMinYInward, .alignHeightInward, .alignWidthInward]
expectedResult = NSMakeRect(CGFloat(0.0), CGFloat(-5.0), CGFloat(0.0), CGFloat(0.0))
result = NSIntegralRectWithOptions(referenceNegativeRect, options)
XCTAssertEqual(result, expectedResult)
- options = [.AlignMinXInward, .AlignMinYInward, .AlignHeightInward, .AlignWidthInward]
+ options = [.alignMinXInward, .alignMinYInward, .alignHeightInward, .alignWidthInward]
expectedResult = NSMakeRect(CGFloat(0.0), CGFloat(-5.0), CGFloat(105.0), CGFloat(24.0))
result = NSIntegralRectWithOptions(referenceNegativeOriginRect, options)
XCTAssertEqual(result, expectedResult)
- options = [.AlignMinXOutward, .AlignMinYOutward, .AlignHeightOutward, .AlignWidthOutward]
+ options = [.alignMinXOutward, .alignMinYOutward, .alignHeightOutward, .alignWidthOutward]
expectedResult = NSMakeRect(CGFloat(-1.0), CGFloat(-6.0), CGFloat(106.0), CGFloat(25.0))
result = NSIntegralRectWithOptions(referenceNegativeOriginRect, options)
XCTAssertEqual(result, expectedResult)
- options = [.AlignMaxXOutward, .AlignMaxYOutward, .AlignHeightOutward, .AlignWidthOutward]
+ options = [.alignMaxXOutward, .alignMaxYOutward, .alignHeightOutward, .alignWidthOutward]
expectedResult = NSMakeRect(CGFloat(0.0), CGFloat(-6.0), CGFloat(106.0), CGFloat(25.0))
result = NSIntegralRectWithOptions(referenceNegativeOriginRect, options)
XCTAssertEqual(result, expectedResult)
- options = [.AlignMinXOutward, .AlignMaxXOutward, .AlignMinYOutward, .AlignMaxYOutward]
+ options = [.alignMinXOutward, .alignMaxXOutward, .alignMinYOutward, .alignMaxYOutward]
expectedResult = NSMakeRect(CGFloat(-1.0), CGFloat(-6.0), CGFloat(107.0), CGFloat(25.0))
result = NSIntegralRectWithOptions(referenceNegativeOriginRect, options)
XCTAssertEqual(result, expectedResult)
- options = [.AlignMaxXOutward, .AlignMaxYOutward, .AlignHeightOutward, .AlignWidthOutward]
+ options = [.alignMaxXOutward, .alignMaxYOutward, .alignHeightOutward, .alignWidthOutward]
expectedResult = NSMakeRect(CGFloat(1.0), CGFloat(5.0), CGFloat(106.0), CGFloat(25.0))
result = NSIntegralRectWithOptions(referenceRect, options)
XCTAssertEqual(result, expectedResult)
- options = [.AlignMaxXInward, .AlignMaxYInward, .AlignHeightOutward, .AlignWidthOutward]
+ options = [.alignMaxXInward, .alignMaxYInward, .alignHeightOutward, .alignWidthOutward]
expectedResult = NSMakeRect(CGFloat(-1.0), CGFloat(-7.0), CGFloat(106.0), CGFloat(25.0))
result = NSIntegralRectWithOptions(referenceNegativeOriginRect, options)
XCTAssertEqual(result, expectedResult)
- options = [.AlignMaxXInward, .AlignMaxYInward, .AlignHeightOutward, .AlignWidthOutward]
+ options = [.alignMaxXInward, .alignMaxYInward, .alignHeightOutward, .alignWidthOutward]
expectedResult = NSMakeRect(CGFloat(0.0), CGFloat(4.0), CGFloat(106.0), CGFloat(25.0))
result = NSIntegralRectWithOptions(referenceRect, options)
XCTAssertEqual(result, expectedResult)
- options = [.AlignMinXNearest, .AlignMinYNearest, .AlignHeightNearest, .AlignWidthNearest]
+ options = [.alignMinXNearest, .alignMinYNearest, .alignHeightNearest, .alignWidthNearest]
expectedResult = NSMakeRect(CGFloat(1.0), CGFloat(5.0), CGFloat(106.0), CGFloat(24.0))
result = NSIntegralRectWithOptions(referenceRect, options)
XCTAssertEqual(result, expectedResult)
- options = [.AlignMinXNearest, .AlignMinYNearest, .AlignHeightNearest, .AlignWidthNearest]
+ options = [.alignMinXNearest, .alignMinYNearest, .alignHeightNearest, .alignWidthNearest]
expectedResult = NSMakeRect(CGFloat(-1.0), CGFloat(-5.0), CGFloat(106.0), CGFloat(24.0))
result = NSIntegralRectWithOptions(referenceNegativeOriginRect, options)
XCTAssertEqual(result, expectedResult)
- options = [.AlignMaxXNearest, .AlignMaxYNearest, .AlignHeightNearest, .AlignWidthNearest]
+ options = [.alignMaxXNearest, .alignMaxYNearest, .alignHeightNearest, .alignWidthNearest]
expectedResult = NSMakeRect(CGFloat(0.0), CGFloat(6.0), CGFloat(106.0), CGFloat(24.0))
result = NSIntegralRectWithOptions(referenceRect, options)
XCTAssertEqual(result, expectedResult)
- options = [.AlignMaxXNearest, .AlignMaxYNearest, .AlignHeightNearest, .AlignWidthNearest]
+ options = [.alignMaxXNearest, .alignMaxYNearest, .alignHeightNearest, .alignWidthNearest]
expectedResult = NSMakeRect(CGFloat(-1.0), CGFloat(-5.0), CGFloat(106.0), CGFloat(24.0))
result = NSIntegralRectWithOptions(referenceNegativeOriginRect, options)
XCTAssertEqual(result, expectedResult)
- options = [.AlignMinXInward, .AlignMaxXInward, .AlignMinYInward, .AlignMaxYInward]
+ options = [.alignMinXInward, .alignMaxXInward, .alignMinYInward, .alignMaxYInward]
expectedResult = NSMakeRect(CGFloat(1.0), CGFloat(6.0), CGFloat(105.0), CGFloat(23.0))
result = NSIntegralRectWithOptions(referenceRect, options)
XCTAssertEqual(result, expectedResult)
- options = [.AlignMinXInward, .AlignMaxXInward, .AlignMinYInward, .AlignMaxYInward]
+ options = [.alignMinXInward, .alignMaxXInward, .alignMinYInward, .alignMaxYInward]
expectedResult = NSMakeRect(CGFloat(0.0), CGFloat(-5.0), CGFloat(105.0), CGFloat(23.0))
result = NSIntegralRectWithOptions(referenceNegativeOriginRect, options)
XCTAssertEqual(result, expectedResult)
- options = [.AlignMinXNearest, .AlignMaxXInward, .AlignMinYInward, .AlignMaxYNearest]
+ options = [.alignMinXNearest, .alignMaxXInward, .alignMinYInward, .alignMaxYNearest]
expectedResult = NSMakeRect(CGFloat(-1.0), CGFloat(-5.0), CGFloat(106.0), CGFloat(24.0))
result = NSIntegralRectWithOptions(referenceNegativeOriginRect, options)
XCTAssertEqual(result, expectedResult)
diff --git a/TestFoundation/TestNSKeyedArchiver.swift b/TestFoundation/TestNSKeyedArchiver.swift
index 6e6b529..32fd2b6 100644
--- a/TestFoundation/TestNSKeyedArchiver.swift
+++ b/TestFoundation/TestNSKeyedArchiver.swift
@@ -111,6 +111,7 @@
private func test_archive(_ encode: (NSKeyedArchiver) -> Bool,
decode: (NSKeyedUnarchiver) -> Bool) {
+ // Archiving using custom NSMutableData instance
let data = NSMutableData()
let archiver = NSKeyedArchiver(forWritingWith: data)
@@ -119,6 +120,15 @@
let unarchiver = NSKeyedUnarchiver(forReadingWithData: Data._unconditionallyBridgeFromObjectiveC(data))
XCTAssertTrue(decode(unarchiver))
+
+ // Archiving using the default initializer
+ let archiver1 = NSKeyedArchiver()
+
+ XCTAssertTrue(encode(archiver1))
+ let archivedData = archiver1.encodedData
+
+ let unarchiver1 = NSKeyedUnarchiver(forReadingWithData: archivedData)
+ XCTAssertTrue(decode(unarchiver1))
}
private func test_archive(_ object: Any, classes: [AnyClass], allowsSecureCoding: Bool = true, outputFormat: PropertyListSerialization.PropertyListFormat) {
