1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
|
//===--- BridgeNonVerbatim.swift - Array bridging implementation test -----===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// When a ContiguousArray<T> is bridged to Objective-C, and T isn't
// "bridged verbatim," Cocoa operations like objectAtIndex may have
// to conjure up an object to return, and this object is expected to
// outlive the array.
//
//===----------------------------------------------------------------------===//
// RUN: %target-run-stdlib-swift
// REQUIRES: executable_test
//
// REQUIRES: objc_interop
import Swift
import SwiftShims
import Foundation
import StdlibUnittest
import StdlibUnittestFoundationExtras
struct X : _ObjectiveCBridgeable {
init(_ value: Int) {
self.value = value
}
func _bridgeToObjectiveC() -> LifetimeTracked {
return LifetimeTracked(value)
}
static func _forceBridgeFromObjectiveC(
_ x: LifetimeTracked,
result: inout X?
) {
result = X(x.value)
}
static func _conditionallyBridgeFromObjectiveC(
_ x: LifetimeTracked,
result: inout X?
) -> Bool {
result = X(x.value)
return true
}
static func _unconditionallyBridgeFromObjectiveC(_ source: LifetimeTracked?)
-> X {
var result: X?
_forceBridgeFromObjectiveC(source!, result: &result)
return result!
}
var value: Int
}
let BridgeNonVerbatimTests = TestSuite("BrideNonVerbatim")
BridgeNonVerbatimTests.test("testing") {
func testScope() {
let a = [X(1), X(2), X(3)]
let nsx: NSArray = a._bridgeToObjectiveC()
// construction of these tracked objects is lazy
expectEqual(LifetimeTracked.instances, 0)
// We can get a single element out
let one = nsx.object(at: 0) as! LifetimeTracked
expectEqual(one.value, 1)
// We can get the element again, but it may not have the same identity
let anotherOne = nsx.object(at: 0) as! LifetimeTracked
expectEqualReference(one, anotherOne)
// Because the elements come back at +0, we really don't want to
// treat them as objects, or we'll get double deletion
var objects: [Int] = [0, 0]
objects.withUnsafeMutableBufferPointer {
// FIXME: Can't elide signature and use $0 here <rdar://problem/17770732>
(buf: inout UnsafeMutableBufferPointer<Int>) -> () in
nsx.available_getObjects(
AutoreleasingUnsafeMutablePointer(buf.baseAddress!),
range: NSRange(location: 1, length: 2))
return
}
var x = objects[0]
// getObjects yields them at +0:
expectTrue(_isUnique_native(&x))
}
autoreleasepool() {
testScope()
}
// leaks?
expectEqual(LifetimeTracked.instances, 0)
}
runAllTests()
|
