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
109
110
111
|
// RUN: %empty-directory(%t)
// RUN: %target-swift-frontend-emit-module -emit-module-path %t/FakeDistributedActorSystems.swiftmodule -module-name FakeDistributedActorSystems %S/../Inputs/FakeDistributedActorSystems.swift
// RUN: %target-build-swift -parse-as-library -I %t %s %S/../Inputs/FakeDistributedActorSystems.swift -o %t/a.out
// RUN: %target-codesign %t/a.out
// RUN: %target-run %t/a.out
// REQUIRES: executable_test
// REQUIRES: concurrency
// REQUIRES: distributed
// REQUIRES: concurrency_runtime
// UNSUPPORTED: back_deployment_runtime
// UNSUPPORTED: back_deploy_concurrency
// UNSUPPORTED: use_os_stdlib
// UNSUPPORTED: freestanding
import StdlibUnittest
import Distributed
import FakeDistributedActorSystems
@available(SwiftStdlib 5.7, *)
typealias DefaultDistributedActorSystem = FakeRoundtripActorSystem
@available(SwiftStdlib 5.9, *)
func checkAssumeLocalDistributedActor(actor: MainDistributedFriend) /* synchronous! */ -> String {
actor.assumeIsolated { dist in
print("gained access to: \(dist.isolatedProperty)")
return dist.isolatedProperty
}
}
@available(SwiftStdlib 5.9, *)
func checkAssumeMainActor(actor: MainDistributedFriend) /* synchronous! */ {
MainActor.assumeIsolated {
print("yay")
}
}
@available(SwiftStdlib 5.9, *)
@MainActor
func check(actor: MainDistributedFriend) {
_ = checkAssumeLocalDistributedActor(actor: actor)
checkAssumeMainActor(actor: actor)
}
@available(SwiftStdlib 5.9, *)
distributed actor MainDistributedFriend {
nonisolated var unownedExecutor: UnownedSerialExecutor {
print("get unowned executor")
return MainActor.sharedUnownedExecutor
}
let isolatedProperty: String = "Hello there!"
distributed func test(x: Int) async throws {
print("executed: \(#function)")
defer {
print("done executed: \(#function)")
}
return checkAssumeMainActor(actor: self)
}
}
@available(SwiftStdlib 5.9, *)
actor OtherMain {
nonisolated var unownedExecutor: UnownedSerialExecutor {
return MainActor.sharedUnownedExecutor
}
func checkAssumeLocalDistributedActor(actor: MainDistributedFriend) /* synchronous! */ {
_ = actor.assumeIsolated { dist in
print("gained access to: \(dist.isolatedProperty)")
return dist.isolatedProperty
}
}
}
@available(SwiftStdlib 5.7, *)
@main struct Main {
static func main() async {
if #available(SwiftStdlib 5.9, *) {
let tests = TestSuite("AssumeLocalDistributedActorExecutor")
let system = FakeRoundtripActorSystem()
let distLocal = MainDistributedFriend(actorSystem: system)
tests.test("assumeOnLocalDistributedActorExecutor: assume the main executor, inside the DistributedMainDistributedFriend local actor") {
_ = checkAssumeLocalDistributedActor(actor: distLocal)
try! await distLocal.test(x: 42)
}
tests.test("assumeOnLocalDistributedActorExecutor: assume same actor as the DistributedMainDistributedFriend") {
await OtherMain().checkAssumeLocalDistributedActor(actor: distLocal)
try! await distLocal.test(x: 42)
}
tests.test("assumeOnLocalDistributedActorExecutor: wrongly assume the same actor as the DistributedmainFriend") {
await OtherMain().checkAssumeLocalDistributedActor(actor: distLocal)
}
tests.test("assumeOnLocalDistributedActorExecutor: on remote actor reference") {
expectCrashLater(withMessage: "Cannot assume to be 'isolated MainDistributedFriend' since distributed actor 'a.MainDistributedFriend' is a remote actor reference.")
let remoteRef = try! MainDistributedFriend.resolve(id: distLocal.id, using: system)
await OtherMain().checkAssumeLocalDistributedActor(actor: remoteRef)
}
await runAllTestsAsync()
}
}
}
|
