test/stdlib/UIKit.swift - third_party/swift - Git at Google

 // RUN: %empty-directory(%t)
 // RUN: %target-build-swift -swift-version 4 %s -o %t/a.out4 && %target-codesign %t/a.out4 && %target-run %t/a.out4
 // RUN: %target-build-swift -swift-version 4.2 %s -o %t/a.out4_2 && %target-codesign %t/a.out4_2 && %target-run %t/a.out4_2
 // REQUIRES: executable_test
 // UNSUPPORTED: OS=macosx
 // REQUIRES: objc_interop

 import UIKit
 import StdlibUnittest
 import StdlibUnittestFoundationExtras

 #if swift(>=4.2)
   let UIKitTests = TestSuite("UIKit_Swift4_2")
 #else
   let UIKitTests = TestSuite("UIKit_Swift4")
 #endif

 #if !os(watchOS) && !os(tvOS)
 private func printDevice(_ o: UIDeviceOrientation) -> String {
   return "\(o.isPortrait) \(o.isLandscape) \(o.isFlat) \(o.isValidInterfaceOrientation)"
 }

 private func printInterface(_ o: UIInterfaceOrientation) -> String {
   return "\(o.isPortrait) \(o.isLandscape)"
 }

 UIKitTests.test("UIDeviceOrientation") {
   expectEqual("false false false false", printDevice(.unknown))
   expectEqual("true false false true", printDevice(.portrait))
   expectEqual("true false false true", printDevice(.portraitUpsideDown))
   expectEqual("false true false true", printDevice(.landscapeLeft))
   expectEqual("false true false true", printDevice(.landscapeRight))
   expectEqual("false false true false", printDevice(.faceUp))
   expectEqual("false false true false", printDevice(.faceDown))
 #if !swift(>=4.2)
   // Orientation functions should still be available
   _ = UIDeviceOrientationIsLandscape
   _ = UIDeviceOrientationIsPortrait
   _ = UIDeviceOrientationIsValidInterfaceOrientation
 #endif
 }

 UIKitTests.test("UIInterfaceOrientation") {
   expectEqual("false false", printInterface(.unknown))
   expectEqual("true false", printInterface(.portrait))
   expectEqual("true false", printInterface(.portraitUpsideDown))
   expectEqual("false true", printInterface(.landscapeLeft))
   expectEqual("false true", printInterface(.landscapeRight))
 #if !swift(>=4.2)
   // Orientation functions should still be available
   _ = UIInterfaceOrientationIsLandscape
   _ = UIInterfaceOrientationIsPortrait
 #endif
 }
 #endif // !os(watchOS) && !os(tvOS)

 UIKitTests.test("UIEdgeInsets") {
   let insets = [
     UIEdgeInsets(top: 1.0, left: 2.0, bottom: 3.0, right: 4.0),
     UIEdgeInsets(top: 1.0, left: 2.0, bottom: 3.1, right: 4.0),
     UIEdgeInsets.zero
   ]
   checkEquatable(insets, oracle: { $0 == $1 })
   expectFalse(UIEdgeInsetsEqualToEdgeInsets(insets[0], insets[1]))

   let encodedInsets = try! JSONEncoder().encode(insets[0])
   let decodedInsets = try! JSONDecoder().decode(UIEdgeInsets.self, from: encodedInsets)
   expectTrue(decodedInsets == insets[0])
 }

 UIKitTests.test("NSDirectionalEdgeInsets") {
   guard #available(iOS 11.0, tvOS 11.0, watchOS 5.0, *) else { return }
   let insets = [
     NSDirectionalEdgeInsets(top: 1.0, leading: 2.0, bottom: 3.0, trailing: 4.0),
     NSDirectionalEdgeInsets(top: 1.0, leading: 2.0, bottom: 3.1, trailing: 4.0),
     NSDirectionalEdgeInsets.zero
   ]
   checkEquatable(insets, oracle: { $0 == $1 })
   // NSDirectionalEdgeInsetsEqualToDirectionalEdgeInsets was never exposed in Swift

   let encodedInsets = try! JSONEncoder().encode(insets[0])
   let decodedInsets = try! JSONDecoder().decode(NSDirectionalEdgeInsets.self, from: encodedInsets)
   expectTrue(decodedInsets == insets[0])
 }

 UIKitTests.test("UIOffset") {
   let offsets = [
     UIOffset(horizontal: 1.0, vertical: 2.0),
     UIOffset(horizontal: 1.0, vertical: 3.0),
     UIOffset.zero
   ]
   checkEquatable(offsets, oracle: { $0 == $1 })
   expectFalse(UIOffsetEqualToOffset(offsets[0], offsets[1]))

   let encodedOffset = try! JSONEncoder().encode(offsets[0])
   let decodedOffset = try! JSONDecoder().decode(UIOffset.self, from: encodedOffset)
   expectTrue(decodedOffset == offsets[0])
 }

 #if os(iOS) || os(tvOS)
 UIKitTests.test("UIFloatRange") {
   guard #available(iOS 9.0, tvOS 9.0, *) else { return }
   #if swift(>=4.2)
     let zero = UIFloatRange.zero
   #else
     let zero = UIFloatRangeZero
   #endif

   let ranges = [
     UIFloatRange(minimum: 1.0, maximum: 2.0),
     UIFloatRange(minimum: 1.0, maximum: 3.0),
     zero
   ]
   checkEquatable(ranges, oracle: { $0 == $1 })
   expectFalse(UIFloatRangeIsEqualToRange(ranges[0], ranges[1]))

   let encodedRange = try! JSONEncoder().encode(ranges[0])
   let decodedRange = try! JSONDecoder().decode(UIFloatRange.self, from: encodedRange)
   expectTrue(decodedRange == ranges[0])
 }
 #endif

 UIKitTests.test("UIFont.Weight") {
   guard #available(iOS 8.2, *) else { return }
   #if swift(>=4) // Swift 4
     let regularFontWeight: UIFont.Weight = .regular

     expectTrue(regularFontWeight == .regular)
     expectTrue(regularFontWeight > .light)
     expectTrue(regularFontWeight < .heavy)
     expectTrue(regularFontWeight + 0.1 == 0.1 + regularFontWeight)
   #else // Swift 3
     let regularFontWeight: UIFontWeight = UIFontWeightRegular

     expectTrue(regularFontWeight == UIFontWeightRegular)
     expectTrue(regularFontWeight > UIFontWeightLight)
     expectTrue(regularFontWeight < UIFontWeightHeavy)
     expectTrue(regularFontWeight + 0.1 == 0.1 + UIFontWeightRegular)
   #endif
 }

 #if !os(watchOS)
 UIKitTests.test("UILayoutPriority") {
   let lowLayoutPriority: UILayoutPriority = .defaultLow
   let highLayoutPriority: UILayoutPriority = .defaultHigh

   expectTrue(lowLayoutPriority < highLayoutPriority)

   expectTrue(lowLayoutPriority + 2.0 == UILayoutPriority(lowLayoutPriority.rawValue + 2.0))
   expectTrue(2.0 + lowLayoutPriority == UILayoutPriority(lowLayoutPriority.rawValue + 2.0))
   expectTrue(lowLayoutPriority - 2.0 == UILayoutPriority(lowLayoutPriority.rawValue - 2.0))
   expectTrue(highLayoutPriority - lowLayoutPriority == highLayoutPriority.rawValue - lowLayoutPriority.rawValue)

   expectTrue(lowLayoutPriority + (highLayoutPriority - lowLayoutPriority) == highLayoutPriority)

   var mutablePriority = lowLayoutPriority
   mutablePriority -= 1.0
   mutablePriority += 2.0
   expectTrue(mutablePriority == lowLayoutPriority + 1.0)

   let priorotyRange = lowLayoutPriority...highLayoutPriority
   expectTrue(priorotyRange.contains(.defaultLow))
   expectFalse(priorotyRange.contains(.required))
 }
 #endif

 #if !os(watchOS)
 UIKitTests.test("UIWindow.Level") {
   #if swift(>=4.2) // Swift 4.2
     let normalWindowLevel: UIWindow.Level = .normal

     expectTrue(normalWindowLevel == .normal)
     expectTrue(normalWindowLevel < .alert)
     expectTrue(normalWindowLevel + 1 == 1 + normalWindowLevel)
   #else // Swift 3 and 4
     let normalWindowLevel: UIWindowLevel = UIWindowLevelNormal

     expectTrue(normalWindowLevel == UIWindowLevelNormal)
     expectTrue(normalWindowLevel < UIWindowLevelAlert)
     expectTrue(normalWindowLevel + 1 == 1 + UIWindowLevelNormal)
   #endif
 }
 #endif

 #if !os(watchOS)
 class TestChildView : UIView, CustomPlaygroundQuickLookable {
   convenience init() {
     self.init(frame: CGRect(x: 0, y: 0, width: 10, height: 10))
   }
   var customPlaygroundQuickLook: PlaygroundQuickLook {
     return .text("child")
   }
 }

 UIKitTests.test("CustomPlaygroundQuickLookable") {
   switch PlaygroundQuickLook(reflecting: TestChildView()) {
   case .text("child"): break
   default: expectUnreachable(
     "TestChildView custom quicklookable should have been invoked")
   }
 }
 #endif

 UIKitTests.test("NSValue bridging") {
   expectBridgeToNSValue(UIEdgeInsets(top: 17, left: 38, bottom: 6, right: 79),
                         nsValueInitializer: { NSValue(uiEdgeInsets: $0) },
                         nsValueGetter: { $0.uiEdgeInsetsValue },
                         equal: (==))
   if #available(iOS 11.0, tvOS 11.0, watchOS 5.0, *) {
     expectBridgeToNSValue(NSDirectionalEdgeInsets(top: 86, leading: 75, bottom: 30, trailing: 9),
                           nsValueInitializer: { NSValue(directionalEdgeInsets: $0) },
                           nsValueGetter: { $0.directionalEdgeInsetsValue },
                           equal: (==))
   }
   expectBridgeToNSValue(UIOffset(horizontal: 17, vertical: 38),
                         nsValueInitializer: { NSValue(uiOffset: $0) },
                         nsValueGetter: { $0.uiOffsetValue },
                         equal: (==))
 }

 #if os(iOS) || os(tvOS)
 UIKitTests.test("UIContentSizeCategory comparison") {
     if #available(iOS 11.0, tvOS 11.0, *) {
         expectTrue(UIContentSizeCategory.large < UIContentSizeCategory.extraLarge)
         expectTrue(UIContentSizeCategory.large <= UIContentSizeCategory.extraLarge)
         expectFalse(UIContentSizeCategory.large >= UIContentSizeCategory.extraLarge)
         expectFalse(UIContentSizeCategory.large > UIContentSizeCategory.extraLarge)
         expectFalse(UIContentSizeCategory.large == UIContentSizeCategory.extraLarge)

         expectTrue(UIContentSizeCategory.extraLarge > UIContentSizeCategory.large)
         expectTrue(UIContentSizeCategory.extraLarge >= UIContentSizeCategory.large)
         expectFalse(UIContentSizeCategory.extraLarge < UIContentSizeCategory.large)
         expectFalse(UIContentSizeCategory.extraLarge <= UIContentSizeCategory.large)
         expectFalse(UIContentSizeCategory.extraLarge == UIContentSizeCategory.large)

         expectTrue(UIContentSizeCategory.large == UIContentSizeCategory.large)
         expectTrue(UIContentSizeCategory.large >= UIContentSizeCategory.large)
         expectTrue(UIContentSizeCategory.large <= UIContentSizeCategory.large)
         expectFalse(UIContentSizeCategory.large > UIContentSizeCategory.large)
         expectFalse(UIContentSizeCategory.large < UIContentSizeCategory.large)

         expectTrue(UIContentSizeCategory.accessibilityExtraExtraExtraLarge.isAccessibilityCategory)
         expectFalse(UIContentSizeCategory.extraSmall.isAccessibilityCategory)
     }
 }
 #endif

 #if os(iOS) || os(watchOS) || os(tvOS)
 UIKitTests.test("UIFontMetrics scaling") {
     if #available(iOS 11.0, watchOS 4.0, tvOS 11.0, *) {
         let metrics = UIFont.TextStyle.headline.metrics
         expectTrue(metrics != nil)
 #if !swift(>=4.2)
         _ = UIFontTextStyle.headline.metrics
 #endif
     }
 }
 #endif

 #if os(iOS) || os(tvOS)
 UIKitTests.test("UIFocusEnvironment") {
   if #available(iOS 11.0, tvOS 11.0, *) {
     let item1 = UIView()
     let item2 = UIView()
     _ = item1.contains(item2)
     _ = item1.isFocused
   }
 }
 #endif

 #if os(iOS)

 UIKitTests.test("NSItemProviderReadingWriting support") {
   if #available(iOS 11.0, *) {
     func f<T : UIDragDropSession>(session: T) {
       _ = session.canLoadObjects(ofClass: String.self)
       _ = session.canLoadObjects(ofClass: URL.self)
     }
     func g<T : UIDropSession>(session: T) {
       _ = session.loadObjects(ofClass: String.self) { _ in ()}
       _ = session.loadObjects(ofClass: URL.self) { _ in () }
     }

     let pc0 = UIPasteConfiguration(forAccepting: String.self)
     let pc1 = UIPasteConfiguration(forAccepting: URL.self)
     pc0.addTypeIdentifiers(forAccepting: URL.self)
     pc1.addTypeIdentifiers(forAccepting: String.self)

     var pb = UIPasteboard.general
     pb.setObjects(["Hello"])
     pb.setObjects([URL(string: "https://www.apple.com")!])
     pb.setObjects(["Hello"], localOnly: true, expirationDate: nil)
     pb.setObjects([URL(string: "https://www.apple.com")!], localOnly: true, expirationDate: nil)
   }
 }

 #endif

 #if os(iOS)
 UIKitTests.test("UIPrintError compatibility") {
   #if swift(>=4.2)
   _ = UIPrintError.Code.notAvailable
   _ = UIPrintError.Code.noContent
   _ = UIPrintError.Code.unknownImageFormat
   _ = UIPrintError.Code.jobFailed
   #else
   _ = UIPrintingNotAvailableError
   _ = UIPrintNoContentError
   _ = UIPrintUnknownImageFormatError
   _ = UIPrintJobFailedError
   #endif
 }
 #endif

 #if !os(watchOS)
 UIKitTests.test("UIApplicationMain") {
   #if swift(>=4.2)
   _ = { UIApplicationMain(CommandLine.argc, CommandLine.unsafeArgv, nil, nil) }
   #endif
   _ = { UIApplicationMain(CommandLine.argc, UnsafeMutableRawPointer(CommandLine.unsafeArgv).bindMemory(to: UnsafeMutablePointer<Int8>.self, capacity: Int(CommandLine.argc)), nil, nil) }
 }
 #endif

 UIKitTests.test("UIAccessibilityTraits") {
   #if swift(>=4.2)
   let traits: UIAccessibilityTraits = [.link, .button]
   expectTrue(traits.contains(.link))
   expectFalse(traits.contains(.header))
   #else
   let _: UIAccessibilityTraits = UIAccessibilityTraitLink | UIAccessibilityTraitButton
   #endif
 }

 #if !os(watchOS)
 UIKitTests.test("UITextDirection") {
   #if swift(>=4.2)
   let _: UITextDirection = .storage(.forward)
   let _: UITextDirection = .layout(.right)
   #else
   let _: UITextDirection = UITextStorageDirection.backward.rawValue
   #endif
 }
 #endif


 runAllTests()
	// RUN: %empty-directory(%t)
	// RUN: %target-build-swift -swift-version 4 %s -o %t/a.out4 && %target-codesign %t/a.out4 && %target-run %t/a.out4
	// RUN: %target-build-swift -swift-version 4.2 %s -o %t/a.out4_2 && %target-codesign %t/a.out4_2 && %target-run %t/a.out4_2
	// REQUIRES: executable_test
	// UNSUPPORTED: OS=macosx
	// REQUIRES: objc_interop

	import UIKit
	import StdlibUnittest
	import StdlibUnittestFoundationExtras

	#if swift(>=4.2)
	let UIKitTests = TestSuite("UIKit_Swift4_2")
	#else
	let UIKitTests = TestSuite("UIKit_Swift4")
	#endif

	#if !os(watchOS) && !os(tvOS)
	private func printDevice(_ o: UIDeviceOrientation) -> String {
	return "\(o.isPortrait) \(o.isLandscape) \(o.isFlat) \(o.isValidInterfaceOrientation)"
	}

	private func printInterface(_ o: UIInterfaceOrientation) -> String {
	return "\(o.isPortrait) \(o.isLandscape)"
	}

	UIKitTests.test("UIDeviceOrientation") {
	expectEqual("false false false false", printDevice(.unknown))
	expectEqual("true false false true", printDevice(.portrait))
	expectEqual("true false false true", printDevice(.portraitUpsideDown))
	expectEqual("false true false true", printDevice(.landscapeLeft))
	expectEqual("false true false true", printDevice(.landscapeRight))
	expectEqual("false false true false", printDevice(.faceUp))
	expectEqual("false false true false", printDevice(.faceDown))
	#if !swift(>=4.2)
	// Orientation functions should still be available
	_ = UIDeviceOrientationIsLandscape
	_ = UIDeviceOrientationIsPortrait
	_ = UIDeviceOrientationIsValidInterfaceOrientation
	#endif
	}

	UIKitTests.test("UIInterfaceOrientation") {
	expectEqual("false false", printInterface(.unknown))
	expectEqual("true false", printInterface(.portrait))
	expectEqual("true false", printInterface(.portraitUpsideDown))
	expectEqual("false true", printInterface(.landscapeLeft))
	expectEqual("false true", printInterface(.landscapeRight))
	#if !swift(>=4.2)
	// Orientation functions should still be available
	_ = UIInterfaceOrientationIsLandscape
	_ = UIInterfaceOrientationIsPortrait
	#endif
	}
	#endif // !os(watchOS) && !os(tvOS)

	UIKitTests.test("UIEdgeInsets") {
	let insets = [
	UIEdgeInsets(top: 1.0, left: 2.0, bottom: 3.0, right: 4.0),
	UIEdgeInsets(top: 1.0, left: 2.0, bottom: 3.1, right: 4.0),
	UIEdgeInsets.zero
	]
	checkEquatable(insets, oracle: { $0 == $1 })
	expectFalse(UIEdgeInsetsEqualToEdgeInsets(insets[0], insets[1]))

	let encodedInsets = try! JSONEncoder().encode(insets[0])
	let decodedInsets = try! JSONDecoder().decode(UIEdgeInsets.self, from: encodedInsets)
	expectTrue(decodedInsets == insets[0])
	}

	UIKitTests.test("NSDirectionalEdgeInsets") {
	guard #available(iOS 11.0, tvOS 11.0, watchOS 5.0, *) else { return }
	let insets = [
	NSDirectionalEdgeInsets(top: 1.0, leading: 2.0, bottom: 3.0, trailing: 4.0),
	NSDirectionalEdgeInsets(top: 1.0, leading: 2.0, bottom: 3.1, trailing: 4.0),
	NSDirectionalEdgeInsets.zero
	]
	checkEquatable(insets, oracle: { $0 == $1 })
	// NSDirectionalEdgeInsetsEqualToDirectionalEdgeInsets was never exposed in Swift

	let encodedInsets = try! JSONEncoder().encode(insets[0])
	let decodedInsets = try! JSONDecoder().decode(NSDirectionalEdgeInsets.self, from: encodedInsets)
	expectTrue(decodedInsets == insets[0])
	}

	UIKitTests.test("UIOffset") {
	let offsets = [
	UIOffset(horizontal: 1.0, vertical: 2.0),
	UIOffset(horizontal: 1.0, vertical: 3.0),
	UIOffset.zero
	]
	checkEquatable(offsets, oracle: { $0 == $1 })
	expectFalse(UIOffsetEqualToOffset(offsets[0], offsets[1]))

	let encodedOffset = try! JSONEncoder().encode(offsets[0])
	let decodedOffset = try! JSONDecoder().decode(UIOffset.self, from: encodedOffset)
	expectTrue(decodedOffset == offsets[0])
	}

	#if os(iOS) \|\| os(tvOS)
	UIKitTests.test("UIFloatRange") {
	guard #available(iOS 9.0, tvOS 9.0, *) else { return }
	#if swift(>=4.2)
	let zero = UIFloatRange.zero
	#else
	let zero = UIFloatRangeZero
	#endif

	let ranges = [
	UIFloatRange(minimum: 1.0, maximum: 2.0),
	UIFloatRange(minimum: 1.0, maximum: 3.0),
	zero
	]
	checkEquatable(ranges, oracle: { $0 == $1 })
	expectFalse(UIFloatRangeIsEqualToRange(ranges[0], ranges[1]))

	let encodedRange = try! JSONEncoder().encode(ranges[0])
	let decodedRange = try! JSONDecoder().decode(UIFloatRange.self, from: encodedRange)
	expectTrue(decodedRange == ranges[0])
	}
	#endif

	UIKitTests.test("UIFont.Weight") {
	guard #available(iOS 8.2, *) else { return }
	#if swift(>=4) // Swift 4
	let regularFontWeight: UIFont.Weight = .regular

	expectTrue(regularFontWeight == .regular)
	expectTrue(regularFontWeight > .light)
	expectTrue(regularFontWeight < .heavy)
	expectTrue(regularFontWeight + 0.1 == 0.1 + regularFontWeight)
	#else // Swift 3
	let regularFontWeight: UIFontWeight = UIFontWeightRegular

	expectTrue(regularFontWeight == UIFontWeightRegular)
	expectTrue(regularFontWeight > UIFontWeightLight)
	expectTrue(regularFontWeight < UIFontWeightHeavy)
	expectTrue(regularFontWeight + 0.1 == 0.1 + UIFontWeightRegular)
	#endif
	}

	#if !os(watchOS)
	UIKitTests.test("UILayoutPriority") {
	let lowLayoutPriority: UILayoutPriority = .defaultLow
	let highLayoutPriority: UILayoutPriority = .defaultHigh

	expectTrue(lowLayoutPriority < highLayoutPriority)

	expectTrue(lowLayoutPriority + 2.0 == UILayoutPriority(lowLayoutPriority.rawValue + 2.0))
	expectTrue(2.0 + lowLayoutPriority == UILayoutPriority(lowLayoutPriority.rawValue + 2.0))
	expectTrue(lowLayoutPriority - 2.0 == UILayoutPriority(lowLayoutPriority.rawValue - 2.0))
	expectTrue(highLayoutPriority - lowLayoutPriority == highLayoutPriority.rawValue - lowLayoutPriority.rawValue)

	expectTrue(lowLayoutPriority + (highLayoutPriority - lowLayoutPriority) == highLayoutPriority)

	var mutablePriority = lowLayoutPriority
	mutablePriority -= 1.0
	mutablePriority += 2.0
	expectTrue(mutablePriority == lowLayoutPriority + 1.0)

	let priorotyRange = lowLayoutPriority...highLayoutPriority
	expectTrue(priorotyRange.contains(.defaultLow))
	expectFalse(priorotyRange.contains(.required))
	}
	#endif

	#if !os(watchOS)
	UIKitTests.test("UIWindow.Level") {
	#if swift(>=4.2) // Swift 4.2
	let normalWindowLevel: UIWindow.Level = .normal

	expectTrue(normalWindowLevel == .normal)
	expectTrue(normalWindowLevel < .alert)
	expectTrue(normalWindowLevel + 1 == 1 + normalWindowLevel)
	#else // Swift 3 and 4
	let normalWindowLevel: UIWindowLevel = UIWindowLevelNormal

	expectTrue(normalWindowLevel == UIWindowLevelNormal)
	expectTrue(normalWindowLevel < UIWindowLevelAlert)
	expectTrue(normalWindowLevel + 1 == 1 + UIWindowLevelNormal)
	#endif
	}
	#endif

	#if !os(watchOS)
	class TestChildView : UIView, CustomPlaygroundQuickLookable {
	convenience init() {
	self.init(frame: CGRect(x: 0, y: 0, width: 10, height: 10))
	}
	var customPlaygroundQuickLook: PlaygroundQuickLook {
	return .text("child")
	}
	}

	UIKitTests.test("CustomPlaygroundQuickLookable") {
	switch PlaygroundQuickLook(reflecting: TestChildView()) {
	case .text("child"): break
	default: expectUnreachable(
	"TestChildView custom quicklookable should have been invoked")
	}
	}
	#endif

	UIKitTests.test("NSValue bridging") {
	expectBridgeToNSValue(UIEdgeInsets(top: 17, left: 38, bottom: 6, right: 79),
	nsValueInitializer: { NSValue(uiEdgeInsets: $0) },
	nsValueGetter: { $0.uiEdgeInsetsValue },
	equal: (==))
	if #available(iOS 11.0, tvOS 11.0, watchOS 5.0, *) {
	expectBridgeToNSValue(NSDirectionalEdgeInsets(top: 86, leading: 75, bottom: 30, trailing: 9),
	nsValueInitializer: { NSValue(directionalEdgeInsets: $0) },
	nsValueGetter: { $0.directionalEdgeInsetsValue },
	equal: (==))
	}
	expectBridgeToNSValue(UIOffset(horizontal: 17, vertical: 38),
	nsValueInitializer: { NSValue(uiOffset: $0) },
	nsValueGetter: { $0.uiOffsetValue },
	equal: (==))
	}

	#if os(iOS) \|\| os(tvOS)
	UIKitTests.test("UIContentSizeCategory comparison") {
	if #available(iOS 11.0, tvOS 11.0, *) {
	expectTrue(UIContentSizeCategory.large < UIContentSizeCategory.extraLarge)
	expectTrue(UIContentSizeCategory.large <= UIContentSizeCategory.extraLarge)
	expectFalse(UIContentSizeCategory.large >= UIContentSizeCategory.extraLarge)
	expectFalse(UIContentSizeCategory.large > UIContentSizeCategory.extraLarge)
	expectFalse(UIContentSizeCategory.large == UIContentSizeCategory.extraLarge)

	expectTrue(UIContentSizeCategory.extraLarge > UIContentSizeCategory.large)
	expectTrue(UIContentSizeCategory.extraLarge >= UIContentSizeCategory.large)
	expectFalse(UIContentSizeCategory.extraLarge < UIContentSizeCategory.large)
	expectFalse(UIContentSizeCategory.extraLarge <= UIContentSizeCategory.large)
	expectFalse(UIContentSizeCategory.extraLarge == UIContentSizeCategory.large)

	expectTrue(UIContentSizeCategory.large == UIContentSizeCategory.large)
	expectTrue(UIContentSizeCategory.large >= UIContentSizeCategory.large)
	expectTrue(UIContentSizeCategory.large <= UIContentSizeCategory.large)
	expectFalse(UIContentSizeCategory.large > UIContentSizeCategory.large)
	expectFalse(UIContentSizeCategory.large < UIContentSizeCategory.large)

	expectTrue(UIContentSizeCategory.accessibilityExtraExtraExtraLarge.isAccessibilityCategory)
	expectFalse(UIContentSizeCategory.extraSmall.isAccessibilityCategory)
	}
	}
	#endif

	#if os(iOS) \|\| os(watchOS) \|\| os(tvOS)
	UIKitTests.test("UIFontMetrics scaling") {
	if #available(iOS 11.0, watchOS 4.0, tvOS 11.0, *) {
	let metrics = UIFont.TextStyle.headline.metrics
	expectTrue(metrics != nil)
	#if !swift(>=4.2)
	_ = UIFontTextStyle.headline.metrics
	#endif
	}
	}
	#endif

	#if os(iOS) \|\| os(tvOS)
	UIKitTests.test("UIFocusEnvironment") {
	if #available(iOS 11.0, tvOS 11.0, *) {
	let item1 = UIView()
	let item2 = UIView()
	_ = item1.contains(item2)
	_ = item1.isFocused
	}
	}
	#endif

	#if os(iOS)

	UIKitTests.test("NSItemProviderReadingWriting support") {
	if #available(iOS 11.0, *) {
	func f<T : UIDragDropSession>(session: T) {
	_ = session.canLoadObjects(ofClass: String.self)
	_ = session.canLoadObjects(ofClass: URL.self)
	}
	func g<T : UIDropSession>(session: T) {
	_ = session.loadObjects(ofClass: String.self) { _ in ()}
	_ = session.loadObjects(ofClass: URL.self) { _ in () }
	}

	let pc0 = UIPasteConfiguration(forAccepting: String.self)
	let pc1 = UIPasteConfiguration(forAccepting: URL.self)
	pc0.addTypeIdentifiers(forAccepting: URL.self)
	pc1.addTypeIdentifiers(forAccepting: String.self)

	var pb = UIPasteboard.general
	pb.setObjects(["Hello"])
	pb.setObjects([URL(string: "https://www.apple.com")!])
	pb.setObjects(["Hello"], localOnly: true, expirationDate: nil)
	pb.setObjects([URL(string: "https://www.apple.com")!], localOnly: true, expirationDate: nil)
	}
	}

	#endif

	#if os(iOS)
	UIKitTests.test("UIPrintError compatibility") {
	#if swift(>=4.2)
	_ = UIPrintError.Code.notAvailable
	_ = UIPrintError.Code.noContent
	_ = UIPrintError.Code.unknownImageFormat
	_ = UIPrintError.Code.jobFailed
	#else
	_ = UIPrintingNotAvailableError
	_ = UIPrintNoContentError
	_ = UIPrintUnknownImageFormatError
	_ = UIPrintJobFailedError
	#endif
	}
	#endif

	#if !os(watchOS)
	UIKitTests.test("UIApplicationMain") {
	#if swift(>=4.2)
	_ = { UIApplicationMain(CommandLine.argc, CommandLine.unsafeArgv, nil, nil) }
	#endif
	_ = { UIApplicationMain(CommandLine.argc, UnsafeMutableRawPointer(CommandLine.unsafeArgv).bindMemory(to: UnsafeMutablePointer<Int8>.self, capacity: Int(CommandLine.argc)), nil, nil) }
	}
	#endif

	UIKitTests.test("UIAccessibilityTraits") {
	#if swift(>=4.2)
	let traits: UIAccessibilityTraits = [.link, .button]
	expectTrue(traits.contains(.link))
	expectFalse(traits.contains(.header))
	#else
	let _: UIAccessibilityTraits = UIAccessibilityTraitLink \| UIAccessibilityTraitButton
	#endif
	}

	#if !os(watchOS)
	UIKitTests.test("UITextDirection") {
	#if swift(>=4.2)
	let _: UITextDirection = .storage(.forward)
	let _: UITextDirection = .layout(.right)
	#else
	let _: UITextDirection = UITextStorageDirection.backward.rawValue
	#endif
	}
	#endif


	runAllTests()