1use proc_macro::TokenStream;
2use quote::{format_ident, quote};
3use std::mem;
4use syn::{
5 parse_macro_input, parse_quote, spanned::Spanned as _, AttributeArgs, FnArg, ItemFn, Lit, Meta,
6 NestedMeta, Type,
7};
8
9#[proc_macro_attribute]
10pub fn test(args: TokenStream, function: TokenStream) -> TokenStream {
11 let mut namespace = format_ident!("gpui");
12
13 let args = syn::parse_macro_input!(args as AttributeArgs);
14 let mut max_retries = 0;
15 let mut num_iterations = 1;
16 let mut starting_seed = 0;
17
18 for arg in args {
19 match arg {
20 NestedMeta::Meta(Meta::Path(name))
21 if name.get_ident().map_or(false, |n| n == "self") =>
22 {
23 namespace = format_ident!("crate");
24 }
25 NestedMeta::Meta(Meta::NameValue(meta)) => {
26 let key_name = meta.path.get_ident().map(|i| i.to_string());
27 let result = (|| {
28 match key_name.as_ref().map(String::as_str) {
29 Some("retries") => max_retries = parse_int(&meta.lit)?,
30 Some("iterations") => num_iterations = parse_int(&meta.lit)?,
31 Some("seed") => starting_seed = parse_int(&meta.lit)?,
32 _ => {
33 return Err(TokenStream::from(
34 syn::Error::new(meta.path.span(), "invalid argument")
35 .into_compile_error(),
36 ))
37 }
38 }
39 Ok(())
40 })();
41
42 if let Err(tokens) = result {
43 return tokens;
44 }
45 }
46 other => {
47 return TokenStream::from(
48 syn::Error::new_spanned(other, "invalid argument").into_compile_error(),
49 )
50 }
51 }
52 }
53
54 let mut inner_fn = parse_macro_input!(function as ItemFn);
55 if max_retries > 0 && num_iterations > 1 {
56 return TokenStream::from(
57 syn::Error::new_spanned(inner_fn, "retries and randomized iterations can't be mixed")
58 .into_compile_error(),
59 );
60 }
61 let inner_fn_attributes = mem::take(&mut inner_fn.attrs);
62 let inner_fn_name = format_ident!("_{}", inner_fn.sig.ident);
63 let outer_fn_name = mem::replace(&mut inner_fn.sig.ident, inner_fn_name.clone());
64
65 let mut outer_fn: ItemFn = if inner_fn.sig.asyncness.is_some() {
66 // Pass to the test function the number of app contexts that it needs,
67 // based on its parameter list.
68 let mut inner_fn_args = proc_macro2::TokenStream::new();
69 for (ix, arg) in inner_fn.sig.inputs.iter().enumerate() {
70 if let FnArg::Typed(arg) = arg {
71 if let Type::Path(ty) = &*arg.ty {
72 let last_segment = ty.path.segments.last();
73 match last_segment.map(|s| s.ident.to_string()).as_deref() {
74 Some("TestAppContext") => {
75 let first_entity_id = ix * 100_000;
76 inner_fn_args.extend(quote!(#namespace::TestAppContext::new(
77 foreground_platform.clone(),
78 platform.clone(),
79 foreground.clone(),
80 background.clone(),
81 font_cache.clone(),
82 #first_entity_id),
83 ));
84 }
85 Some("StdRng") => {
86 inner_fn_args.extend(quote!(rand::SeedableRng::seed_from_u64(seed)));
87 }
88 _ => {
89 return TokenStream::from(
90 syn::Error::new_spanned(arg, "invalid argument")
91 .into_compile_error(),
92 )
93 }
94 }
95 } else {
96 return TokenStream::from(
97 syn::Error::new_spanned(arg, "invalid argument").into_compile_error(),
98 );
99 }
100 } else {
101 return TokenStream::from(
102 syn::Error::new_spanned(arg, "invalid argument").into_compile_error(),
103 );
104 }
105 }
106
107 parse_quote! {
108 #[test]
109 fn #outer_fn_name() {
110 #inner_fn
111
112 let is_randomized = #num_iterations > 1;
113 let mut num_iterations = #num_iterations as u64;
114 let mut starting_seed = #starting_seed as u64;
115 if is_randomized {
116 if let Ok(value) = std::env::var("SEED") {
117 starting_seed = value.parse().expect("invalid SEED variable");
118 }
119 if let Ok(value) = std::env::var("ITERATIONS") {
120 num_iterations = value.parse().expect("invalid ITERATIONS variable");
121 }
122 }
123
124 let mut atomic_seed = std::sync::atomic::AtomicU64::new(starting_seed as u64);
125 let mut retries = 0;
126
127 loop {
128 let result = std::panic::catch_unwind(|| {
129 let foreground_platform = std::rc::Rc::new(#namespace::platform::test::foreground_platform());
130 let platform = std::sync::Arc::new(#namespace::platform::test::platform());
131 let font_system = #namespace::Platform::fonts(platform.as_ref());
132 let font_cache = std::sync::Arc::new(#namespace::FontCache::new(font_system));
133
134 loop {
135 let seed = atomic_seed.load(std::sync::atomic::Ordering::SeqCst);
136 if seed >= starting_seed + num_iterations {
137 break;
138 }
139
140 if is_randomized {
141 dbg!(seed);
142 }
143
144 let (foreground, background) = #namespace::executor::deterministic(seed);
145 foreground.run(#inner_fn_name(#inner_fn_args));
146 atomic_seed.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
147 }
148 });
149
150 match result {
151 Ok(result) => {
152 break;
153 }
154 Err(error) => {
155 if retries < #max_retries {
156 retries += 1;
157 println!("retrying: attempt {}", retries);
158 } else {
159 if is_randomized {
160 eprintln!("failing seed: {}", atomic_seed.load(std::sync::atomic::Ordering::SeqCst));
161 }
162 std::panic::resume_unwind(error);
163 }
164 }
165 }
166 }
167 }
168 }
169 } else {
170 let mut inner_fn_args = proc_macro2::TokenStream::new();
171 for arg in inner_fn.sig.inputs.iter() {
172 if let FnArg::Typed(arg) = arg {
173 if let Type::Path(ty) = &*arg.ty {
174 let last_segment = ty.path.segments.last();
175 if let Some("StdRng") = last_segment.map(|s| s.ident.to_string()).as_deref() {
176 inner_fn_args.extend(quote!(rand::SeedableRng::seed_from_u64(seed),));
177 }
178 } else {
179 inner_fn_args.extend(quote!(cx,));
180 }
181 } else {
182 return TokenStream::from(
183 syn::Error::new_spanned(arg, "invalid argument").into_compile_error(),
184 );
185 }
186 }
187
188 parse_quote! {
189 #[test]
190 fn #outer_fn_name() {
191 #inner_fn
192
193 let is_randomized = #num_iterations > 1;
194 let mut num_iterations = #num_iterations as u64;
195 let mut starting_seed = #starting_seed as u64;
196 if is_randomized {
197 if let Ok(value) = std::env::var("SEED") {
198 starting_seed = value.parse().expect("invalid SEED variable");
199 }
200 if let Ok(value) = std::env::var("ITERATIONS") {
201 num_iterations = value.parse().expect("invalid ITERATIONS variable");
202 }
203 }
204
205 let mut atomic_seed = std::sync::atomic::AtomicU64::new(starting_seed as u64);
206 let mut retries = 0;
207
208 loop {
209 let result = std::panic::catch_unwind(|| {
210 let foreground_platform = std::rc::Rc::new(#namespace::platform::test::foreground_platform());
211 let platform = std::sync::Arc::new(#namespace::platform::test::platform());
212 let font_system = #namespace::Platform::fonts(platform.as_ref());
213 let font_cache = std::sync::Arc::new(#namespace::FontCache::new(font_system));
214
215 loop {
216 let seed = atomic_seed.load(std::sync::atomic::Ordering::SeqCst);
217 if seed >= starting_seed + num_iterations {
218 break;
219 }
220
221 if is_randomized {
222 dbg!(seed);
223 }
224
225 #namespace::App::test(foreground_platform.clone(), platform.clone(), font_cache.clone(), |cx| {
226 #inner_fn_name(#inner_fn_args);
227 });
228 atomic_seed.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
229 }
230 });
231
232 match result {
233 Ok(_) => {
234 break;
235 }
236 Err(error) => {
237 if retries < #max_retries {
238 retries += 1;
239 println!("retrying: attempt {}", retries);
240 } else {
241 if is_randomized {
242 eprintln!("failing seed: {}", atomic_seed.load(std::sync::atomic::Ordering::SeqCst));
243 }
244 std::panic::resume_unwind(error);
245 }
246 }
247 }
248 }
249 }
250 }
251 };
252 outer_fn.attrs.extend(inner_fn_attributes);
253
254 TokenStream::from(quote!(#outer_fn))
255}
256
257fn parse_int(literal: &Lit) -> Result<usize, TokenStream> {
258 let result = if let Lit::Int(int) = &literal {
259 int.base10_parse()
260 } else {
261 Err(syn::Error::new(literal.span(), "must be an integer"))
262 };
263
264 result.map_err(|err| TokenStream::from(err.into_compile_error()))
265}