swift/test/Concurrency/Runtime/async_taskgroup_discarding.swift at main · ian-twilightcoder/swift · GitHub

Name: swift/test/Concurrency/Runtime/async_taskgroup_discarding.swift at main · ian-twilightcoder/swift · GitHub
Rating: 4.7 (6239 reviews)
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
// RUN: %target-run-simple-swift( -Xfrontend -disable-availability-checking -parse-as-library) | %FileCheck %s
// TODO: move to target-run-simple-leaks-swift once CI is using at least Xcode 14.3

// REQUIRES: concurrency
// REQUIRES: executable_test
// REQUIRES: concurrency_runtime

// UNSUPPORTED: back_deployment_runtime
// UNSUPPORTED: freestanding

// FIXME: enable discarding taskgroup on windows; rdar://104762037
// UNSUPPORTED: OS=windows-msvc

import _Concurrency

finalclassPayloadFirst{}
finalclassPayloadSecond{}

actorSimpleCountDownLatch{
letfrom:Int
varcount:Int

varcontinuation:CheckedContinuation<Void,Never>?

init(from:Int){
self.from = from
self.count = from
}

func hit(){
defer{ count -=1}
print("hit @ \(count)")
if count ==0{
fatalError("Counted down more times than expected! (From: \(from))")
}elseif count ==1{
print("hit resume")
 continuation?.resume()
}
}

func wait()async{
guardself.count >0else{
return // we're done
}

returnawaitwithCheckedContinuation{ cc in
self.continuation = cc
}
}
}

finalclassErrorFirst:Error{
letfirst:PayloadFirst
letid:String
letlatch:SimpleCountDownLatch

init(latch:SimpleCountDownLatch, file:String= #fileID, line:UInt= #line){
self.latch = latch
self.id ="\(file):\(line)"
 first =.init()
print("init \(self) id:\(id)")
}
deinit{
print("deinit \(self) id:\(id)")
Task{[latch]inawait latch.hit()}
}
}

// Should not really matter that different types, but want to make really sure
finalclassErrorSecond:Error{
letfirst:PayloadFirst
letid:String
letlatch:SimpleCountDownLatch

init(latch:SimpleCountDownLatch, file:String= #fileID, line:UInt= #line){
self.latch = latch
self.id ="\(file):\(line)"
 first =.init()
print("init \(self) id:\(id)")
}
deinit{
print("deinit \(self) id:\(id)")
Task{[latch]inawait latch.hit()}
}
}


func shouldStartWith(_ lhs:Any, _ rhs:Any){
letl="\(lhs)"
letr="\(rhs)"
precondition(l.prefix("\(r)".count)== r,"'\(l)' did not start with '\(r)'")
}

// NOTE: Not as StdlibUnittest/TestSuite since these types of tests are unreasonably slow to load/debug.

@discardableResult
func one()->Int{
1
}

@mainstructMain{
staticfunc main()async{
letlatch=SimpleCountDownLatch(from:6)
do{

letgot=tryawaitwithThrowingDiscardingTaskGroup(){ group in
 group.addTask{one()}
 group.addTask{throwErrorFirst(latch: latch)}
 group.addTask{throwErrorFirst(latch: latch)}
 group.addTask{throwErrorFirst(latch: latch)}

 group.addTask{throwErrorSecond(latch: latch)}
 group.addTask{throwErrorSecond(latch: latch)}
 group.addTask{throwErrorSecond(latch: latch)}

return12
}
fatalError("expected error to be re-thrown, got: \(got)")
}catch{
shouldStartWith(error,"main.Error")
}
 // CHECK: deinit main.Error
 // CHECK: deinit main.Error
 // CHECK: deinit main.Error

 // CHECK: deinit main.Error
 // CHECK: deinit main.Error
 // CHECK: deinit main.Error
await latch.wait()
print("done") // CHECK: done
}
}