CoCalc -- async

GitHub Repository: bytecodealliance/wasmtime
Path: blob/main/crates/wasi/tests/all/p2/async_.rs
¹⁶⁹² views
1
use crate::store::{Ctx, MyWasiCtx};
2
use anyhow::Result;
3
use std::path::Path;
4
use test_programs_artifacts::*;
5
use wasmtime::component::{Component, Linker};
6
use wasmtime_wasi::p2::add_to_linker_async;
7
use wasmtime_wasi::p2::bindings::Command;
8

9
async fn run(path: &str, inherit_stdio: bool) -> Result<()> {
10
    let path = Path::new(path);
11
    let name = path.file_stem().unwrap().to_str().unwrap();
12
    let engine = test_programs_artifacts::engine(|config| {
13
        config.async_support(true);
14
    });
15
    let mut linker = Linker::new(&engine);
16
    add_to_linker_async(&mut linker)?;
17

18
    let (mut store, _td) = Ctx::new(&engine, name, |builder| {
19
        if inherit_stdio {
20
            builder.inherit_stdio();
21
        }
22
        MyWasiCtx {
23
            wasi: builder.build(),
24
            table: Default::default(),
25
        }
26
    })?;
27
    let component = Component::from_file(&engine, path)?;
28
    let command = Command::instantiate_async(&mut store, &component, &linker).await?;
29
    command
30
        .wasi_cli_run()
31
        .call_run(&mut store)
32
        .await?
33
        .map_err(|()| anyhow::anyhow!("run returned a failure"))
34
}
35

36
foreach_preview1!(assert_test_exists);
37
foreach_preview2!(assert_test_exists);
38

