validation-test/Casting/BoxingCasts.swift.gyb - third_party/swift - Git at Google

 // BoxingCasts.swift - Tests for boxing/unboxing casts
 //
 // This source file is part of the Swift.org open source project
 //
 // Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See https://swift.org/LICENSE.txt for license information
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 // -----------------------------------------------------------------------------
 ///
 /// Contains tests for existential, optional, and other casts that box/unbox values.
 ///
 // -----------------------------------------------------------------------------
 // RUN: %empty-directory(%t)
 //
 // RUN: %gyb %s -o %t/BoxingCasts.swift
 // RUN: %line-directive %t/BoxingCasts.swift -- %target-build-swift -g -module-name a -swift-version 5 -Onone %t/BoxingCasts.swift -o %t/a.swift5.Onone.out
 // RUN: %target-codesign %t/a.swift5.Onone.out
 // RUN: %line-directive %t/BoxingCasts.swift -- %target-run %t/a.swift5.Onone.out
 //
 // Note: The RUN directives above override the default test optimizations.
 // This test is deliberately run non-optimized in order to verify the
 // behavior of runtime methods that may not be called for optimized casts.
 //
 // XXX FIXME XXX TODO XXX  _Also_ build this with optimizations in order to
 // verify compiler behaviors.
 //
 // REQUIRES: executable_test

 import StdlibUnittest
 #if _runtime(_ObjC)
 import Foundation
 #endif

 fileprivate func runtimeCast<From, To> (_ x: From, to: To.Type) -> To? {
   return x as? To
 }

 fileprivate func optional<T>(_ x: T) -> Optional<T> {
   return runtimeCast(x, to: Optional<T>.self)!
 }

 fileprivate protocol FilePrivateProtocol {}
 internal protocol InternalProtocol {}
 public protocol PublicProtocol {}
 protocol UnimplementedProtocol {}

 fileprivate enum EmptyEnum: FilePrivateProtocol, InternalProtocol, PublicProtocol { }

 fileprivate enum SingleCaseEnum: FilePrivateProtocol, InternalProtocol, PublicProtocol {
 case case0
   init() {self = .case0}
 }

 fileprivate enum TrivialPayloadEnum: FilePrivateProtocol, InternalProtocol, PublicProtocol {
 case payloadCase(Int)
   init() {self = .payloadCase(42)}
 }

 extension TrivialPayloadEnum: Hashable {}

 fileprivate enum MultiPayloadEnum: FilePrivateProtocol, InternalProtocol, PublicProtocol {
 case case0(String)
 case case1(Int)
   init() {self = .case1(42)}
 }

 extension MultiPayloadEnum: Hashable {}

 fileprivate class ClassInt: FilePrivateProtocol, InternalProtocol, PublicProtocol {
   public var value: Int
   private var tracker = LifetimeTracked(77)
   init(_ v: Int = 42) {value = v}
 }

 extension ClassInt: Equatable, Hashable {
   static func ==(left: ClassInt, right: ClassInt) -> Bool {left.value == right.value}
   func hash(into hasher: inout Hasher) { value.hash(into: &hasher) }
 }

 fileprivate struct StructInt: FilePrivateProtocol, InternalProtocol, PublicProtocol {
   public var value: Int
   private var tracker = LifetimeTracked(77)
   init(_ v: Int = 42) { value = v}
 }

 extension StructInt: Hashable, Equatable { }

 #if _runtime(_ObjC)
 fileprivate class OCClassInt: NSObject, FilePrivateProtocol, InternalProtocol, PublicProtocol {
   public var value: Int
   private var tracker = LifetimeTracked(77)
   init(_ v: Int = 42) { value = v}
 }
 #endif

 let BoxingCasts = TestSuite("BoxingCasts")

 %{
 import random
 # The test body goes into a named function and the test case just invokes that
 # function by name.  This makes debugging easier, since it's easier to set break
 # points on named functions than on arbitrary closures.
 # The function names are included in the test name
 # for ease of reference.
 testNumber = 0
 def testFunctionName():
   return "test{number}".format(number=testNumber)
 def nextTestNumber():
   global testNumber
   testNumber += 1

 # Type used for intermediate casts.  The base object gets
 # cast to one or more of these before the final test.
 class Box:
   def __init__(self, name, typeName=None, cast=None):
     self.name = name
     self.typeName = typeName or name
     self.cast_template = cast or "runtimeCast({expr}, to: {typeName}.self)!"
   def cast_oper(self, expr):
     return self.cast_template.format(expr=expr, typeName=self.typeName)

 anyHashableBox = Box(name="AnyHashable")
 all_boxes = [
     Box(name="Any", typeName="Any"),
     Box(name="AnyStatic", cast="({expr} as Any)"),
     Box(name="AnyObject"),
     Box(name="SwiftValueBox", cast="_bridgeAnythingToObjectiveC({expr})"),
     Box(name="Optional", cast="optional({expr})")
 ]
 protocol_boxes = [
     Box(name="PublicProtocol"),
 #    Box(name="FilePrivateProtocol"), # Blocked by SR-2620 aka rdar://28281488
     Box(name="InternalProtocol"),
 ]

 # Describes a base object that will be subject to a variety of casts
 default_protocols = [
   "PublicProtocol",
   "InternalProtocol",
   # "FilePrivateProtocol" # Blocked by SR-2620 aka rdar://28281488
 ]

 class Contents:
   def __init__(self, name, constructor=None, extra_targets=[], hashable=True, roundtrips=True, protocols=default_protocols, objc_only=False):
     self.name = name
     self.constructor = constructor or "{name}()".format(name=name)
     self.objc_only = objc_only

     self.targets = ["Any"]
     self.targets.extend(protocols)
     self.targets.extend(extra_targets)
     if roundtrips:
       self.targets.append(self.name)

     self.boxes = []
     self.boxes.extend(all_boxes)
     self.boxes.extend([Box(name=n) for n in protocols])
     if hashable:
       self.boxes.append(anyHashableBox)

 contents = [
   Contents(name="StructInt",
     # extra_targets=["StructInt?"],
   ),
   Contents(name="StructInt?",
     constructor="Optional<StructInt>.some(StructInt())",
     extra_targets=["StructInt"],
     roundtrips=False, # Compiler bug rejects roundtrip cast T? => Any => T?
   ),
   Contents(name="ClassInt"),
   Contents(name="OCClassInt", objc_only=True),
   Contents(name="SingleCaseEnum"),
   Contents(name="TrivialPayloadEnum"),
   Contents(name="TrivialPayloadEnum"),
   Contents(name="MultiPayloadEnum"),
   Contents(name="StructInt.Type",
     constructor="StructInt.self",
     hashable=False,
     protocols=[],
   ),
   Contents(name="StructInt.Type?",
     constructor="Optional<StructInt.Type>.some(StructInt.self)",
     hashable=False,
     protocols=[],
     extra_targets=["StructInt.Type"],
     roundtrips=False, # Compiler bug rejects roundtrip cast T? => Any => T?
   ),
   Contents(name="PublicProtocol.Protocol",
     constructor="PublicProtocol.self",
     hashable=False,
     protocols=[],
   ),
 ]

 # Code below generates a separate test case for each combination of content,
 # target type, and one or more box/intermediate types.
 }%

 % for content in contents:
 %   if content.objc_only:
 #if _runtime(_ObjC)
 %   end
 %   for target in content.targets:
 %     for box in content.boxes:
 %       nextTestNumber()
 BoxingCasts.test("${testFunctionName()}(): Casting ${box.name}(${content.name}) to ${target}") {
   // TODO: Selectively enable/disable cases that work with earlier stdlib
   if #available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *) {
     ${testFunctionName()}()
   }
 }
 func ${testFunctionName()}() {
   let a = ${content.constructor}
   let b = ${box.cast_oper("a")}
 %       # // Skip trivial cast from T? to T
 %       if not (content.name == target and box.name == "Optional"):
 %         # // Skip trivial cast from protocol box to protocol
 %         if box.name != target:
 %           # // Skip trivial cast from T? => P
 %           if not (target.endswith("Protocol") and box.name == "Optional"):
   let c = /* ${box.name}(${content.name})) */ b as? ${target}
   expectNotNil(c)
 %           end
 %         end
 %       end
   let d = runtimeCast(/* ${box.name}(${content.name}) */ b, to: ${target}.self)
   expectNotNil(d)
 }

 %       for innerBox in [random.choice(content.boxes)]:
 %         nextTestNumber()
 BoxingCasts.test("${testFunctionName()}(): Casting ${box.name}(${innerBox.name}(${content.name})) to ${target}") {
   // TODO: Selectively enable/disable cases that work with earlier stdlib
   if #available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *) {
     ${testFunctionName()}()
   }
 }
 func ${testFunctionName()}() {
   let a = ${content.constructor}
   let b = ${innerBox.cast_oper("a")}
   let c = ${box.cast_oper("b")}
 %         # // Skip trivial cast from T? to T
 %         if not (innerBox.name == target and box.name == "Optional"):
 %           # // Skip trivial cast from protocol box to protocol
 %           if box.name != target:
   let d = /* ${box.name}(${innerBox.name}(${content.name})) */ c as? ${target}
   expectNotNil(d)
 %           end
 %         end
   let e = runtimeCast(/* ${box.name}(${innerBox.name}(${content.name})) */ c, to: ${target}.self)
   expectNotNil(e)
 }
 %       end
 %     end
 %   end
 %   if content.objc_only:
 #endif
 %   end
 % end

 runAllTests()
	// BoxingCasts.swift - Tests for boxing/unboxing casts
	//
	// This source file is part of the Swift.org open source project
	//
	// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
	// Licensed under Apache License v2.0 with Runtime Library Exception
	//
	// See https://swift.org/LICENSE.txt for license information
	// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
	//
	// -----------------------------------------------------------------------------
	///
	/// Contains tests for existential, optional, and other casts that box/unbox values.
	///
	// -----------------------------------------------------------------------------
	// RUN: %empty-directory(%t)
	//
	// RUN: %gyb %s -o %t/BoxingCasts.swift
	// RUN: %line-directive %t/BoxingCasts.swift -- %target-build-swift -g -module-name a -swift-version 5 -Onone %t/BoxingCasts.swift -o %t/a.swift5.Onone.out
	// RUN: %target-codesign %t/a.swift5.Onone.out
	// RUN: %line-directive %t/BoxingCasts.swift -- %target-run %t/a.swift5.Onone.out
	//
	// Note: The RUN directives above override the default test optimizations.
	// This test is deliberately run non-optimized in order to verify the
	// behavior of runtime methods that may not be called for optimized casts.
	//
	// XXX FIXME XXX TODO XXX _Also_ build this with optimizations in order to
	// verify compiler behaviors.
	//
	// REQUIRES: executable_test

	import StdlibUnittest
	#if _runtime(_ObjC)
	import Foundation
	#endif

	fileprivate func runtimeCast<From, To> (_ x: From, to: To.Type) -> To? {
	return x as? To
	}

	fileprivate func optional<T>(_ x: T) -> Optional<T> {
	return runtimeCast(x, to: Optional<T>.self)!
	}

	fileprivate protocol FilePrivateProtocol {}
	internal protocol InternalProtocol {}
	public protocol PublicProtocol {}
	protocol UnimplementedProtocol {}

	fileprivate enum EmptyEnum: FilePrivateProtocol, InternalProtocol, PublicProtocol { }

	fileprivate enum SingleCaseEnum: FilePrivateProtocol, InternalProtocol, PublicProtocol {
	case case0
	init() {self = .case0}
	}

	fileprivate enum TrivialPayloadEnum: FilePrivateProtocol, InternalProtocol, PublicProtocol {
	case payloadCase(Int)
	init() {self = .payloadCase(42)}
	}

	extension TrivialPayloadEnum: Hashable {}

	fileprivate enum MultiPayloadEnum: FilePrivateProtocol, InternalProtocol, PublicProtocol {
	case case0(String)
	case case1(Int)
	init() {self = .case1(42)}
	}

	extension MultiPayloadEnum: Hashable {}

	fileprivate class ClassInt: FilePrivateProtocol, InternalProtocol, PublicProtocol {
	public var value: Int
	private var tracker = LifetimeTracked(77)
	init(_ v: Int = 42) {value = v}
	}

	extension ClassInt: Equatable, Hashable {
	static func ==(left: ClassInt, right: ClassInt) -> Bool {left.value == right.value}
	func hash(into hasher: inout Hasher) { value.hash(into: &hasher) }
	}

	fileprivate struct StructInt: FilePrivateProtocol, InternalProtocol, PublicProtocol {
	public var value: Int
	private var tracker = LifetimeTracked(77)
	init(_ v: Int = 42) { value = v}
	}

	extension StructInt: Hashable, Equatable { }

	#if _runtime(_ObjC)
	fileprivate class OCClassInt: NSObject, FilePrivateProtocol, InternalProtocol, PublicProtocol {
	public var value: Int
	private var tracker = LifetimeTracked(77)
	init(_ v: Int = 42) { value = v}
	}
	#endif

	let BoxingCasts = TestSuite("BoxingCasts")

	%{
	import random
	# The test body goes into a named function and the test case just invokes that
	# function by name. This makes debugging easier, since it's easier to set break
	# points on named functions than on arbitrary closures.
	# The function names are included in the test name
	# for ease of reference.
	testNumber = 0
	def testFunctionName():
	return "test{number}".format(number=testNumber)
	def nextTestNumber():
	global testNumber
	testNumber += 1

	# Type used for intermediate casts. The base object gets
	# cast to one or more of these before the final test.
	class Box:
	def __init__(self, name, typeName=None, cast=None):
	self.name = name
	self.typeName = typeName or name
	self.cast_template = cast or "runtimeCast({expr}, to: {typeName}.self)!"
	def cast_oper(self, expr):
	return self.cast_template.format(expr=expr, typeName=self.typeName)

	anyHashableBox = Box(name="AnyHashable")
	all_boxes = [
	Box(name="Any", typeName="Any"),
	Box(name="AnyStatic", cast="({expr} as Any)"),
	Box(name="AnyObject"),
	Box(name="SwiftValueBox", cast="_bridgeAnythingToObjectiveC({expr})"),
	Box(name="Optional", cast="optional({expr})")
	]
	protocol_boxes = [
	Box(name="PublicProtocol"),
	# Box(name="FilePrivateProtocol"), # Blocked by SR-2620 aka rdar://28281488
	Box(name="InternalProtocol"),
	]

	# Describes a base object that will be subject to a variety of casts
	default_protocols = [
	"PublicProtocol",
	"InternalProtocol",
	# "FilePrivateProtocol" # Blocked by SR-2620 aka rdar://28281488
	]

	class Contents:
	def __init__(self, name, constructor=None, extra_targets=[], hashable=True, roundtrips=True, protocols=default_protocols, objc_only=False):
	self.name = name
	self.constructor = constructor or "{name}()".format(name=name)
	self.objc_only = objc_only

	self.targets = ["Any"]
	self.targets.extend(protocols)
	self.targets.extend(extra_targets)
	if roundtrips:
	self.targets.append(self.name)

	self.boxes = []
	self.boxes.extend(all_boxes)
	self.boxes.extend([Box(name=n) for n in protocols])
	if hashable:
	self.boxes.append(anyHashableBox)

	contents = [
	Contents(name="StructInt",
	# extra_targets=["StructInt?"],
	),
	Contents(name="StructInt?",
	constructor="Optional<StructInt>.some(StructInt())",
	extra_targets=["StructInt"],
	roundtrips=False, # Compiler bug rejects roundtrip cast T? => Any => T?
	),
	Contents(name="ClassInt"),
	Contents(name="OCClassInt", objc_only=True),
	Contents(name="SingleCaseEnum"),
	Contents(name="TrivialPayloadEnum"),
	Contents(name="TrivialPayloadEnum"),
	Contents(name="MultiPayloadEnum"),
	Contents(name="StructInt.Type",
	constructor="StructInt.self",
	hashable=False,
	protocols=[],
	),
	Contents(name="StructInt.Type?",
	constructor="Optional<StructInt.Type>.some(StructInt.self)",
	hashable=False,
	protocols=[],
	extra_targets=["StructInt.Type"],
	roundtrips=False, # Compiler bug rejects roundtrip cast T? => Any => T?
	),
	Contents(name="PublicProtocol.Protocol",
	constructor="PublicProtocol.self",
	hashable=False,
	protocols=[],
	),
	]

	# Code below generates a separate test case for each combination of content,
	# target type, and one or more box/intermediate types.
	}%

	% for content in contents:
	% if content.objc_only:
	#if _runtime(_ObjC)
	% end
	% for target in content.targets:
	% for box in content.boxes:
	% nextTestNumber()
	BoxingCasts.test("${testFunctionName()}(): Casting ${box.name}(${content.name}) to ${target}") {
	// TODO: Selectively enable/disable cases that work with earlier stdlib
	if #available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *) {
	${testFunctionName()}()
	}
	}
	func ${testFunctionName()}() {
	let a = ${content.constructor}
	let b = ${box.cast_oper("a")}
	% # // Skip trivial cast from T? to T
	% if not (content.name == target and box.name == "Optional"):
	% # // Skip trivial cast from protocol box to protocol
	% if box.name != target:
	% # // Skip trivial cast from T? => P
	% if not (target.endswith("Protocol") and box.name == "Optional"):
	let c = /* ${box.name}(${content.name})) */ b as? ${target}
	expectNotNil(c)
	% end
	% end
	% end
	let d = runtimeCast(/* ${box.name}(${content.name}) */ b, to: ${target}.self)
	expectNotNil(d)
	}

	% for innerBox in [random.choice(content.boxes)]:
	% nextTestNumber()
	BoxingCasts.test("${testFunctionName()}(): Casting ${box.name}(${innerBox.name}(${content.name})) to ${target}") {
	// TODO: Selectively enable/disable cases that work with earlier stdlib
	if #available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *) {
	${testFunctionName()}()
	}
	}
	func ${testFunctionName()}() {
	let a = ${content.constructor}
	let b = ${innerBox.cast_oper("a")}
	let c = ${box.cast_oper("b")}
	% # // Skip trivial cast from T? to T
	% if not (innerBox.name == target and box.name == "Optional"):
	% # // Skip trivial cast from protocol box to protocol
	% if box.name != target:
	let d = /* ${box.name}(${innerBox.name}(${content.name})) */ c as? ${target}
	expectNotNil(d)
	% end
	% end
	let e = runtimeCast(/* ${box.name}(${innerBox.name}(${content.name})) */ c, to: ${target}.self)
	expectNotNil(e)
	}
	% end
	% end
	% end
	% if content.objc_only:
	#endif
	% end
	% end

	runAllTests()