39
// Below here is mechanical: there should be one test for every binary in
40
// wasi-tests.
41
#[test_log::test(tokio::test(flavor = "multi_thread"))]
42
async fn preview1_big_random_buf() {
43
    run(PREVIEW1_BIG_RANDOM_BUF_COMPONENT, false).await.unwrap()
44
}
45
#[test_log::test(tokio::test(flavor = "multi_thread"))]
46
async fn preview1_clock_time_get() {
47
    run(PREVIEW1_CLOCK_TIME_GET_COMPONENT, false).await.unwrap()
48
}
49
#[test_log::test(tokio::test(flavor = "multi_thread"))]
50
async fn preview1_close_preopen() {
51
    run(PREVIEW1_CLOSE_PREOPEN_COMPONENT, false).await.unwrap()
52
}
53
#[test_log::test(tokio::test(flavor = "multi_thread"))]
54
async fn preview1_dangling_fd() {
55
    run(PREVIEW1_DANGLING_FD_COMPONENT, false).await.unwrap()
56
}
57
#[test_log::test(tokio::test(flavor = "multi_thread"))]
58
async fn preview1_dangling_symlink() {
59
    run(PREVIEW1_DANGLING_SYMLINK_COMPONENT, false)
60
        .await
61
        .unwrap()
62
}
63
#[test_log::test(tokio::test(flavor = "multi_thread"))]
64
async fn preview1_directory_seek() {
65
    run(PREVIEW1_DIRECTORY_SEEK_COMPONENT, false).await.unwrap()
66
}
67
#[test_log::test(tokio::test(flavor = "multi_thread"))]
68
async fn preview1_dir_fd_op_failures() {
69
    run(PREVIEW1_DIR_FD_OP_FAILURES_COMPONENT, false)
70
        .await
71
        .unwrap()
72
}
73
#[test_log::test(tokio::test(flavor = "multi_thread"))]
74
async fn preview1_fd_advise() {
75
    run(PREVIEW1_FD_ADVISE_COMPONENT, false).await.unwrap()
76
}
77
#[test_log::test(tokio::test(flavor = "multi_thread"))]
78
async fn preview1_fd_filestat_get() {
79
    run(PREVIEW1_FD_FILESTAT_GET_COMPONENT, false)
80
        .await
81
        .unwrap()
82
}
83
#[test_log::test(tokio::test(flavor = "multi_thread"))]
84
async fn preview1_fd_filestat_set() {
85
    run(PREVIEW1_FD_FILESTAT_SET_COMPONENT, false)
86
        .await
87
        .unwrap()
88
}
89
#[test_log::test(tokio::test(flavor = "multi_thread"))]
90
async fn preview1_fd_flags_set() {
91
    run(PREVIEW1_FD_FLAGS_SET_COMPONENT, false).await.unwrap()
92
}
93
#[test_log::test(tokio::test(flavor = "multi_thread"))]
94
async fn preview1_fd_readdir() {
95
    run(PREVIEW1_FD_READDIR_COMPONENT, false).await.unwrap()
96
}
97
#[test_log::test(tokio::test(flavor = "multi_thread"))]
98
async fn preview1_file_allocate() {
99
    run(PREVIEW1_FILE_ALLOCATE_COMPONENT, false).await.unwrap()
100
}
101
#[test_log::test(tokio::test(flavor = "multi_thread"))]
102
async fn preview1_file_pread_pwrite() {
103
    run(PREVIEW1_FILE_PREAD_PWRITE_COMPONENT, false)
104
        .await
105
        .unwrap()
106
}
107
#[test_log::test(tokio::test(flavor = "multi_thread"))]
108
async fn preview1_file_read_write() {
109
    run(PREVIEW1_FILE_READ_WRITE_COMPONENT, false)
110
        .await
111
        .unwrap()
112
}
113
#[test_log::test(tokio::test(flavor = "multi_thread"))]
114
async fn preview1_file_seek_tell() {
115
    run(PREVIEW1_FILE_SEEK_TELL_COMPONENT, false).await.unwrap()
116
}
117
#[test_log::test(tokio::test(flavor = "multi_thread"))]
118
async fn preview1_file_truncation() {
119
    run(PREVIEW1_FILE_TRUNCATION_COMPONENT, false)
120
        .await
121
        .unwrap()
122
}
123
#[test_log::test(tokio::test(flavor = "multi_thread"))]
124
async fn preview1_file_unbuffered_write() {
125
    run(PREVIEW1_FILE_UNBUFFERED_WRITE_COMPONENT, false)
126
        .await
127
        .unwrap()
128
}
129
#[test_log::test(tokio::test(flavor = "multi_thread"))]
130
async fn preview1_interesting_paths() {
131
    run(PREVIEW1_INTERESTING_PATHS_COMPONENT, true)
132
        .await
133
        .unwrap()
134
}
135
#[test_log::test(tokio::test(flavor = "multi_thread"))]
136
async fn preview1_regular_file_isatty() {
137
    run(PREVIEW1_REGULAR_FILE_ISATTY_COMPONENT, false)
138
        .await
139
        .unwrap()
140
}
141
#[test_log::test(tokio::test(flavor = "multi_thread"))]
142
async fn preview1_nofollow_errors() {
143
    run(PREVIEW1_NOFOLLOW_ERRORS_COMPONENT, false)
144
        .await
145
        .unwrap()
146
}
147
#[test_log::test(tokio::test(flavor = "multi_thread"))]
148
async fn preview1_overwrite_preopen() {
149
    run(PREVIEW1_OVERWRITE_PREOPEN_COMPONENT, false)
150
        .await
151
        .unwrap()
152
}
153
#[test_log::test(tokio::test(flavor = "multi_thread"))]
154
async fn preview1_path_exists() {
155
    run(PREVIEW1_PATH_EXISTS_COMPONENT, false).await.unwrap()
156
}
157
#[test_log::test(tokio::test(flavor = "multi_thread"))]
158
async fn preview1_path_filestat() {
159
    run(PREVIEW1_PATH_FILESTAT_COMPONENT, false).await.unwrap()
160
}
161
#[test_log::test(tokio::test(flavor = "multi_thread"))]
162
async fn preview1_path_link() {
163
    run(PREVIEW1_PATH_LINK_COMPONENT, false).await.unwrap()
164
}
165
#[test_log::test(tokio::test(flavor = "multi_thread"))]
166
async fn preview1_path_open_create_existing() {
167
    run(PREVIEW1_PATH_OPEN_CREATE_EXISTING_COMPONENT, false)
168
        .await
169
        .unwrap()
170
}
171
#[test_log::test(tokio::test(flavor = "multi_thread"))]
172
async fn preview1_path_open_read_write() {
173
    run(PREVIEW1_PATH_OPEN_READ_WRITE_COMPONENT, false)
174
        .await
175
        .unwrap()
176
}
177
#[test_log::test(tokio::test(flavor = "multi_thread"))]
178
async fn preview1_path_open_dirfd_not_dir() {
179
    run(PREVIEW1_PATH_OPEN_DIRFD_NOT_DIR_COMPONENT, false)
180
        .await
181
        .unwrap()
182
}
183
#[test_log::test(tokio::test(flavor = "multi_thread"))]
184
async fn preview1_path_open_missing() {
185
    run(PREVIEW1_PATH_OPEN_MISSING_COMPONENT, false)
186
        .await
187
        .unwrap()
188
}
189
#[test_log::test(tokio::test(flavor = "multi_thread"))]
190
async fn preview1_path_open_nonblock() {
191
    run(PREVIEW1_PATH_OPEN_NONBLOCK_COMPONENT, false)
192
        .await
193
        .unwrap()
194
}
195
#[test_log::test(tokio::test(flavor = "multi_thread"))]
196
async fn preview1_path_rename_dir_trailing_slashes() {
197
    run(PREVIEW1_PATH_RENAME_DIR_TRAILING_SLASHES_COMPONENT, false)
198
        .await
199
        .unwrap()
200
}
201
#[test_log::test(tokio::test(flavor = "multi_thread"))]
202
async fn preview1_path_rename() {
203
    run(PREVIEW1_PATH_RENAME_COMPONENT, false).await.unwrap()
204
}
205
#[test_log::test(tokio::test(flavor = "multi_thread"))]
206
async fn preview1_path_symlink_trailing_slashes() {
207
    run(PREVIEW1_PATH_SYMLINK_TRAILING_SLASHES_COMPONENT, false)
208
        .await
209
        .unwrap()
210
}
211
#[test_log::test(tokio::test(flavor = "multi_thread"))]
212
async fn preview1_poll_oneoff_files() {
213
    run(PREVIEW1_POLL_ONEOFF_FILES_COMPONENT, false)
214
        .await
215
        .unwrap()
216
}
217

218
#[test_log::test(tokio::test(flavor = "multi_thread"))]
219
async fn preview1_poll_oneoff_stdio() {
220
    run(PREVIEW1_POLL_ONEOFF_STDIO_COMPONENT, true)
221
        .await
222
        .unwrap()
223
}
224
#[test_log::test(tokio::test(flavor = "multi_thread"))]
225
async fn preview1_readlink() {
226
    run(PREVIEW1_READLINK_COMPONENT, false).await.unwrap()
227
}
228
#[test_log::test(tokio::test(flavor = "multi_thread"))]
229
async fn preview1_remove_directory() {
230
    run(PREVIEW1_REMOVE_DIRECTORY_COMPONENT, false)
231
        .await
232
        .unwrap()
233
}
234
#[test_log::test(tokio::test(flavor = "multi_thread"))]
235
async fn preview1_remove_nonempty_directory() {
236
    run(PREVIEW1_REMOVE_NONEMPTY_DIRECTORY_COMPONENT, false)
237
        .await
238
        .unwrap()
239
}
240
#[test_log::test(tokio::test(flavor = "multi_thread"))]
241
async fn preview1_renumber() {
242
    run(PREVIEW1_RENUMBER_COMPONENT, false).await.unwrap()
243
}
244
#[test_log::test(tokio::test(flavor = "multi_thread"))]
245
async fn preview1_sched_yield() {
246
    run(PREVIEW1_SCHED_YIELD_COMPONENT, false).await.unwrap()
247
}
248
#[test_log::test(tokio::test(flavor = "multi_thread"))]
249
async fn preview1_stdio() {
250
    run(PREVIEW1_STDIO_COMPONENT, false).await.unwrap()
251
}
252
#[test_log::test(tokio::test(flavor = "multi_thread"))]
253
async fn preview1_stdio_isatty() {
254
    // If the test process is setup such that stdio is a terminal:
255
    if test_programs_artifacts::stdio_is_terminal() {
256
        // Inherit stdio, test asserts each is not tty:
257
        run(PREVIEW1_STDIO_ISATTY_COMPONENT, true).await.unwrap()
258
    }
259
}
260
#[test_log::test(tokio::test(flavor = "multi_thread"))]
261
async fn preview1_stdio_not_isatty() {
262
    // Don't inherit stdio, test asserts each is not tty:
263
    run(PREVIEW1_STDIO_NOT_ISATTY_COMPONENT, false)
264
        .await
265
        .unwrap()
266
}
267
#[test_log::test(tokio::test(flavor = "multi_thread"))]
268
async fn preview1_symlink_create() {
269
    run(PREVIEW1_SYMLINK_CREATE_COMPONENT, false).await.unwrap()
270
}
271
#[test_log::test(tokio::test(flavor = "multi_thread"))]
272
async fn preview1_symlink_filestat() {
273
    run(PREVIEW1_SYMLINK_FILESTAT_COMPONENT, false)
274
        .await
275
        .unwrap()
276
}
277
#[test_log::test(tokio::test(flavor = "multi_thread"))]
278
async fn preview1_symlink_loop() {
279
    run(PREVIEW1_SYMLINK_LOOP_COMPONENT, false).await.unwrap()
280
}
281
#[test_log::test(tokio::test(flavor = "multi_thread"))]
282
async fn preview1_unlink_file_trailing_slashes() {
283
    run(PREVIEW1_UNLINK_FILE_TRAILING_SLASHES_COMPONENT, false)
284
        .await
285
        .unwrap()
286
}
287
#[test_log::test(tokio::test(flavor = "multi_thread"))]
288
async fn preview1_path_open_preopen() {
289
    run(PREVIEW1_PATH_OPEN_PREOPEN_COMPONENT, false)
290
        .await
291
        .unwrap()
292
}
293
#[test_log::test(tokio::test(flavor = "multi_thread"))]
294
async fn preview1_unicode_output() {
295
    run(PREVIEW1_UNICODE_OUTPUT_COMPONENT, true).await.unwrap()
296
}
297
#[test_log::test(tokio::test(flavor = "multi_thread"))]
298
async fn preview1_file_write() {
299
    run(PREVIEW1_FILE_WRITE_COMPONENT, false).await.unwrap()
300
}
301
#[test_log::test(tokio::test(flavor = "multi_thread"))]
302
async fn preview1_path_open_lots() {
303
    run(PREVIEW1_PATH_OPEN_LOTS_COMPONENT, false).await.unwrap()
304
}
305

306
#[test_log::test(tokio::test(flavor = "multi_thread"))]
307
async fn preview2_sleep() {
308
    run(PREVIEW2_SLEEP_COMPONENT, false).await.unwrap()
309
}
310
#[test_log::test(tokio::test(flavor = "multi_thread"))]
311
async fn preview2_random() {
312
    run(PREVIEW2_RANDOM_COMPONENT, false).await.unwrap()
313
}
314
#[test_log::test(tokio::test(flavor = "multi_thread"))]
315
async fn preview2_ip_name_lookup() {
316
    run(PREVIEW2_IP_NAME_LOOKUP_COMPONENT, false).await.unwrap()
317
}
318
#[test_log::test(tokio::test(flavor = "multi_thread"))]
319
async fn preview2_tcp_sockopts() {
320
    run(PREVIEW2_TCP_SOCKOPTS_COMPONENT, false).await.unwrap()
321
}
322
#[test_log::test(tokio::test(flavor = "multi_thread"))]
323
async fn preview2_tcp_sample_application() {
324
    run(PREVIEW2_TCP_SAMPLE_APPLICATION_COMPONENT, false)
325
        .await
326
        .unwrap()
327
}
328
#[test_log::test(tokio::test(flavor = "multi_thread"))]
329
async fn preview2_tcp_states() {
330
    run(PREVIEW2_TCP_STATES_COMPONENT, false).await.unwrap()
331
}
332
#[test_log::test(tokio::test(flavor = "multi_thread"))]
333
async fn preview2_tcp_streams() {
334
    run(PREVIEW2_TCP_STREAMS_COMPONENT, false).await.unwrap()
335
}
336
#[test_log::test(tokio::test(flavor = "multi_thread"))]
337
async fn preview2_tcp_bind() {
338
    run(PREVIEW2_TCP_BIND_COMPONENT, false).await.unwrap()
339
}
340
#[test_log::test(tokio::test(flavor = "multi_thread"))]
341
async fn preview2_tcp_connect() {
342
    run(PREVIEW2_TCP_CONNECT_COMPONENT, false).await.unwrap()
343
}
344
#[test_log::test(tokio::test(flavor = "multi_thread"))]
345
async fn preview2_udp_sockopts() {
346
    run(PREVIEW2_UDP_SOCKOPTS_COMPONENT, false).await.unwrap()
347
}
348
#[test_log::test(tokio::test(flavor = "multi_thread"))]
349
async fn preview2_udp_sample_application() {
350
    run(PREVIEW2_UDP_SAMPLE_APPLICATION_COMPONENT, false)
351
        .await
352
        .unwrap()
353
}
354
#[test_log::test(tokio::test(flavor = "multi_thread"))]
355
async fn preview2_udp_states() {
356
    run(PREVIEW2_UDP_STATES_COMPONENT, false).await.unwrap()
357
}
358
#[test_log::test(tokio::test(flavor = "multi_thread"))]
359
async fn preview2_udp_bind() {
360
    run(PREVIEW2_UDP_BIND_COMPONENT, false).await.unwrap()
361
}
362
#[test_log::test(tokio::test(flavor = "multi_thread"))]
363
async fn preview2_udp_connect() {
364
    run(PREVIEW2_UDP_CONNECT_COMPONENT, false).await.unwrap()
365
}
366
#[test_log::test(tokio::test(flavor = "multi_thread"))]
367
async fn preview2_stream_pollable_correct() {
368
    run(PREVIEW2_STREAM_POLLABLE_CORRECT_COMPONENT, false)
369
        .await
370
        .unwrap()
371
}
372
#[test_log::test(tokio::test(flavor = "multi_thread"))]
373
async fn preview2_stream_pollable_traps() {
374
    let e = run(PREVIEW2_STREAM_POLLABLE_TRAPS_COMPONENT, false)
375
        .await
376
        .unwrap_err();
377
    assert_eq!(
378
        format!("{}", e.source().expect("trap source")),
379
        "resource has children"
380
    )
381
}
382
#[test_log::test(tokio::test(flavor = "multi_thread"))]
383
async fn preview2_pollable_correct() {
384
    run(PREVIEW2_POLLABLE_CORRECT_COMPONENT, false)
385
        .await
386
        .unwrap()
387
}
388
#[test_log::test(tokio::test(flavor = "multi_thread"))]
389
async fn preview2_pollable_traps() {
390
    let e = run(PREVIEW2_POLLABLE_TRAPS_COMPONENT, false)
391
        .await
392
        .unwrap_err();
393
    assert_eq!(
394
        format!("{}", e.source().expect("trap source")),
395
        "empty poll list"
396
    )
397
}
398
#[test_log::test(tokio::test(flavor = "multi_thread"))]
399
async fn preview2_adapter_badfd() {
400
    run(PREVIEW2_ADAPTER_BADFD_COMPONENT, false).await.unwrap()
401
}
402
#[test_log::test(tokio::test(flavor = "multi_thread"))]
403
async fn preview2_file_read_write() {
404
    run(PREVIEW2_FILE_READ_WRITE_COMPONENT, false)
405
        .await
406
        .unwrap()
407
}
408

409
Product

Resources

Company
