1 | // vim: tw=80 |
2 | use super::*; |
3 | |
4 | use quote::ToTokens; |
5 | |
6 | /// Convert a trait object reference into a reference to a Boxed trait |
7 | /// |
8 | /// # Returns |
9 | /// |
10 | /// Returns `true` if it was necessary to box the type. |
11 | fn dedynify(ty: &mut Type) -> bool { |
12 | if let Type::Reference(ref mut tr) = ty { |
13 | if let Type::TraitObject(ref tto) = tr.elem.as_ref() { |
14 | if let Some(lt) = &tr.lifetime { |
15 | if lt.ident == "static" { |
16 | // For methods that return 'static references, the user can |
17 | // usually actually supply one, unlike nonstatic references. |
18 | // dedynify is unneeded and harmful in such cases. |
19 | // |
20 | // But we do need to add parens to prevent parsing errors |
21 | // when methods like returning add a `+ Send` to the output |
22 | // type. |
23 | *tr.elem = parse2(quote!((#tto))).unwrap(); |
24 | return false; |
25 | } |
26 | } |
27 | |
28 | *tr.elem = parse2(quote!(Box<#tto>)).unwrap(); |
29 | return true; |
30 | } |
31 | } |
32 | false |
33 | } |
34 | |
35 | /// Convert a special reference type like "&str" into a reference to its owned |
36 | /// type like "&String". |
37 | fn destrify(ty: &mut Type) { |
38 | if let Type::Reference(ref mut tr) = ty { |
39 | if let Some(lt) = &tr.lifetime { |
40 | if lt.ident == "static" { |
41 | // For methods that return 'static references, the user can |
42 | // usually actually supply one, unlike nonstatic references. |
43 | // destrify is unneeded and harmful in such cases. |
44 | return; |
45 | } |
46 | } |
47 | |
48 | let path_ty: TypePath = parse2(quote!(Path)).unwrap(); |
49 | let pathbuf_ty: Type = parse2(quote!(::std::path::PathBuf)).unwrap(); |
50 | |
51 | let str_ty: TypePath = parse2(quote!(str)).unwrap(); |
52 | let string_ty: Type = parse2(quote!(::std::string::String)).unwrap(); |
53 | |
54 | let cstr_ty: TypePath = parse2(quote!(CStr)).unwrap(); |
55 | let cstring_ty: Type = parse2(quote!(::std::ffi::CString)).unwrap(); |
56 | |
57 | let osstr_ty: TypePath = parse2(quote!(OsStr)).unwrap(); |
58 | let osstring_ty: Type = parse2(quote!(::std::ffi::OsString)).unwrap(); |
59 | |
60 | match tr.elem.as_ref() { |
61 | Type::Path(ref path) if *path == cstr_ty => |
62 | *tr.elem = cstring_ty, |
63 | Type::Path(ref path) if *path == osstr_ty => |
64 | *tr.elem = osstring_ty, |
65 | Type::Path(ref path) if *path == path_ty => |
66 | *tr.elem = pathbuf_ty, |
67 | Type::Path(ref path) if *path == str_ty => |
68 | *tr.elem = string_ty, |
69 | Type::Slice(ts) => { |
70 | let inner = (*ts.elem).clone(); |
71 | let mut segments = Punctuated::new(); |
72 | segments.push(format_ident!("std" ).into()); |
73 | segments.push(format_ident!("vec" ).into()); |
74 | let mut v: PathSegment = format_ident!("Vec" ).into(); |
75 | let mut abga_args = Punctuated::new(); |
76 | abga_args.push(GenericArgument::Type(inner)); |
77 | v.arguments = PathArguments::AngleBracketed( |
78 | AngleBracketedGenericArguments { |
79 | colon2_token: None, |
80 | lt_token: Token![<](Span::call_site()), |
81 | args: abga_args, |
82 | gt_token: Token![>](Span::call_site()), |
83 | } |
84 | ); |
85 | segments.push(v); |
86 | |
87 | *tr.elem = Type::Path(TypePath { |
88 | qself: None, |
89 | path: Path { |
90 | leading_colon: Some(Token![::](Span::call_site())), |
91 | segments |
92 | } |
93 | }); |
94 | }, |
95 | _ => (), // Nothing to do |
96 | }; |
97 | } |
98 | } |
99 | |
100 | /// Return the owned version of the input. |
101 | fn ownify(ty: &Type) -> Type { |
102 | if let Type::Reference(ref tr) = &ty { |
103 | if tr.lifetime.as_ref().map_or(false, |lt| lt.ident == "static" ) |
104 | { |
105 | // Just a static expectation |
106 | ty.clone() |
107 | } else { |
108 | *tr.elem.clone() |
109 | } |
110 | } else { |
111 | ty.clone() |
112 | } |
113 | } |
114 | |
115 | /// Add Send + Sync to a where clause |
116 | fn send_syncify(wc: &mut Option<WhereClause>, bounded_ty: Type) { |
117 | let mut bounds = Punctuated::new(); |
118 | bounds.push(TypeParamBound::Trait(TraitBound { |
119 | paren_token: None, |
120 | modifier: TraitBoundModifier::None, |
121 | lifetimes: None, |
122 | path: Path::from(format_ident!("Send" )) |
123 | })); |
124 | bounds.push(TypeParamBound::Trait(TraitBound { |
125 | paren_token: None, |
126 | modifier: TraitBoundModifier::None, |
127 | lifetimes: None, |
128 | path: Path::from(format_ident!("Sync" )) |
129 | })); |
130 | if wc.is_none() { |
131 | *wc = Some(WhereClause { |
132 | where_token: <Token![where]>::default(), |
133 | predicates: Punctuated::new() |
134 | }); |
135 | } |
136 | wc.as_mut().unwrap() |
137 | .predicates.push( |
138 | WherePredicate::Type( |
139 | PredicateType { |
140 | lifetimes: None, |
141 | bounded_ty, |
142 | colon_token: Default::default(), |
143 | bounds |
144 | } |
145 | ) |
146 | ); |
147 | } |
148 | |
149 | /// Build a MockFunction. |
150 | #[derive(Clone, Copy, Debug)] |
151 | pub(crate) struct Builder<'a> { |
152 | attrs: &'a [Attribute], |
153 | call_levels: Option<usize>, |
154 | levels: usize, |
155 | parent: Option<&'a Ident>, |
156 | sig: &'a Signature, |
157 | struct_: Option<&'a Ident>, |
158 | struct_generics: Option<&'a Generics>, |
159 | trait_: Option<&'a Ident>, |
160 | vis: &'a Visibility |
161 | } |
162 | |
163 | impl<'a> Builder<'a> { |
164 | pub fn attrs(&mut self, attrs: &'a[Attribute]) -> &mut Self { |
165 | self.attrs = attrs; |
166 | self |
167 | } |
168 | |
169 | pub fn build(self) -> MockFunction { |
170 | let mut argnames = Vec::new(); |
171 | let mut argty = Vec::new(); |
172 | let mut is_static = true; |
173 | let mut predexprs = Vec::new(); |
174 | let mut predty = Vec::new(); |
175 | let mut refpredty = Vec::new(); |
176 | |
177 | let (mut declosured_generics, declosured_inputs, call_exprs) = |
178 | declosurefy(&self.sig.generics, &self.sig.inputs); |
179 | |
180 | for fa in declosured_inputs.iter() { |
181 | if let FnArg::Typed(pt) = fa { |
182 | let argname = (*pt.pat).clone(); |
183 | if pat_is_self(&argname) { |
184 | // A weird receiver like `Box<Self>` |
185 | is_static = false; |
186 | continue; |
187 | } |
188 | let aty = supersuperfy(&pt.ty, self.levels); |
189 | if let Type::Reference(ref tr) = aty { |
190 | predexprs.push(quote!(#argname)); |
191 | predty.push((*tr.elem).clone()); |
192 | let tr2 = Type::Reference(TypeReference { |
193 | and_token: tr.and_token, |
194 | lifetime: None, |
195 | mutability: None, |
196 | elem: tr.elem.clone() |
197 | }); |
198 | refpredty.push(tr2); |
199 | } else { |
200 | predexprs.push(quote!(argname)); |
201 | predty.push(aty.clone()); |
202 | let tr = TypeReference { |
203 | and_token: Token![&](Span::call_site()), |
204 | lifetime: None, |
205 | mutability: None, |
206 | elem: Box::new(aty.clone()) |
207 | }; |
208 | refpredty.push(Type::Reference(tr)); |
209 | }; |
210 | argnames.push(argname); |
211 | argty.push(aty.clone()); |
212 | } else { |
213 | is_static = false; |
214 | } |
215 | } |
216 | let (output, boxed) = match self.sig.output { |
217 | ReturnType::Default => ( |
218 | Type::Tuple(TypeTuple { |
219 | paren_token: token::Paren::default(), |
220 | elems: Punctuated::new(), |
221 | }), |
222 | false, |
223 | ), |
224 | ReturnType::Type(_, ref ty) => { |
225 | let mut output_ty = supersuperfy(ty, self.levels); |
226 | destrify(&mut output_ty); |
227 | let boxed = dedynify(&mut output_ty); |
228 | (output_ty, boxed) |
229 | } |
230 | }; |
231 | supersuperfy_generics(&mut declosured_generics, self.levels); |
232 | let owned_output = ownify(&output); |
233 | let mut return_ref = false; |
234 | let mut return_refmut = false; |
235 | if let Type::Reference(ref tr) = &output { |
236 | if tr.lifetime.as_ref().map_or(true, |lt| lt.ident != "static" ) |
237 | { |
238 | if tr.mutability.is_none() { |
239 | return_ref = true; |
240 | } else { |
241 | return_refmut = true; |
242 | } |
243 | } |
244 | }; |
245 | if is_static && (return_ref || return_refmut) { |
246 | compile_error(self.sig.span(), |
247 | "Mockall cannot mock static methods that return non-'static references. It's unclear what the return value's lifetime should be." ); |
248 | } |
249 | let struct_generics = self.struct_generics.cloned() |
250 | .unwrap_or_default(); |
251 | let (type_generics, salifetimes, srlifetimes) = split_lifetimes( |
252 | struct_generics.clone(), |
253 | &declosured_inputs, |
254 | &ReturnType::Type(<Token![->]>::default(), |
255 | Box::new(owned_output.clone())) |
256 | ); |
257 | let srltg = lifetimes_to_generics(&srlifetimes); |
258 | let (call_generics, malifetimes, mrlifetimes) = split_lifetimes( |
259 | declosured_generics, |
260 | &declosured_inputs, |
261 | &ReturnType::Type(<Token![->]>::default(), |
262 | Box::new(owned_output.clone())) |
263 | ); |
264 | let mrltg = lifetimes_to_generics(&mrlifetimes); |
265 | let cgenerics = merge_generics(&type_generics, &call_generics); |
266 | let egenerics = merge_generics( |
267 | &merge_generics(&cgenerics, &srltg), |
268 | &mrltg); |
269 | let alifetimes = salifetimes.into_iter() |
270 | .collect::<HashSet<LifetimeDef>>() |
271 | .union(&malifetimes.into_iter().collect::<HashSet<_>>()) |
272 | .cloned() |
273 | .collect(); |
274 | |
275 | let fn_params = egenerics.type_params() |
276 | .map(|tp| tp.ident.clone()) |
277 | .collect(); |
278 | let call_levels = self.call_levels.unwrap_or(self.levels); |
279 | |
280 | MockFunction { |
281 | alifetimes, |
282 | argnames, |
283 | argty, |
284 | attrs: self.attrs.to_vec(), |
285 | call_exprs, |
286 | call_generics, |
287 | call_vis: expectation_visibility(self.vis, call_levels), |
288 | egenerics, |
289 | cgenerics, |
290 | fn_params, |
291 | is_static, |
292 | mod_ident: self.parent.unwrap_or(&Ident::new("FIXME" , Span::call_site())).clone(), |
293 | output, |
294 | owned_output, |
295 | boxed, |
296 | predexprs, |
297 | predty, |
298 | refpredty, |
299 | return_ref, |
300 | return_refmut, |
301 | sig: self.sig.clone(), |
302 | struct_: self.struct_.cloned(), |
303 | struct_generics, |
304 | trait_: self.trait_.cloned(), |
305 | type_generics, |
306 | privmod_vis: expectation_visibility(self.vis, self.levels) |
307 | } |
308 | } |
309 | |
310 | /// How many levels of modules beneath the original function this one is |
311 | /// nested. |
312 | pub fn call_levels(&mut self, levels: usize) -> &mut Self { |
313 | self.call_levels = Some(levels); |
314 | self |
315 | } |
316 | |
317 | /// How many levels of modules beneath the original function this one's |
318 | /// private module is nested. |
319 | pub fn levels(&mut self, levels: usize) -> &mut Self { |
320 | self.levels = levels; |
321 | self |
322 | } |
323 | |
324 | /// # Arguments |
325 | /// |
326 | /// * sig: The signature of the mockable function |
327 | /// * v: The visibility of the mockable function |
328 | pub fn new(sig: &'a Signature, vis: &'a Visibility) -> Self { |
329 | Builder { |
330 | attrs: &[], |
331 | levels: 0, |
332 | call_levels: None, |
333 | parent: None, |
334 | sig, |
335 | struct_: None, |
336 | struct_generics: None, |
337 | trait_: None, |
338 | vis |
339 | } |
340 | } |
341 | |
342 | /// Supply the name of the parent module |
343 | pub fn parent(&mut self, ident: &'a Ident) -> &mut Self { |
344 | self.parent = Some(ident); |
345 | self |
346 | } |
347 | |
348 | /// Supply the name of the parent struct, if any |
349 | pub fn struct_(&mut self, ident: &'a Ident) -> &mut Self { |
350 | self.struct_= Some(ident); |
351 | self |
352 | } |
353 | |
354 | /// Supply the Generics of the parent struct, if any |
355 | pub fn struct_generics(&mut self, generics: &'a Generics) -> &mut Self { |
356 | self.struct_generics = Some(generics); |
357 | self |
358 | } |
359 | |
360 | /// Supply the name of the method's trait, if any |
361 | pub fn trait_(&mut self, ident: &'a Ident) -> &mut Self { |
362 | self.trait_ = Some(ident); |
363 | self |
364 | } |
365 | } |
366 | |
367 | #[derive(Clone)] |
368 | pub(crate) struct MockFunction { |
369 | /// Lifetimes of the mocked method that relate to the arguments but not the |
370 | /// return value |
371 | alifetimes: Punctuated<LifetimeDef, token::Comma>, |
372 | /// Names of the method arguments |
373 | argnames: Vec<Pat>, |
374 | /// Types of the method arguments |
375 | argty: Vec<Type>, |
376 | /// any attributes on the original function, like #[inline] |
377 | pub attrs: Vec<Attribute>, |
378 | /// Expressions that should be used for Expectation::call's arguments |
379 | call_exprs: Vec<TokenStream>, |
380 | /// Generics used for the expectation call |
381 | call_generics: Generics, |
382 | /// Visibility of the mock function itself |
383 | call_vis: Visibility, |
384 | /// Generics of the Expectation object |
385 | egenerics: Generics, |
386 | /// Generics of the Common object |
387 | cgenerics: Generics, |
388 | /// The mock function's generic types as a list of types |
389 | fn_params: Vec<Ident>, |
390 | /// Is this for a static method or free function? |
391 | is_static: bool, |
392 | /// name of the function's parent module |
393 | mod_ident: Ident, |
394 | /// Output type of the Method, supersuperfied. |
395 | output: Type, |
396 | /// Owned version of the output type of the Method, supersuperfied. |
397 | /// |
398 | /// If the real output type is a non-'static reference, then it will differ |
399 | /// from this field. |
400 | owned_output: Type, |
401 | /// True if the `owned_type` is boxed by `Box<>`. |
402 | boxed: bool, |
403 | /// Expressions that create the predicate arguments from the call arguments |
404 | predexprs: Vec<TokenStream>, |
405 | /// Types used for Predicates. Will be almost the same as args, but every |
406 | /// type will be a non-reference type. |
407 | predty: Vec<Type>, |
408 | /// Does the function return a non-'static reference? |
409 | return_ref: bool, |
410 | /// Does the function return a mutable reference? |
411 | return_refmut: bool, |
412 | /// References to every type in `predty`. |
413 | refpredty: Vec<Type>, |
414 | /// The signature of the mockable function |
415 | sig: Signature, |
416 | /// Name of the parent structure, if any |
417 | struct_: Option<Ident>, |
418 | /// Generics of the parent structure |
419 | struct_generics: Generics, |
420 | /// Name of this method's trait, if the method comes from a trait |
421 | trait_: Option<Ident>, |
422 | /// Type generics of the mock structure |
423 | type_generics: Generics, |
424 | /// Visibility of the expectation and its methods |
425 | privmod_vis: Visibility |
426 | } |
427 | |
428 | impl MockFunction { |
429 | /// Return the mock function itself |
430 | /// |
431 | /// # Arguments |
432 | /// |
433 | /// * `modname`: Name of the parent struct's private module |
434 | // Supplying modname is an unfortunately hack. Ideally MockFunction |
435 | // wouldn't need to know that. |
436 | pub fn call(&self, modname: Option<&Ident>) -> impl ToTokens { |
437 | let attrs = AttrFormatter::new(&self.attrs).format(); |
438 | let call_exprs = &self.call_exprs; |
439 | let (_, tg, _) = if self.is_method_generic() || self.is_static() { |
440 | &self.egenerics |
441 | } else { |
442 | &self.call_generics |
443 | }.split_for_impl(); |
444 | let tbf = tg.as_turbofish(); |
445 | let name = self.name(); |
446 | let desc = self.desc(); |
447 | let no_match_msg = quote!(std::format!( |
448 | "{}: No matching expectation found" , #desc)); |
449 | let sig = &self.sig; |
450 | let (vis, dead_code) = if self.trait_.is_some() { |
451 | (&Visibility::Inherited, quote!()) |
452 | } else { |
453 | let dead_code = if let Visibility::Inherited = self.call_vis { |
454 | // This private method may be a helper only used by the struct's |
455 | // other methods, which we are mocking. If so, the mock method |
456 | // will be dead code. But we can't simply eliminate it, because |
457 | // it might also be used by other code in the same module. |
458 | quote!(#[allow(dead_code)]) |
459 | } else { |
460 | quote!() |
461 | }; |
462 | (&self.call_vis, dead_code) |
463 | }; |
464 | let substruct_obj = if let Some(trait_) = &self.trait_ { |
465 | let ident = format_ident!("{}_expectations" , trait_); |
466 | quote!(#ident.) |
467 | } else { |
468 | quote!() |
469 | }; |
470 | let call = if self.return_refmut { |
471 | Ident::new("call_mut" , Span::call_site()) |
472 | } else { |
473 | Ident::new("call" , Span::call_site()) |
474 | }; |
475 | let mut deref = quote!(); |
476 | if self.boxed { |
477 | if self.return_ref { |
478 | deref = quote!(&**); |
479 | } else if self.return_refmut { |
480 | deref = quote!(&mut **); |
481 | } |
482 | } |
483 | if self.is_static { |
484 | let outer_mod_path = self.outer_mod_path(modname); |
485 | quote!( |
486 | // Don't add a doc string. The original is included in #attrs |
487 | #(#attrs)* |
488 | #dead_code |
489 | #vis #sig { |
490 | let no_match_msg = #no_match_msg; |
491 | #deref { |
492 | let __mockall_guard = #outer_mod_path::EXPECTATIONS |
493 | .lock().unwrap(); |
494 | /* |
495 | * TODO: catch panics, then gracefully release the mutex |
496 | * so it won't be poisoned. This requires bounding any |
497 | * generic parameters with UnwindSafe |
498 | */ |
499 | /* std::panic::catch_unwind(|| */ |
500 | __mockall_guard.#call#tbf(#(#call_exprs,)*) |
501 | /*)*/ |
502 | }.expect(&no_match_msg) |
503 | } |
504 | ) |
505 | } else { |
506 | quote!( |
507 | // Don't add a doc string. The original is included in #attrs |
508 | #(#attrs)* |
509 | #dead_code |
510 | #vis #sig { |
511 | let no_match_msg = #no_match_msg; |
512 | #deref self.#substruct_obj #name.#call#tbf(#(#call_exprs,)*) |
513 | .expect(&no_match_msg) |
514 | } |
515 | |
516 | ) |
517 | } |
518 | } |
519 | |
520 | /// Return this method's contribution to its parent's checkpoint method |
521 | pub fn checkpoint(&self) -> impl ToTokens { |
522 | let attrs = AttrFormatter::new(&self.attrs) |
523 | .doc(false) |
524 | .format(); |
525 | let inner_mod_ident = self.inner_mod_ident(); |
526 | if self.is_static { |
527 | quote!( |
528 | #(#attrs)* |
529 | { |
530 | let __mockall_timeses = #inner_mod_ident::EXPECTATIONS.lock() |
531 | .unwrap() |
532 | .checkpoint() |
533 | .collect::<Vec<_>>(); |
534 | } |
535 | ) |
536 | } else { |
537 | let name = &self.name(); |
538 | quote!(#(#attrs)* { self.#name.checkpoint(); }) |
539 | } |
540 | } |
541 | |
542 | /// Return a function that creates a Context object for this function |
543 | /// |
544 | /// # Arguments |
545 | /// |
546 | /// * `modname`: Name of the parent struct's private module |
547 | // Supplying modname is an unfortunately hack. Ideally MockFunction |
548 | // wouldn't need to know that. |
549 | pub fn context_fn(&self, modname: Option<&Ident>) -> impl ToTokens { |
550 | let attrs = AttrFormatter::new(&self.attrs) |
551 | .doc(false) |
552 | .format(); |
553 | let context_docstr = format!("Create a [`Context`]({}{}/struct.Context.html) for mocking the `{}` method" , |
554 | modname.map(|m| format!("{}/" , m)).unwrap_or_default(), |
555 | self.inner_mod_ident(), |
556 | self.name()); |
557 | let context_ident = format_ident!("{}_context" , self.name()); |
558 | let (_, tg, _) = self.type_generics.split_for_impl(); |
559 | let outer_mod_path = self.outer_mod_path(modname); |
560 | let v = &self.call_vis; |
561 | quote!( |
562 | #(#attrs)* |
563 | #[doc = #context_docstr] |
564 | #v fn #context_ident() -> #outer_mod_path::Context #tg |
565 | { |
566 | #outer_mod_path::Context::default() |
567 | } |
568 | ) |
569 | } |
570 | |
571 | /// Generate a code fragment that will print a description of the invocation |
572 | fn desc(&self) -> impl ToTokens { |
573 | let argnames = &self.argnames; |
574 | let name = if let Some(s) = &self.struct_ { |
575 | format!("{}::{}" , s, self.sig.ident) |
576 | } else { |
577 | format!("{}::{}" , self.mod_ident, self.sig.ident) |
578 | }; |
579 | let fields = vec!["{:?}" ; argnames.len()].join(", " ); |
580 | let fstr = format!("{}({})" , name, fields); |
581 | quote!(std::format!(#fstr, #(::mockall::MaybeDebugger(argnames)),*)) |
582 | } |
583 | |
584 | /// Generate code for the expect_ method |
585 | /// |
586 | /// # Arguments |
587 | /// |
588 | /// * `modname`: Name of the parent struct's private module |
589 | /// * `self_args`: If supplied, these are the |
590 | /// AngleBracketedGenericArguments of the self type of the |
591 | /// trait impl. e.g. The `T` in `impl Foo for Bar<T>`. |
592 | // Supplying modname is an unfortunately hack. Ideally MockFunction |
593 | // wouldn't need to know that. |
594 | pub fn expect(&self, modname: &Ident, self_args: Option<&PathArguments>) |
595 | -> impl ToTokens |
596 | { |
597 | let attrs = AttrFormatter::new(&self.attrs) |
598 | .doc(false) |
599 | .format(); |
600 | let name = self.name(); |
601 | let expect_ident = format_ident!("expect_{}" , &name); |
602 | let expectation_obj = self.expectation_obj(self_args); |
603 | let funcname = &self.sig.ident; |
604 | let (_, tg, _) = if self.is_method_generic() { |
605 | &self.egenerics |
606 | } else { |
607 | &self.call_generics |
608 | }.split_for_impl(); |
609 | let (ig, _, wc) = self.call_generics.split_for_impl(); |
610 | let mut wc = wc.cloned(); |
611 | if self.is_method_generic() && (self.return_ref || self.return_refmut) { |
612 | // Add Senc + Sync, required for downcast, since Expectation |
613 | // stores an Option<#owned_output> |
614 | send_syncify(&mut wc, self.owned_output.clone()); |
615 | } |
616 | let tbf = tg.as_turbofish(); |
617 | let vis = &self.call_vis; |
618 | |
619 | #[cfg (not(feature = "nightly_derive" ))] |
620 | let must_use = quote!(#[must_use = |
621 | "Must set return value when not using the \"nightly \" feature" |
622 | ]); |
623 | #[cfg (feature = "nightly_derive" )] |
624 | let must_use = quote!(); |
625 | |
626 | let substruct_obj = if let Some(trait_) = &self.trait_ { |
627 | let ident = format_ident!("{}_expectations" , trait_); |
628 | quote!(#ident.) |
629 | } else { |
630 | quote!() |
631 | }; |
632 | let docstr = format!("Create an [`Expectation`]({}/{}/struct.Expectation.html) for mocking the `{}` method" , |
633 | modname, self.inner_mod_ident(), funcname); |
634 | quote!( |
635 | #must_use |
636 | #[doc = #docstr] |
637 | #(#attrs)* |
638 | #vis fn #expect_ident #ig(&mut self) |
639 | -> &mut #modname::#expectation_obj |
640 | #wc |
641 | { |
642 | self.#substruct_obj #name.expect#tbf() |
643 | } |
644 | ) |
645 | } |
646 | |
647 | /// Return the name of this function's expecation object |
648 | fn expectation_obj(&self, self_args: Option<&PathArguments>) |
649 | -> impl ToTokens |
650 | { |
651 | let inner_mod_ident = self.inner_mod_ident(); |
652 | if let Some(PathArguments::AngleBracketed(abga)) = self_args { |
653 | // staticize any lifetimes that might be present in the Expectation |
654 | // object but not in the self args. These come from the method's |
655 | // return type. |
656 | let mut abga2 = abga.clone(); |
657 | for _ in self.egenerics.lifetimes() { |
658 | let lt = Lifetime::new("'static" , Span::call_site()); |
659 | let la = GenericArgument::Lifetime(lt); |
660 | abga2.args.insert(0, la); |
661 | } |
662 | assert!(!self.is_method_generic(), |
663 | "specific impls with generic methods are TODO" ); |
664 | quote!(#inner_mod_ident::Expectation #abga2) |
665 | } else { |
666 | // staticize any lifetimes. This is necessary for methods that |
667 | // return non-static types, because the Expectation itself must be |
668 | // 'static. |
669 | let segenerics = staticize(&self.egenerics); |
670 | let (_, tg, _) = segenerics.split_for_impl(); |
671 | quote!(#inner_mod_ident::Expectation #tg) |
672 | } |
673 | } |
674 | |
675 | /// Return the name of this function's expecations object |
676 | pub fn expectations_obj(&self) -> impl ToTokens { |
677 | let inner_mod_ident = self.inner_mod_ident(); |
678 | if self.is_method_generic() { |
679 | quote!(#inner_mod_ident::GenericExpectations) |
680 | } else { |
681 | quote!(#inner_mod_ident::Expectations) |
682 | } |
683 | } |
684 | |
685 | pub fn field_definition(&self, modname: Option<&Ident>) -> TokenStream { |
686 | let name = self.name(); |
687 | let attrs = AttrFormatter::new(&self.attrs) |
688 | .doc(false) |
689 | .format(); |
690 | let expectations_obj = &self.expectations_obj(); |
691 | if self.is_method_generic() { |
692 | quote!(#(#attrs)* #name: #modname::#expectations_obj) |
693 | } else { |
694 | // staticize any lifetimes. This is necessary for methods that |
695 | // return non-static types, because the Expectation itself must be |
696 | // 'static. |
697 | let segenerics = staticize(&self.egenerics); |
698 | let (_, tg, _) = segenerics.split_for_impl(); |
699 | quote!(#(#attrs)* #name: #modname::#expectations_obj #tg) |
700 | } |
701 | } |
702 | |
703 | /// Human-readable name of the mock function |
704 | fn funcname(&self) -> String { |
705 | if let Some(si) = &self.struct_ { |
706 | format!("{}::{}" , si, self.name()) |
707 | } else { |
708 | format!("{}" , self.name()) |
709 | } |
710 | } |
711 | |
712 | fn hrtb(&self) -> Option<BoundLifetimes> { |
713 | if self.alifetimes.is_empty() { |
714 | None |
715 | } else { |
716 | Some(BoundLifetimes { |
717 | lifetimes: self.alifetimes.clone(), |
718 | lt_token: <Token![<]>::default(), |
719 | gt_token: <Token![>]>::default(), |
720 | .. Default::default() |
721 | }) |
722 | } |
723 | } |
724 | |
725 | fn is_expectation_generic(&self) -> bool { |
726 | self.egenerics.params.iter().any(|p| { |
727 | matches!(p, GenericParam::Type(_)) |
728 | }) || self.egenerics.where_clause.is_some() |
729 | } |
730 | |
731 | /// Is the mock method generic (as opposed to a non-generic method of a |
732 | /// generic mock struct)? |
733 | pub fn is_method_generic(&self) -> bool { |
734 | self.call_generics.params.iter().any(|p| { |
735 | matches!(p, GenericParam::Type(_)) |
736 | }) || self.call_generics.where_clause.is_some() |
737 | } |
738 | |
739 | fn outer_mod_path(&self, modname: Option<&Ident>) -> Path { |
740 | let mut path = if let Some(m) = modname { |
741 | Path::from(PathSegment::from(m.clone())) |
742 | } else { |
743 | Path { leading_colon: None, segments: Punctuated::new() } |
744 | }; |
745 | path.segments.push(PathSegment::from(self.inner_mod_ident())); |
746 | path |
747 | } |
748 | |
749 | fn inner_mod_ident(&self) -> Ident { |
750 | format_ident!("__{}" , &self.name()) |
751 | } |
752 | |
753 | pub fn is_static(&self) -> bool { |
754 | self.is_static |
755 | } |
756 | |
757 | pub fn name(&self) -> &Ident { |
758 | &self.sig.ident |
759 | } |
760 | |
761 | /// Generate code for this function's private module |
762 | pub fn priv_module(&self) -> impl ToTokens { |
763 | let attrs = AttrFormatter::new(&self.attrs) |
764 | .doc(false) |
765 | .format(); |
766 | let common = &Common{f: self}; |
767 | let context = &Context{f: self}; |
768 | let expectation: Box<dyn ToTokens> = if self.return_ref { |
769 | Box::new(RefExpectation{f: self}) |
770 | } else if self.return_refmut { |
771 | Box::new(RefMutExpectation{f: self}) |
772 | } else { |
773 | Box::new(StaticExpectation{f: self}) |
774 | }; |
775 | let expectations: Box<dyn ToTokens> = if self.return_ref { |
776 | Box::new(RefExpectations{f: self}) |
777 | } else if self.return_refmut { |
778 | Box::new(RefMutExpectations{f: self}) |
779 | } else { |
780 | Box::new(StaticExpectations{f: self}) |
781 | }; |
782 | let generic_expectations = GenericExpectations{f: self}; |
783 | let guard: Box<dyn ToTokens> = if self.is_expectation_generic() { |
784 | Box::new(GenericExpectationGuard{f: self}) |
785 | } else { |
786 | Box::new(ConcreteExpectationGuard{f: self}) |
787 | }; |
788 | let matcher = &Matcher{f: self}; |
789 | let std_mutexguard = if self.is_static { |
790 | quote!(use ::std::sync::MutexGuard;) |
791 | } else { |
792 | quote!() |
793 | }; |
794 | let inner_mod_ident = self.inner_mod_ident(); |
795 | let rfunc: Box<dyn ToTokens> = if self.return_ref { |
796 | Box::new(RefRfunc{f: self}) |
797 | } else if self.return_refmut { |
798 | Box::new(RefMutRfunc{f: self}) |
799 | } else { |
800 | Box::new(StaticRfunc{f: self}) |
801 | }; |
802 | quote!( |
803 | #(#attrs)* |
804 | #[allow(missing_docs)] |
805 | pub mod #inner_mod_ident { |
806 | use super::*; |
807 | use ::mockall::CaseTreeExt; |
808 | #std_mutexguard |
809 | use ::std::{ |
810 | boxed::Box, |
811 | mem, |
812 | ops::{DerefMut, Range}, |
813 | sync::Mutex, |
814 | vec::Vec, |
815 | }; |
816 | #rfunc |
817 | #matcher |
818 | #common |
819 | #expectation |
820 | #expectations |
821 | #generic_expectations |
822 | #guard |
823 | #context |
824 | } |
825 | ) |
826 | } |
827 | } |
828 | |
829 | /// Holds parts of the expectation that are common for all output types |
830 | struct Common<'a> { |
831 | f: &'a MockFunction |
832 | } |
833 | |
834 | impl<'a> ToTokens for Common<'a> { |
835 | fn to_tokens(&self, tokens: &mut TokenStream) { |
836 | let argnames = &self.f.argnames; |
837 | let predty = &self.f.predty; |
838 | let hrtb = self.f.hrtb(); |
839 | let funcname = self.f.funcname(); |
840 | let (ig, tg, wc) = self.f.cgenerics.split_for_impl(); |
841 | let lg = lifetimes_to_generics(&self.f.alifetimes); |
842 | let refpredty = &self.f.refpredty; |
843 | let with_generics_idents = (0..self.f.predty.len()) |
844 | .map(|i| format_ident!("MockallMatcher{}" , i)) |
845 | .collect::<Vec<_>>(); |
846 | let with_generics = with_generics_idents.iter() |
847 | .zip(self.f.predty.iter()) |
848 | .map(|(id, mt)| |
849 | quote!(#id: #hrtb ::mockall::Predicate<#mt> + Send + 'static, ) |
850 | ).collect::<TokenStream>(); |
851 | let with_args = self.f.argnames.iter() |
852 | .zip(with_generics_idents.iter()) |
853 | .map(|(argname, id)| quote!(#argname: #id, )) |
854 | .collect::<TokenStream>(); |
855 | let boxed_withargs = argnames.iter() |
856 | .map(|aa| quote!(Box::new(#aa), )) |
857 | .collect::<TokenStream>(); |
858 | quote!( |
859 | /// Holds the stuff that is independent of the output type |
860 | struct Common #ig #wc { |
861 | matcher: Mutex<Matcher #tg>, |
862 | seq_handle: Option<::mockall::SeqHandle>, |
863 | times: ::mockall::Times |
864 | } |
865 | |
866 | impl #ig std::default::Default for Common #tg #wc |
867 | { |
868 | fn default() -> Self { |
869 | Common { |
870 | matcher: Mutex::new(Matcher::default()), |
871 | seq_handle: None, |
872 | times: ::mockall::Times::default() |
873 | } |
874 | } |
875 | } |
876 | |
877 | impl #ig Common #tg #wc { |
878 | fn call(&self, desc: &str) { |
879 | self.times.call() |
880 | .unwrap_or_else(|m| { |
881 | let desc = std::format!( |
882 | "{}" , self.matcher.lock().unwrap()); |
883 | panic!("{}: Expectation({}) {}" , #funcname, desc, |
884 | m); |
885 | }); |
886 | self.verify_sequence(desc); |
887 | if ::mockall::ExpectedCalls::TooFew != self.times.is_satisfied() { |
888 | self.satisfy_sequence() |
889 | } |
890 | } |
891 | |
892 | fn in_sequence(&mut self, __mockall_seq: &mut ::mockall::Sequence) |
893 | -> &mut Self |
894 | { |
895 | assert!(self.times.is_exact(), |
896 | "Only Expectations with an exact call count have sequences" ); |
897 | self.seq_handle = Some(__mockall_seq.next_handle()); |
898 | self |
899 | } |
900 | |
901 | fn is_done(&self) -> bool { |
902 | self.times.is_done() |
903 | } |
904 | |
905 | #[allow(clippy::ptr_arg)] |
906 | fn matches #lg (&self, #( #argnames: predty, )*) -> bool { |
907 | self.matcher.lock().unwrap().matches(#(#argnames, )*) |
908 | } |
909 | |
910 | /// Forbid this expectation from ever being called. |
911 | fn never(&mut self) { |
912 | self.times.never(); |
913 | } |
914 | |
915 | fn satisfy_sequence(&self) { |
916 | if let Some(__mockall_handle) = &self.seq_handle { |
917 | __mockall_handle.satisfy() |
918 | } |
919 | } |
920 | |
921 | /// Expect this expectation to be called any number of times |
922 | /// contained with the given range. |
923 | fn times<MockallR>(&mut self, __mockall_r: MockallR) |
924 | where MockallR: Into<::mockall::TimesRange> |
925 | { |
926 | self.times.times(__mockall_r) |
927 | } |
928 | |
929 | fn with<#with_generics>(&mut self, #with_args) |
930 | { |
931 | let mut __mockall_guard = self.matcher.lock().unwrap(); |
932 | *__mockall_guard.deref_mut() = |
933 | Matcher::Pred(Box::new((#boxed_withargs))); |
934 | } |
935 | |
936 | fn withf<MockallF>(&mut self, __mockall_f: MockallF) |
937 | where MockallF: #hrtb Fn(#( #refpredty, )*) |
938 | -> bool + Send + 'static |
939 | { |
940 | let mut __mockall_guard = self.matcher.lock().unwrap(); |
941 | *__mockall_guard.deref_mut() = |
942 | Matcher::Func(Box::new(__mockall_f)); |
943 | } |
944 | |
945 | fn withf_st<MockallF>(&mut self, __mockall_f: MockallF) |
946 | where MockallF: #hrtb Fn(#( #refpredty, )*) |
947 | -> bool + 'static |
948 | { |
949 | let mut __mockall_guard = self.matcher.lock().unwrap(); |
950 | *__mockall_guard.deref_mut() = |
951 | Matcher::FuncSt( |
952 | ::mockall::Fragile::new(Box::new(__mockall_f)) |
953 | ); |
954 | } |
955 | |
956 | fn verify_sequence(&self, desc: &str) { |
957 | if let Some(__mockall_handle) = &self.seq_handle { |
958 | __mockall_handle.verify(desc) |
959 | } |
960 | } |
961 | } |
962 | |
963 | impl #ig Drop for Common #tg #wc { |
964 | fn drop(&mut self) { |
965 | if !::std::thread::panicking() { |
966 | let desc = std::format!( |
967 | "{}" , self.matcher.lock().unwrap()); |
968 | match self.times.is_satisfied() { |
969 | ::mockall::ExpectedCalls::TooFew => { |
970 | panic!("{}: Expectation({}) called {} time(s) which is fewer than expected {}" , |
971 | #funcname, |
972 | desc, |
973 | self.times.count(), |
974 | self.times.minimum()); |
975 | }, |
976 | ::mockall::ExpectedCalls::TooMany => { |
977 | panic!("{}: Expectation({}) called {} time(s) which is more than expected {}" , |
978 | #funcname, |
979 | desc, |
980 | self.times.count(), |
981 | self.times.maximum()); |
982 | }, |
983 | _ => () |
984 | } |
985 | } |
986 | } |
987 | } |
988 | ).to_tokens(tokens); |
989 | } |
990 | } |
991 | |
992 | /// Generates methods that are common for all Expectation types |
993 | struct CommonExpectationMethods<'a> { |
994 | f: &'a MockFunction |
995 | } |
996 | |
997 | impl<'a> ToTokens for CommonExpectationMethods<'a> { |
998 | fn to_tokens(&self, tokens: &mut TokenStream) { |
999 | let argnames = &self.f.argnames; |
1000 | let hrtb = self.f.hrtb(); |
1001 | let lg = lifetimes_to_generics(&self.f.alifetimes); |
1002 | let predty = &self.f.predty; |
1003 | let with_generics_idents = (0..self.f.predty.len()) |
1004 | .map(|i| format_ident!("MockallMatcher{}" , i)) |
1005 | .collect::<Vec<_>>(); |
1006 | let with_generics = with_generics_idents.iter() |
1007 | .zip(self.f.predty.iter()) |
1008 | .map(|(id, mt)| |
1009 | quote!(#id: #hrtb ::mockall::Predicate<#mt> + Send + 'static, ) |
1010 | ).collect::<TokenStream>(); |
1011 | let with_args = self.f.argnames.iter() |
1012 | .zip(with_generics_idents.iter()) |
1013 | .map(|(argname, id)| quote!(#argname: #id, )) |
1014 | .collect::<TokenStream>(); |
1015 | let v = &self.f.privmod_vis; |
1016 | quote!( |
1017 | /// Add this expectation to a |
1018 | /// [`Sequence`](../../../mockall/struct.Sequence.html). |
1019 | #v fn in_sequence(&mut self, __mockall_seq: &mut ::mockall::Sequence) |
1020 | -> &mut Self |
1021 | { |
1022 | self.common.in_sequence(__mockall_seq); |
1023 | self |
1024 | } |
1025 | |
1026 | fn is_done(&self) -> bool { |
1027 | self.common.is_done() |
1028 | } |
1029 | |
1030 | /// Validate this expectation's matcher. |
1031 | #[allow(clippy::ptr_arg)] |
1032 | fn matches #lg (&self, #(#argnames: predty, )*) -> bool { |
1033 | self.common.matches(#(#argnames, )*) |
1034 | } |
1035 | |
1036 | /// Forbid this expectation from ever being called. |
1037 | #v fn never(&mut self) -> &mut Self { |
1038 | self.common.never(); |
1039 | self |
1040 | } |
1041 | |
1042 | /// Create a new, default, [`Expectation`](struct.Expectation.html) |
1043 | #v fn new() -> Self { |
1044 | Self::default() |
1045 | } |
1046 | |
1047 | /// Expect this expectation to be called exactly once. Shortcut for |
1048 | /// [`times(1)`](#method.times). |
1049 | #v fn once(&mut self) -> &mut Self { |
1050 | self.times(1) |
1051 | } |
1052 | |
1053 | /// Restrict the number of times that that this method may be called. |
1054 | /// |
1055 | /// The argument may be: |
1056 | /// * A fixed number: `.times(4)` |
1057 | /// * Various types of range: |
1058 | /// - `.times(5..10)` |
1059 | /// - `.times(..10)` |
1060 | /// - `.times(5..)` |
1061 | /// - `.times(5..=10)` |
1062 | /// - `.times(..=10)` |
1063 | /// * The wildcard: `.times(..)` |
1064 | #v fn times<MockallR>(&mut self, __mockall_r: MockallR) -> &mut Self |
1065 | where MockallR: Into<::mockall::TimesRange> |
1066 | { |
1067 | self.common.times(__mockall_r); |
1068 | self |
1069 | } |
1070 | |
1071 | /// Set matching crieteria for this Expectation. |
1072 | /// |
1073 | /// The matching predicate can be anything implemening the |
1074 | /// [`Predicate`](../../../mockall/trait.Predicate.html) trait. Only |
1075 | /// one matcher can be set per `Expectation` at a time. |
1076 | #v fn with<#with_generics>(&mut self, #with_args) -> &mut Self |
1077 | { |
1078 | self.common.with(#(#argnames, )*); |
1079 | self |
1080 | } |
1081 | |
1082 | /// Set a matching function for this Expectation. |
1083 | /// |
1084 | /// This is equivalent to calling [`with`](#method.with) with a |
1085 | /// function argument, like `with(predicate::function(f))`. |
1086 | #v fn withf<MockallF>(&mut self, __mockall_f: MockallF) -> &mut Self |
1087 | where MockallF: #hrtb Fn(#(predty, )*) |
1088 | -> bool + Send + 'static |
1089 | { |
1090 | self.common.withf(__mockall_f); |
1091 | self |
1092 | } |
1093 | |
1094 | /// Single-threaded version of [`withf`](#method.withf). |
1095 | /// Can be used when the argument type isn't `Send`. |
1096 | #v fn withf_st<MockallF>(&mut self, __mockall_f: MockallF) -> &mut Self |
1097 | where MockallF: #hrtb Fn(#(predty, )*) |
1098 | -> bool + 'static |
1099 | { |
1100 | self.common.withf_st(__mockall_f); |
1101 | self |
1102 | } |
1103 | ).to_tokens(tokens); |
1104 | } |
1105 | } |
1106 | |
1107 | /// Holds the moethods of the Expectations object that are common for all |
1108 | /// Expectation types |
1109 | struct CommonExpectationsMethods<'a> { |
1110 | f: &'a MockFunction |
1111 | } |
1112 | |
1113 | impl<'a> ToTokens for CommonExpectationsMethods<'a> { |
1114 | fn to_tokens(&self, tokens: &mut TokenStream) { |
1115 | let (ig, tg, wc) = self.f.egenerics.split_for_impl(); |
1116 | let v = &self.f.privmod_vis; |
1117 | quote!( |
1118 | /// A collection of [`Expectation`](struct.Expectations.html) |
1119 | /// objects. Users will rarely if ever use this struct directly. |
1120 | #[doc(hidden)] |
1121 | #v struct Expectations #ig ( Vec<Expectation #tg>) #wc; |
1122 | |
1123 | impl #ig Expectations #tg #wc { |
1124 | /// Verify that all current expectations are satisfied and clear |
1125 | /// them. |
1126 | #v fn checkpoint(&mut self) -> std::vec::Drain<Expectation #tg> |
1127 | { |
1128 | self.0.drain(..) |
1129 | } |
1130 | |
1131 | /// Create a new expectation for this method. |
1132 | #v fn expect(&mut self) -> &mut Expectation #tg |
1133 | { |
1134 | self.0.push(Expectation::default()); |
1135 | let __mockall_l = self.0.len(); |
1136 | &mut self.0[__mockall_l - 1] |
1137 | } |
1138 | |
1139 | #v fn new() -> Self { |
1140 | Self::default() |
1141 | } |
1142 | } |
1143 | impl #ig Default for Expectations #tg #wc |
1144 | { |
1145 | fn default() -> Self { |
1146 | Expectations(Vec::new()) |
1147 | } |
1148 | } |
1149 | ).to_tokens(tokens); |
1150 | } |
1151 | } |
1152 | |
1153 | /// The ExpectationGuard structure for static methods with no generic types |
1154 | struct ExpectationGuardCommonMethods<'a> { |
1155 | f: &'a MockFunction |
1156 | } |
1157 | |
1158 | impl<'a> ToTokens for ExpectationGuardCommonMethods<'a> { |
1159 | fn to_tokens(&self, tokens: &mut TokenStream) { |
1160 | if !self.f.is_static { |
1161 | return; |
1162 | } |
1163 | |
1164 | let argnames = &self.f.argnames; |
1165 | let argty = &self.f.argty; |
1166 | let (_, tg, _) = self.f.egenerics.split_for_impl(); |
1167 | let keyid = gen_keyid(&self.f.egenerics); |
1168 | let expectations = if self.f.is_expectation_generic() { |
1169 | quote!(self.guard |
1170 | .store |
1171 | .get_mut(&::mockall::Key::new::#keyid()) |
1172 | .unwrap() |
1173 | .downcast_mut::<Expectations #tg>() |
1174 | .unwrap()) |
1175 | } else { |
1176 | quote!(self.guard) |
1177 | }; |
1178 | let hrtb = self.f.hrtb(); |
1179 | let output = &self.f.output; |
1180 | let predty = &self.f.predty; |
1181 | let with_generics_idents = (0..self.f.predty.len()) |
1182 | .map(|i| format_ident!("MockallMatcher{}" , i)) |
1183 | .collect::<Vec<_>>(); |
1184 | let with_generics = with_generics_idents.iter() |
1185 | .zip(self.f.predty.iter()) |
1186 | .map(|(id, mt)| |
1187 | quote!(#id: #hrtb ::mockall::Predicate<#mt> + Send + 'static, ) |
1188 | ).collect::<TokenStream>(); |
1189 | let with_args = self.f.argnames.iter() |
1190 | .zip(with_generics_idents.iter()) |
1191 | .map(|(argname, id)| quote!(#argname: #id, )) |
1192 | .collect::<TokenStream>(); |
1193 | let v = &self.f.privmod_vis; |
1194 | quote!( |
1195 | /// Just like |
1196 | /// [`Expectation::in_sequence`](struct.Expectation.html#method.in_sequence) |
1197 | #v fn in_sequence(&mut self, |
1198 | __mockall_seq: &mut ::mockall::Sequence) |
1199 | -> &mut Expectation #tg |
1200 | { |
1201 | #expectations.0[self.i].in_sequence(__mockall_seq) |
1202 | } |
1203 | |
1204 | /// Just like |
1205 | /// [`Expectation::never`](struct.Expectation.html#method.never) |
1206 | #v fn never(&mut self) -> &mut Expectation #tg { |
1207 | #expectations.0[self.i].never() |
1208 | } |
1209 | |
1210 | /// Just like |
1211 | /// [`Expectation::once`](struct.Expectation.html#method.once) |
1212 | #v fn once(&mut self) -> &mut Expectation #tg { |
1213 | #expectations.0[self.i].once() |
1214 | } |
1215 | |
1216 | /// Just like |
1217 | /// [`Expectation::return_const`](struct.Expectation.html#method.return_const) |
1218 | #v fn return_const<MockallOutput> |
1219 | (&mut self, __mockall_c: MockallOutput) |
1220 | -> &mut Expectation #tg |
1221 | where MockallOutput: Clone + Into<#output> + Send + 'static |
1222 | { |
1223 | #expectations.0[self.i].return_const(__mockall_c) |
1224 | } |
1225 | |
1226 | /// Just like |
1227 | /// [`Expectation::return_const_st`](struct.Expectation.html#method.return_const_st) |
1228 | #v fn return_const_st<MockallOutput> |
1229 | (&mut self, __mockall_c: MockallOutput) |
1230 | -> &mut Expectation #tg |
1231 | where MockallOutput: Clone + Into<#output> + 'static |
1232 | { |
1233 | #expectations.0[self.i].return_const_st(__mockall_c) |
1234 | } |
1235 | |
1236 | /// Just like |
1237 | /// [`Expectation::returning`](struct.Expectation.html#method.returning) |
1238 | #v fn returning<MockallF>(&mut self, __mockall_f: MockallF) |
1239 | -> &mut Expectation #tg |
1240 | where MockallF: #hrtb FnMut(#(#argty, )*) |
1241 | -> #output + Send + 'static |
1242 | { |
1243 | #expectations.0[self.i].returning(__mockall_f) |
1244 | } |
1245 | |
1246 | /// Just like |
1247 | /// [`Expectation::return_once`](struct.Expectation.html#method.return_once) |
1248 | #v fn return_once<MockallF>(&mut self, __mockall_f: MockallF) |
1249 | -> &mut Expectation #tg |
1250 | where MockallF: #hrtb FnOnce(#(#argty, )*) |
1251 | -> #output + Send + 'static |
1252 | { |
1253 | #expectations.0[self.i].return_once(__mockall_f) |
1254 | } |
1255 | |
1256 | /// Just like |
1257 | /// [`Expectation::return_once_st`](struct.Expectation.html#method.return_once_st) |
1258 | #v fn return_once_st<MockallF>(&mut self, __mockall_f: MockallF) |
1259 | -> &mut Expectation #tg |
1260 | where MockallF: #hrtb FnOnce(#(#argty, )*) |
1261 | -> #output + 'static |
1262 | { |
1263 | #expectations.0[self.i].return_once_st(__mockall_f) |
1264 | } |
1265 | |
1266 | |
1267 | /// Just like |
1268 | /// [`Expectation::returning_st`](struct.Expectation.html#method.returning_st) |
1269 | #v fn returning_st<MockallF>(&mut self, __mockall_f: MockallF) |
1270 | -> &mut Expectation #tg |
1271 | where MockallF: #hrtb FnMut(#(#argty, )*) |
1272 | -> #output + 'static |
1273 | { |
1274 | #expectations.0[self.i].returning_st(__mockall_f) |
1275 | } |
1276 | |
1277 | /// Just like |
1278 | /// [`Expectation::times`](struct.Expectation.html#method.times) |
1279 | #v fn times<MockallR>(&mut self, __mockall_r: MockallR) |
1280 | -> &mut Expectation #tg |
1281 | where MockallR: Into<::mockall::TimesRange> |
1282 | { |
1283 | #expectations.0[self.i].times(__mockall_r) |
1284 | } |
1285 | |
1286 | /// Just like |
1287 | /// [`Expectation::with`](struct.Expectation.html#method.with) |
1288 | #v fn with<#with_generics> (&mut self, #with_args) |
1289 | -> &mut Expectation #tg |
1290 | { |
1291 | #expectations.0[self.i].with(#(#argnames, )*) |
1292 | } |
1293 | |
1294 | /// Just like |
1295 | /// [`Expectation::withf`](struct.Expectation.html#method.withf) |
1296 | #v fn withf<MockallF>(&mut self, __mockall_f: MockallF) |
1297 | -> &mut Expectation #tg |
1298 | where MockallF: #hrtb Fn(#(predty, )*) |
1299 | -> bool + Send + 'static |
1300 | { |
1301 | #expectations.0[self.i].withf(__mockall_f) |
1302 | } |
1303 | |
1304 | /// Just like |
1305 | /// [`Expectation::withf_st`](struct.Expectation.html#method.withf_st) |
1306 | #v fn withf_st<MockallF>(&mut self, __mockall_f: MockallF) |
1307 | -> &mut Expectation #tg |
1308 | where MockallF: #hrtb Fn(#(predty, )*) |
1309 | -> bool + 'static |
1310 | { |
1311 | #expectations.0[self.i].withf_st(__mockall_f) |
1312 | } |
1313 | ).to_tokens(tokens); |
1314 | } |
1315 | } |
1316 | |
1317 | /// The ExpectationGuard structure for static methods with no generic types |
1318 | struct ConcreteExpectationGuard<'a> { |
1319 | f: &'a MockFunction |
1320 | } |
1321 | |
1322 | impl<'a> ToTokens for ConcreteExpectationGuard<'a> { |
1323 | fn to_tokens(&self, tokens: &mut TokenStream) { |
1324 | if !self.f.is_static { |
1325 | return; |
1326 | } |
1327 | |
1328 | let common_methods = ExpectationGuardCommonMethods{f: self.f}; |
1329 | let (_, tg, _) = self.f.egenerics.split_for_impl(); |
1330 | let ltdef = LifetimeDef::new( |
1331 | Lifetime::new("'__mockall_lt" , Span::call_site()) |
1332 | ); |
1333 | let mut e_generics = self.f.egenerics.clone(); |
1334 | e_generics.lt_token.get_or_insert(<Token![<]>::default()); |
1335 | e_generics.params.push(GenericParam::Lifetime(ltdef)); |
1336 | e_generics.gt_token.get_or_insert(<Token![>]>::default()); |
1337 | let (e_ig, e_tg, e_wc) = e_generics.split_for_impl(); |
1338 | let (ei_ig, _, _) = e_generics.split_for_impl(); |
1339 | let v = &self.f.privmod_vis; |
1340 | quote!( |
1341 | ::mockall::lazy_static! { |
1342 | #[doc(hidden)] |
1343 | #v static ref EXPECTATIONS: |
1344 | ::std::sync::Mutex<Expectations #tg> = |
1345 | ::std::sync::Mutex::new(Expectations::new()); |
1346 | } |
1347 | /// Like an [`&Expectation`](struct.Expectation.html) but |
1348 | /// protected by a Mutex guard. Useful for mocking static |
1349 | /// methods. Forwards accesses to an `Expectation` object. |
1350 | // We must return the MutexGuard to the caller so he can |
1351 | // configure the expectation. But we can't bundle both the |
1352 | // guard and the &Expectation into the same structure; the |
1353 | // borrow checker won't let us. Instead we'll record the |
1354 | // expectation's position within the Expectations vector so we |
1355 | // can proxy its methods. |
1356 | // |
1357 | // ExpectationGuard is only defined for expectations that return |
1358 | // 'static return types. |
1359 | #v struct ExpectationGuard #e_ig #e_wc { |
1360 | guard: MutexGuard<'__mockall_lt, Expectations #tg>, |
1361 | i: usize |
1362 | } |
1363 | |
1364 | #[allow(clippy::unused_unit)] |
1365 | impl #ei_ig ExpectationGuard #e_tg #e_wc |
1366 | { |
1367 | // Should only be called from the mockall_derive generated |
1368 | // code |
1369 | #[doc(hidden)] |
1370 | #v fn new(mut __mockall_guard: MutexGuard<'__mockall_lt, Expectations #tg>) |
1371 | -> Self |
1372 | { |
1373 | __mockall_guard.expect(); // Drop the &Expectation |
1374 | let __mockall_i = __mockall_guard.0.len() - 1; |
1375 | ExpectationGuard{guard: __mockall_guard, i: __mockall_i} |
1376 | } |
1377 | |
1378 | #common_methods |
1379 | } |
1380 | ).to_tokens(tokens); |
1381 | } |
1382 | } |
1383 | |
1384 | /// The ExpectationGuard structure for static methods with generic types |
1385 | struct GenericExpectationGuard<'a> { |
1386 | f: &'a MockFunction |
1387 | } |
1388 | |
1389 | impl<'a> ToTokens for GenericExpectationGuard<'a> { |
1390 | fn to_tokens(&self, tokens: &mut TokenStream) { |
1391 | if !self.f.is_static { |
1392 | return; |
1393 | } |
1394 | |
1395 | let common_methods = ExpectationGuardCommonMethods{f: self.f}; |
1396 | let (_, tg, _) = self.f.egenerics.split_for_impl(); |
1397 | let keyid = gen_keyid(&self.f.egenerics); |
1398 | let ltdef = LifetimeDef::new( |
1399 | Lifetime::new("'__mockall_lt" , Span::call_site()) |
1400 | ); |
1401 | let mut egenerics = self.f.egenerics.clone(); |
1402 | egenerics.lt_token.get_or_insert(<Token![<]>::default()); |
1403 | egenerics.params.push(GenericParam::Lifetime(ltdef)); |
1404 | egenerics.gt_token.get_or_insert(<Token![>]>::default()); |
1405 | let (e_ig, e_tg, e_wc) = egenerics.split_for_impl(); |
1406 | let fn_params = &self.f.fn_params; |
1407 | let tbf = tg.as_turbofish(); |
1408 | let v = &self.f.privmod_vis; |
1409 | quote!( |
1410 | ::mockall::lazy_static! { |
1411 | #v static ref EXPECTATIONS: |
1412 | ::std::sync::Mutex<GenericExpectations> = |
1413 | ::std::sync::Mutex::new(GenericExpectations::new()); |
1414 | } |
1415 | /// Like an [`&Expectation`](struct.Expectation.html) but |
1416 | /// protected by a Mutex guard. Useful for mocking static |
1417 | /// methods. Forwards accesses to an `Expectation` object. |
1418 | #v struct ExpectationGuard #e_ig #e_wc{ |
1419 | guard: MutexGuard<'__mockall_lt, GenericExpectations>, |
1420 | i: usize, |
1421 | _phantom: ::std::marker::PhantomData<(#(#fn_params,)*)>, |
1422 | } |
1423 | |
1424 | #[allow(clippy::unused_unit)] |
1425 | impl #e_ig ExpectationGuard #e_tg #e_wc |
1426 | { |
1427 | // Should only be called from the mockall_derive generated |
1428 | // code |
1429 | #[doc(hidden)] |
1430 | #v fn new(mut __mockall_guard: MutexGuard<'__mockall_lt, GenericExpectations>) |
1431 | -> Self |
1432 | { |
1433 | let __mockall_ee: &mut Expectations #tg = |
1434 | __mockall_guard.store.entry( |
1435 | ::mockall::Key::new::#keyid() |
1436 | ).or_insert_with(|| |
1437 | Box::new(Expectations #tbf ::new())) |
1438 | .downcast_mut() |
1439 | .unwrap(); |
1440 | __mockall_ee.expect(); // Drop the &Expectation |
1441 | let __mockall_i = __mockall_ee.0.len() - 1; |
1442 | ExpectationGuard{guard: __mockall_guard, i: __mockall_i, |
1443 | _phantom: ::std::marker::PhantomData} |
1444 | } |
1445 | |
1446 | #common_methods |
1447 | } |
1448 | ).to_tokens(tokens); |
1449 | } |
1450 | } |
1451 | |
1452 | /// Generates Context, which manages the context for expectations of static |
1453 | /// methods. |
1454 | struct Context<'a> { |
1455 | f: &'a MockFunction |
1456 | } |
1457 | |
1458 | impl<'a> ToTokens for Context<'a> { |
1459 | fn to_tokens(&self, tokens: &mut TokenStream) { |
1460 | if !self.f.is_static { |
1461 | return; |
1462 | } |
1463 | |
1464 | let ltdef = LifetimeDef::new( |
1465 | Lifetime::new("'__mockall_lt" , Span::call_site()) |
1466 | ); |
1467 | let mut egenerics = self.f.egenerics.clone(); |
1468 | egenerics.lt_token.get_or_insert(<Token![<]>::default()); |
1469 | egenerics.params.push(GenericParam::Lifetime(ltdef)); |
1470 | egenerics.gt_token.get_or_insert(<Token![>]>::default()); |
1471 | let (_, e_tg, _) = egenerics.split_for_impl(); |
1472 | let (ty_ig, ty_tg, ty_wc) = self.f.type_generics.split_for_impl(); |
1473 | let mut meth_generics = self.f.call_generics.clone(); |
1474 | let ltdef = LifetimeDef::new( |
1475 | Lifetime::new("'__mockall_lt" , Span::call_site()) |
1476 | ); |
1477 | meth_generics.params.push(GenericParam::Lifetime(ltdef)); |
1478 | let (meth_ig, _meth_tg, meth_wc) = meth_generics.split_for_impl(); |
1479 | let ctx_fn_params = self.f.struct_generics.type_params() |
1480 | .map(|tp| tp.ident.clone()) |
1481 | .collect::<Punctuated::<Ident, Token![,]>>(); |
1482 | let v = &self.f.privmod_vis; |
1483 | |
1484 | #[cfg (not(feature = "nightly_derive" ))] |
1485 | let must_use = quote!(#[must_use = |
1486 | "Must set return value when not using the \"nightly \" feature" |
1487 | ]); |
1488 | #[cfg (feature = "nightly_derive" )] |
1489 | let must_use = quote!(); |
1490 | |
1491 | quote!( |
1492 | /// Manages the context for expectations of static methods. |
1493 | /// |
1494 | /// Expectations on this method will be validated and cleared when |
1495 | /// the `Context` object drops. The `Context` object does *not* |
1496 | /// provide any form of synchronization, so multiple tests that set |
1497 | /// expectations on the same static method must provide their own. |
1498 | #[must_use = "Context only serves to create expectations" ] |
1499 | #v struct Context #ty_ig #ty_wc { |
1500 | // Prevent "unused type parameter" errors |
1501 | // Surprisingly, PhantomData<Fn(generics)> is Send even if |
1502 | // generics are not, unlike PhantomData<generics> |
1503 | _phantom: ::std::marker::PhantomData< |
1504 | Box<dyn Fn(#ctx_fn_params) + Send> |
1505 | > |
1506 | } |
1507 | impl #ty_ig Context #ty_tg #ty_wc { |
1508 | /// Verify that all current expectations for this method are |
1509 | /// satisfied and clear them. |
1510 | #v fn checkpoint(&self) { |
1511 | Self::do_checkpoint() |
1512 | } |
1513 | #[doc(hidden)] |
1514 | #v fn do_checkpoint() { |
1515 | let __mockall_timeses = EXPECTATIONS |
1516 | .lock() |
1517 | .unwrap() |
1518 | .checkpoint() |
1519 | .collect::<Vec<_>>(); |
1520 | } |
1521 | |
1522 | /// Create a new expectation for this method. |
1523 | #must_use |
1524 | #v fn expect #meth_ig ( &self,) -> ExpectationGuard #e_tg |
1525 | #meth_wc |
1526 | { |
1527 | ExpectationGuard::new(EXPECTATIONS.lock().unwrap()) |
1528 | } |
1529 | } |
1530 | impl #ty_ig Default for Context #ty_tg #ty_wc { |
1531 | fn default() -> Self { |
1532 | Context {_phantom: std::marker::PhantomData} |
1533 | } |
1534 | } |
1535 | impl #ty_ig Drop for Context #ty_tg #ty_wc { |
1536 | fn drop(&mut self) { |
1537 | Self::do_checkpoint() |
1538 | } |
1539 | } |
1540 | ).to_tokens(tokens); |
1541 | } |
1542 | } |
1543 | |
1544 | struct Matcher<'a> { |
1545 | f: &'a MockFunction |
1546 | } |
1547 | |
1548 | impl<'a> ToTokens for Matcher<'a> { |
1549 | fn to_tokens(&self, tokens: &mut TokenStream) { |
1550 | let (ig, tg, wc) = self.f.cgenerics.split_for_impl(); |
1551 | let argnames = &self.f.argnames; |
1552 | let braces = argnames.iter() |
1553 | .fold(String::new(), |mut acc, _argname| { |
1554 | if acc.is_empty() { |
1555 | acc.push_str("{}" ); |
1556 | } else { |
1557 | acc.push_str(", {}" ); |
1558 | } |
1559 | acc |
1560 | }); |
1561 | let fn_params = &self.f.fn_params; |
1562 | let hrtb = self.f.hrtb(); |
1563 | let indices = (0..argnames.len()) |
1564 | .map(|i| { |
1565 | syn::Index::from(i) |
1566 | }).collect::<Vec<_>>(); |
1567 | let lg = lifetimes_to_generics(&self.f.alifetimes); |
1568 | let pred_matches = argnames.iter().enumerate() |
1569 | .map(|(i, argname)| { |
1570 | let idx = syn::Index::from(i); |
1571 | quote!(__mockall_pred.#idx.eval(#argname),) |
1572 | }).collect::<TokenStream>(); |
1573 | let preds = self.f.predty.iter() |
1574 | .map(|t| quote!(Box<dyn #hrtb ::mockall::Predicate<#t> + Send>,)) |
1575 | .collect::<TokenStream>(); |
1576 | let predty = &self.f.predty; |
1577 | let refpredty = &self.f.refpredty; |
1578 | quote!( |
1579 | enum Matcher #ig #wc { |
1580 | Always, |
1581 | Func(Box<dyn #hrtb Fn(#( #refpredty, )*) -> bool + Send>), |
1582 | // Version of Matcher::Func for closures that aren't Send |
1583 | FuncSt(::mockall::Fragile<Box<dyn #hrtb Fn(#( #refpredty, )*) -> bool>>), |
1584 | Pred(Box<(#preds)>), |
1585 | // Prevent "unused type parameter" errors |
1586 | // Surprisingly, PhantomData<Fn(generics)> is Send even if |
1587 | // generics are not, unlike PhantomData<generics> |
1588 | _Phantom(Box<dyn Fn(#(#fn_params,)*) + Send>) |
1589 | } |
1590 | impl #ig Matcher #tg #wc { |
1591 | #[allow(clippy::ptr_arg)] |
1592 | fn matches #lg (&self, #( #argnames: predty, )*) -> bool { |
1593 | match self { |
1594 | Matcher::Always => true, |
1595 | Matcher::Func(__mockall_f) => |
1596 | __mockall_f(#(#argnames, )*), |
1597 | Matcher::FuncSt(__mockall_f) => |
1598 | (__mockall_f.get())(#(#argnames, )*), |
1599 | Matcher::Pred(__mockall_pred) => |
1600 | [#pred_matches] |
1601 | .iter() |
1602 | .all(|__mockall_x| *__mockall_x), |
1603 | _ => unreachable!() |
1604 | } |
1605 | } |
1606 | } |
1607 | |
1608 | impl #ig Default for Matcher #tg #wc { |
1609 | #[allow(unused_variables)] |
1610 | fn default() -> Self { |
1611 | Matcher::Always |
1612 | } |
1613 | } |
1614 | |
1615 | impl #ig ::std::fmt::Display for Matcher #tg #wc { |
1616 | fn fmt(&self, __mockall_fmt: &mut ::std::fmt::Formatter<'_>) |
1617 | -> ::std::fmt::Result |
1618 | { |
1619 | match self { |
1620 | Matcher::Always => write!(__mockall_fmt, "<anything>" ), |
1621 | Matcher::Func(_) => write!(__mockall_fmt, "<function>" ), |
1622 | Matcher::FuncSt(_) => write!(__mockall_fmt, "<single threaded function>" ), |
1623 | Matcher::Pred(__mockall_p) => { |
1624 | write!(__mockall_fmt, #braces, |
1625 | #(__mockall_p.#indices,)*) |
1626 | } |
1627 | _ => unreachable!(), |
1628 | } |
1629 | } |
1630 | } |
1631 | ).to_tokens(tokens); |
1632 | } |
1633 | } |
1634 | |
1635 | struct RefRfunc<'a> { |
1636 | f: &'a MockFunction |
1637 | } |
1638 | |
1639 | impl<'a> ToTokens for RefRfunc<'a> { |
1640 | fn to_tokens(&self, tokens: &mut TokenStream) { |
1641 | let fn_params = &self.f.fn_params; |
1642 | let (ig, tg, wc) = self.f.egenerics.split_for_impl(); |
1643 | let lg = lifetimes_to_generics(&self.f.alifetimes); |
1644 | let owned_output = &self.f.owned_output; |
1645 | |
1646 | #[cfg (not(feature = "nightly_derive" ))] |
1647 | let default_err_msg = |
1648 | "Returning default values requires the \"nightly \" feature" ; |
1649 | #[cfg (feature = "nightly_derive" )] |
1650 | let default_err_msg = |
1651 | "Can only return default values for types that impl std::Default" ; |
1652 | |
1653 | quote!( |
1654 | enum Rfunc #ig #wc { |
1655 | Default(Option<#owned_output>), |
1656 | Const(#owned_output), |
1657 | // Prevent "unused type parameter" errors Surprisingly, |
1658 | // PhantomData<Fn(generics)> is Send even if generics are not, |
1659 | // unlike PhantomData<generics> |
1660 | _Phantom(Mutex<Box<dyn Fn(#(#fn_params,)*) + Send>>) |
1661 | } |
1662 | |
1663 | impl #ig Rfunc #tg #wc { |
1664 | fn call #lg (&self) |
1665 | -> std::result::Result<owned_output, &'static str> |
1666 | { |
1667 | match self { |
1668 | Rfunc::Default(Some(ref __mockall_o)) => { |
1669 | ::std::result::Result::Ok(__mockall_o) |
1670 | }, |
1671 | Rfunc::Default(None) => { |
1672 | Err(#default_err_msg) |
1673 | }, |
1674 | Rfunc::Const(ref __mockall_o) => { |
1675 | ::std::result::Result::Ok(__mockall_o) |
1676 | }, |
1677 | Rfunc::_Phantom(_) => unreachable!() |
1678 | } |
1679 | } |
1680 | } |
1681 | |
1682 | impl #ig std::default::Default for Rfunc #tg #wc |
1683 | { |
1684 | fn default() -> Self { |
1685 | use ::mockall::ReturnDefault; |
1686 | Rfunc::Default(::mockall::DefaultReturner::<#owned_output> |
1687 | ::maybe_return_default()) |
1688 | } |
1689 | } |
1690 | ).to_tokens(tokens); |
1691 | } |
1692 | } |
1693 | |
1694 | struct RefMutRfunc<'a> { |
1695 | f: &'a MockFunction |
1696 | } |
1697 | |
1698 | impl<'a> ToTokens for RefMutRfunc<'a> { |
1699 | fn to_tokens(&self, tokens: &mut TokenStream) { |
1700 | let argnames = &self.f.argnames; |
1701 | let argty = &self.f.argty; |
1702 | let fn_params = &self.f.fn_params; |
1703 | let (ig, tg, wc) = self.f.egenerics.split_for_impl(); |
1704 | let lg = lifetimes_to_generics(&self.f.alifetimes); |
1705 | let owned_output = &self.f.owned_output; |
1706 | let output = &self.f.output; |
1707 | |
1708 | #[cfg (not(feature = "nightly_derive" ))] |
1709 | let default_err_msg = |
1710 | "Returning default values requires the \"nightly \" feature" ; |
1711 | #[cfg (feature = "nightly_derive" )] |
1712 | let default_err_msg = |
1713 | "Can only return default values for types that impl std::Default" ; |
1714 | |
1715 | quote!( |
1716 | #[allow(clippy::unused_unit)] |
1717 | enum Rfunc #ig #wc { |
1718 | Default(Option<#owned_output>), |
1719 | Mut((Box<dyn FnMut(#(#argty, )*) -> #owned_output + Send + Sync>), |
1720 | Option<#owned_output>), |
1721 | // Version of Rfunc::Mut for closures that aren't Send |
1722 | MutSt((::mockall::Fragile< |
1723 | Box<dyn FnMut(#(#argty, )*) -> #owned_output >> |
1724 | ), Option<#owned_output> |
1725 | ), |
1726 | Var(#owned_output), |
1727 | // Prevent "unused type parameter" errors Surprisingly, |
1728 | // PhantomData<Fn(generics)> is Send even if generics are not, |
1729 | // unlike PhantomData<generics> |
1730 | _Phantom(Mutex<Box<dyn Fn(#(#fn_params,)*) + Send>>) |
1731 | } |
1732 | |
1733 | impl #ig Rfunc #tg #wc { |
1734 | fn call_mut #lg (&mut self, #(#argnames: #argty, )*) |
1735 | -> std::result::Result<#output, &'static str> |
1736 | { |
1737 | match self { |
1738 | Rfunc::Default(Some(ref mut __mockall_o)) => { |
1739 | ::std::result::Result::Ok(__mockall_o) |
1740 | }, |
1741 | Rfunc::Default(None) => { |
1742 | Err(#default_err_msg) |
1743 | }, |
1744 | Rfunc::Mut(ref mut __mockall_f, ref mut __mockall_o) => |
1745 | { |
1746 | *__mockall_o = Some(__mockall_f(#(#argnames, )*)); |
1747 | if let Some(ref mut __mockall_o2) = __mockall_o { |
1748 | ::std::result::Result::Ok(__mockall_o2) |
1749 | } else { |
1750 | unreachable!() |
1751 | } |
1752 | }, |
1753 | Rfunc::MutSt(ref mut __mockall_f, ref mut __mockall_o)=> |
1754 | { |
1755 | *__mockall_o = Some((__mockall_f.get_mut())( |
1756 | #(#argnames, )*) |
1757 | ); |
1758 | if let Some(ref mut __mockall_o2) = __mockall_o { |
1759 | ::std::result::Result::Ok(__mockall_o2) |
1760 | } else { |
1761 | unreachable!() |
1762 | } |
1763 | }, |
1764 | Rfunc::Var(ref mut __mockall_o) => { |
1765 | ::std::result::Result::Ok(__mockall_o) |
1766 | }, |
1767 | Rfunc::_Phantom(_) => unreachable!() |
1768 | } |
1769 | } |
1770 | } |
1771 | |
1772 | impl #ig std::default::Default for Rfunc #tg #wc |
1773 | { |
1774 | fn default() -> Self { |
1775 | use ::mockall::ReturnDefault; |
1776 | Rfunc::Default(::mockall::DefaultReturner::<#owned_output> |
1777 | ::maybe_return_default()) |
1778 | } |
1779 | } |
1780 | ).to_tokens(tokens); |
1781 | } |
1782 | } |
1783 | |
1784 | struct StaticRfunc<'a> { |
1785 | f: &'a MockFunction |
1786 | } |
1787 | |
1788 | impl<'a> ToTokens for StaticRfunc<'a> { |
1789 | fn to_tokens(&self, tokens: &mut TokenStream) { |
1790 | let argnames = &self.f.argnames; |
1791 | let argty = &self.f.argty; |
1792 | let fn_params = &self.f.fn_params; |
1793 | let (ig, tg, wc) = self.f.egenerics.split_for_impl(); |
1794 | let hrtb = self.f.hrtb(); |
1795 | let lg = lifetimes_to_generics(&self.f.alifetimes); |
1796 | let output = &self.f.output; |
1797 | quote!( |
1798 | #[allow(clippy::unused_unit)] |
1799 | enum Rfunc #ig #wc { |
1800 | Default, |
1801 | // Indicates that a `return_once` expectation has already |
1802 | // returned |
1803 | Expired, |
1804 | Mut(Box<dyn #hrtb FnMut(#(#argty, )*) -> #output + Send>), |
1805 | // Version of Rfunc::Mut for closures that aren't Send |
1806 | MutSt(::mockall::Fragile< |
1807 | Box<dyn #hrtb FnMut(#(#argty, )*) -> #output >> |
1808 | ), |
1809 | Once(Box<dyn #hrtb FnOnce(#(#argty, )*) -> #output + Send>), |
1810 | // Version of Rfunc::Once for closure that aren't Send |
1811 | OnceSt(::mockall::Fragile< |
1812 | Box<dyn #hrtb FnOnce(#(#argty, )*) -> #output>> |
1813 | ), |
1814 | // Prevent "unused type parameter" errors Surprisingly, |
1815 | // PhantomData<Fn(generics)> is Send even if generics are not, |
1816 | // unlike PhantomData<generics> |
1817 | _Phantom(Box<dyn Fn(#(#fn_params,)*) + Send>) |
1818 | } |
1819 | |
1820 | impl #ig Rfunc #tg #wc { |
1821 | fn call_mut #lg (&mut self, #( #argnames: #argty, )* ) |
1822 | -> std::result::Result<#output, &'static str> |
1823 | { |
1824 | match self { |
1825 | Rfunc::Default => { |
1826 | use ::mockall::ReturnDefault; |
1827 | ::mockall::DefaultReturner::<#output> |
1828 | ::return_default() |
1829 | }, |
1830 | Rfunc::Expired => { |
1831 | Err("called twice, but it returns by move" ) |
1832 | }, |
1833 | Rfunc::Mut(__mockall_f) => { |
1834 | ::std::result::Result::Ok(__mockall_f( #(#argnames, )* )) |
1835 | }, |
1836 | Rfunc::MutSt(__mockall_f) => { |
1837 | ::std::result::Result::Ok((__mockall_f.get_mut())(#(#argnames,)*)) |
1838 | }, |
1839 | Rfunc::Once(_) => { |
1840 | if let Rfunc::Once(mut __mockall_f) = |
1841 | mem::replace(self, Rfunc::Expired) { |
1842 | ::std::result::Result::Ok(__mockall_f( #(#argnames, )* )) |
1843 | } else { |
1844 | unreachable!() |
1845 | } |
1846 | }, |
1847 | Rfunc::OnceSt(_) => { |
1848 | if let Rfunc::OnceSt(mut __mockall_f) = |
1849 | mem::replace(self, Rfunc::Expired) { |
1850 | ::std::result::Result::Ok((__mockall_f.into_inner())(#(#argnames,)*)) |
1851 | } else { |
1852 | unreachable!() |
1853 | } |
1854 | }, |
1855 | Rfunc::_Phantom(_) => unreachable!() |
1856 | } |
1857 | } |
1858 | } |
1859 | |
1860 | impl #ig std::default::Default for Rfunc #tg #wc |
1861 | { |
1862 | fn default() -> Self { |
1863 | Rfunc::Default |
1864 | } |
1865 | } |
1866 | ).to_tokens(tokens); |
1867 | } |
1868 | } |
1869 | |
1870 | /// An expectation type for functions that take a &self and return a reference |
1871 | struct RefExpectation<'a> { |
1872 | f: &'a MockFunction |
1873 | } |
1874 | |
1875 | impl<'a> ToTokens for RefExpectation<'a> { |
1876 | fn to_tokens(&self, tokens: &mut TokenStream) { |
1877 | let argnames = &self.f.argnames; |
1878 | let argty = &self.f.argty; |
1879 | let common_methods = CommonExpectationMethods{f: self.f}; |
1880 | let desc = self.f.desc(); |
1881 | let funcname = self.f.funcname(); |
1882 | let (ig, tg, wc) = self.f.egenerics.split_for_impl(); |
1883 | |
1884 | let (_, common_tg, _) = self.f.cgenerics.split_for_impl(); |
1885 | let lg = lifetimes_to_generics(&self.f.alifetimes); |
1886 | let output = &self.f.output; |
1887 | let owned_output = &self.f.owned_output; |
1888 | let v = &self.f.privmod_vis; |
1889 | quote!( |
1890 | /// Expectation type for methods taking a `&self` argument and |
1891 | /// returning immutable references. This is the type returned by |
1892 | /// the `expect_*` methods. |
1893 | #v struct Expectation #ig #wc { |
1894 | common: Common #common_tg, |
1895 | rfunc: Rfunc #tg, |
1896 | } |
1897 | |
1898 | #[allow(clippy::unused_unit)] |
1899 | impl #ig Expectation #tg #wc { |
1900 | /// Call this [`Expectation`] as if it were the real method. |
1901 | #v fn call #lg (&self, #(#argnames: #argty, )*) -> #output |
1902 | { |
1903 | self.common.call(desc); |
1904 | self.rfunc.call().unwrap_or_else(|m| { |
1905 | let desc = std::format!( |
1906 | "{}" , self.common.matcher.lock().unwrap()); |
1907 | panic!("{}: Expectation({}) {}" , #funcname, desc, |
1908 | m); |
1909 | }) |
1910 | } |
1911 | |
1912 | /// Return a reference to a constant value from the `Expectation` |
1913 | #v fn return_const(&mut self, __mockall_o: #owned_output) |
1914 | -> &mut Self |
1915 | { |
1916 | self.rfunc = Rfunc::Const(__mockall_o); |
1917 | self |
1918 | } |
1919 | |
1920 | #common_methods |
1921 | } |
1922 | impl #ig Default for Expectation #tg #wc |
1923 | { |
1924 | fn default() -> Self { |
1925 | Expectation { |
1926 | common: Common::default(), |
1927 | rfunc: Rfunc::default() |
1928 | } |
1929 | } |
1930 | } |
1931 | ).to_tokens(tokens); |
1932 | } |
1933 | } |
1934 | |
1935 | /// For methods that take &mut self and return a reference |
1936 | struct RefMutExpectation<'a> { |
1937 | f: &'a MockFunction |
1938 | } |
1939 | |
1940 | impl<'a> ToTokens for RefMutExpectation<'a> { |
1941 | fn to_tokens(&self, tokens: &mut TokenStream) { |
1942 | let common_methods = CommonExpectationMethods{f: self.f}; |
1943 | let argnames = &self.f.argnames; |
1944 | let argty = &self.f.argty; |
1945 | let desc = self.f.desc(); |
1946 | let funcname = self.f.funcname(); |
1947 | let (ig, tg, wc) = self.f.egenerics.split_for_impl(); |
1948 | let (_, common_tg, _) = self.f.cgenerics.split_for_impl(); |
1949 | let lg = lifetimes_to_generics(&self.f.alifetimes); |
1950 | let owned_output = &self.f.owned_output; |
1951 | let v = &self.f.privmod_vis; |
1952 | quote!( |
1953 | /// Expectation type for methods taking a `&mut self` argument and |
1954 | /// returning references. This is the type returned by the |
1955 | /// `expect_*` methods. |
1956 | #v struct Expectation #ig #wc { |
1957 | common: Common #common_tg, |
1958 | rfunc: Rfunc #tg |
1959 | } |
1960 | |
1961 | #[allow(clippy::unused_unit)] |
1962 | impl #ig Expectation #tg #wc { |
1963 | /// Simulating calling the real method for this expectation |
1964 | #v fn call_mut #lg (&mut self, #(#argnames: #argty, )*) |
1965 | -> &mut #owned_output |
1966 | { |
1967 | self.common.call(desc); |
1968 | let desc = std::format!( |
1969 | "{}" , self.common.matcher.lock().unwrap()); |
1970 | self.rfunc.call_mut(#(#argnames, )*).unwrap_or_else(|m| { |
1971 | panic!("{}: Expectation({}) {}" , #funcname, desc, |
1972 | m); |
1973 | }) |
1974 | } |
1975 | |
1976 | /// Convenience method that can be used to supply a return value |
1977 | /// for a `Expectation`. The value will be returned by mutable |
1978 | /// reference. |
1979 | #v fn return_var(&mut self, __mockall_o: #owned_output) -> &mut Self |
1980 | { |
1981 | self.rfunc = Rfunc::Var(__mockall_o); |
1982 | self |
1983 | } |
1984 | |
1985 | /// Supply a closure that the `Expectation` will use to create its |
1986 | /// return value. The return value will be returned by mutable |
1987 | /// reference. |
1988 | #v fn returning<MockallF>(&mut self, __mockall_f: MockallF) |
1989 | -> &mut Self |
1990 | where MockallF: FnMut(#(#argty, )*) -> #owned_output + Send + Sync + 'static |
1991 | { |
1992 | self.rfunc = Rfunc::Mut(Box::new(__mockall_f), None); |
1993 | self |
1994 | } |
1995 | |
1996 | /// Single-threaded version of [`returning`](#method.returning). |
1997 | /// Can be used when the argument or return type isn't `Send`. |
1998 | #v fn returning_st<MockallF>(&mut self, __mockall_f: MockallF) |
1999 | -> &mut Self |
2000 | where MockallF: FnMut(#(#argty, )*) -> #owned_output + 'static |
2001 | { |
2002 | self.rfunc = Rfunc::MutSt( |
2003 | ::mockall::Fragile::new(Box::new(__mockall_f)), None); |
2004 | self |
2005 | } |
2006 | |
2007 | #common_methods |
2008 | } |
2009 | impl #ig Default for Expectation #tg #wc |
2010 | { |
2011 | fn default() -> Self { |
2012 | Expectation { |
2013 | common: Common::default(), |
2014 | rfunc: Rfunc::default() |
2015 | } |
2016 | } |
2017 | } |
2018 | ).to_tokens(tokens); |
2019 | } |
2020 | } |
2021 | |
2022 | /// An expectation type for functions return a `'static` value |
2023 | struct StaticExpectation<'a> { |
2024 | f: &'a MockFunction |
2025 | } |
2026 | |
2027 | impl<'a> ToTokens for StaticExpectation<'a> { |
2028 | fn to_tokens(&self, tokens: &mut TokenStream) { |
2029 | let common_methods = CommonExpectationMethods{f: self.f}; |
2030 | let argnames = &self.f.argnames; |
2031 | let argty = &self.f.argty; |
2032 | let desc = self.f.desc(); |
2033 | let hrtb = self.f.hrtb(); |
2034 | let funcname = self.f.funcname(); |
2035 | let (ig, tg, wc) = self.f.egenerics.split_for_impl(); |
2036 | let (_, common_tg, _) = self.f.cgenerics.split_for_impl(); |
2037 | let lg = lifetimes_to_generics(&self.f.alifetimes); |
2038 | let output = &self.f.output; |
2039 | let v = &self.f.privmod_vis; |
2040 | |
2041 | quote!( |
2042 | /// Expectation type for methods that return a `'static` type. |
2043 | /// This is the type returned by the `expect_*` methods. |
2044 | #v struct Expectation #ig #wc { |
2045 | common: Common #common_tg, |
2046 | rfunc: Mutex<Rfunc #tg>, |
2047 | } |
2048 | |
2049 | #[allow(clippy::unused_unit)] |
2050 | impl #ig Expectation #tg #wc { |
2051 | /// Call this [`Expectation`] as if it were the real method. |
2052 | #[doc(hidden)] |
2053 | #v fn call #lg (&self, #(#argnames: #argty, )* ) -> #output |
2054 | { |
2055 | self.common.call(desc); |
2056 | self.rfunc.lock().unwrap().call_mut(#(#argnames, )*) |
2057 | .unwrap_or_else(|message| { |
2058 | let desc = std::format!( |
2059 | "{}" , self.common.matcher.lock().unwrap()); |
2060 | panic!("{}: Expectation({}) {}" , #funcname, desc, |
2061 | message); |
2062 | }) |
2063 | } |
2064 | |
2065 | /// Return a constant value from the `Expectation` |
2066 | /// |
2067 | /// The output type must be `Clone`. The compiler can't always |
2068 | /// infer the proper type to use with this method; you will |
2069 | /// usually need to specify it explicitly. i.e. |
2070 | /// `return_const(42i32)` instead of `return_const(42)`. |
2071 | // We must use Into<#output> instead of #output because where |
2072 | // clauses don't accept equality constraints. |
2073 | // https://github.com/rust-lang/rust/issues/20041 |
2074 | #[allow(unused_variables)] |
2075 | #v fn return_const<MockallOutput>(&mut self, |
2076 | __mockall_c: MockallOutput) |
2077 | -> &mut Self |
2078 | where MockallOutput: Clone + Into<#output> + Send + 'static |
2079 | { |
2080 | self.returning(move |#(#argnames, )*| __mockall_c.clone().into()) |
2081 | } |
2082 | |
2083 | /// Single-threaded version of |
2084 | /// [`return_const`](#method.return_const). This is useful for |
2085 | /// return types that are not `Send`. |
2086 | /// |
2087 | /// The output type must be `Clone`. The compiler can't always |
2088 | /// infer the proper type to use with this method; you will |
2089 | /// usually need to specify it explicitly. i.e. |
2090 | /// `return_const(42i32)` instead of `return_const(42)`. |
2091 | /// |
2092 | /// It is a runtime error to call the mock method from a |
2093 | /// different thread than the one that originally called this |
2094 | /// method. |
2095 | // We must use Into<#output> instead of #output because where |
2096 | // clauses don't accept equality constraints. |
2097 | // https://github.com/rust-lang/rust/issues/20041 |
2098 | #[allow(unused_variables)] |
2099 | #v fn return_const_st<MockallOutput>(&mut self, |
2100 | __mockall_c: MockallOutput) |
2101 | -> &mut Self |
2102 | where MockallOutput: Clone + Into<#output> + 'static |
2103 | { |
2104 | self.returning_st(move |#(#argnames, )*| __mockall_c.clone().into()) |
2105 | } |
2106 | |
2107 | /// Supply an `FnOnce` closure that will provide the return |
2108 | /// value for this Expectation. This is useful for return types |
2109 | /// that aren't `Clone`. It will be an error to call this |
2110 | /// method multiple times. |
2111 | #v fn return_once<MockallF>(&mut self, __mockall_f: MockallF) |
2112 | -> &mut Self |
2113 | where MockallF: #hrtb FnOnce(#(#argty, )*) |
2114 | -> #output + Send + 'static |
2115 | { |
2116 | { |
2117 | let mut __mockall_guard = self.rfunc.lock().unwrap(); |
2118 | *__mockall_guard.deref_mut() = |
2119 | Rfunc::Once(Box::new(__mockall_f)); |
2120 | } |
2121 | self |
2122 | } |
2123 | |
2124 | /// Single-threaded version of |
2125 | /// [`return_once`](#method.return_once). This is useful for |
2126 | /// return types that are neither `Send` nor `Clone`. |
2127 | /// |
2128 | /// It is a runtime error to call the mock method from a |
2129 | /// different thread than the one that originally called this |
2130 | /// method. It is also a runtime error to call the method more |
2131 | /// than once. |
2132 | #v fn return_once_st<MockallF>(&mut self, __mockall_f: |
2133 | MockallF) -> &mut Self |
2134 | where MockallF: #hrtb FnOnce(#(#argty, )*) |
2135 | -> #output + 'static |
2136 | { |
2137 | { |
2138 | let mut __mockall_guard = self.rfunc.lock().unwrap(); |
2139 | *__mockall_guard.deref_mut() = Rfunc::OnceSt( |
2140 | ::mockall::Fragile::new(Box::new(__mockall_f))); |
2141 | } |
2142 | self |
2143 | } |
2144 | |
2145 | /// Supply a closure that will provide the return value for this |
2146 | /// `Expectation`. The method's arguments are passed to the |
2147 | /// closure by value. |
2148 | #v fn returning<MockallF>(&mut self, __mockall_f: MockallF) |
2149 | -> &mut Self |
2150 | where MockallF: #hrtb FnMut(#(#argty, )*) |
2151 | -> #output + Send + 'static |
2152 | { |
2153 | { |
2154 | let mut __mockall_guard = self.rfunc.lock().unwrap(); |
2155 | *__mockall_guard.deref_mut() = |
2156 | Rfunc::Mut(Box::new(__mockall_f)); |
2157 | } |
2158 | self |
2159 | } |
2160 | |
2161 | /// Single-threaded version of [`returning`](#method.returning). |
2162 | /// Can be used when the argument or return type isn't `Send`. |
2163 | /// |
2164 | /// It is a runtime error to call the mock method from a |
2165 | /// different thread than the one that originally called this |
2166 | /// method. |
2167 | #v fn returning_st<MockallF>(&mut self, __mockall_f: MockallF) |
2168 | -> &mut Self |
2169 | where MockallF: #hrtb FnMut(#(#argty, )*) |
2170 | -> #output + 'static |
2171 | { |
2172 | { |
2173 | let mut __mockall_guard = self.rfunc.lock().unwrap(); |
2174 | *__mockall_guard.deref_mut() = Rfunc::MutSt( |
2175 | ::mockall::Fragile::new(Box::new(__mockall_f))); |
2176 | } |
2177 | self |
2178 | } |
2179 | |
2180 | #common_methods |
2181 | } |
2182 | impl #ig Default for Expectation #tg #wc |
2183 | { |
2184 | fn default() -> Self { |
2185 | Expectation { |
2186 | common: Common::default(), |
2187 | rfunc: Mutex::new(Rfunc::default()) |
2188 | } |
2189 | } |
2190 | } |
2191 | ).to_tokens(tokens); |
2192 | } |
2193 | } |
2194 | |
2195 | /// An collection of RefExpectation's |
2196 | struct RefExpectations<'a> { |
2197 | f: &'a MockFunction |
2198 | } |
2199 | |
2200 | impl<'a> ToTokens for RefExpectations<'a> { |
2201 | fn to_tokens(&self, tokens: &mut TokenStream) { |
2202 | let common_methods = CommonExpectationsMethods{f: self.f}; |
2203 | let argnames = &self.f.argnames; |
2204 | let argty = &self.f.argty; |
2205 | let (ig, tg, wc) = self.f.egenerics.split_for_impl(); |
2206 | let lg = lifetimes_to_generics(&self.f.alifetimes); |
2207 | let output = &self.f.output; |
2208 | let predexprs = &self.f.predexprs; |
2209 | let v = &self.f.privmod_vis; |
2210 | quote!( |
2211 | #common_methods |
2212 | impl #ig Expectations #tg #wc { |
2213 | /// Simulate calling the real method. Every current expectation |
2214 | /// will be checked in FIFO order and the first one with |
2215 | /// matching arguments will be used. |
2216 | #v fn call #lg (&self, #(#argnames: #argty, )* ) |
2217 | -> Option<#output> |
2218 | { |
2219 | self.0.iter() |
2220 | .find(|__mockall_e| |
2221 | __mockall_e.matches(#(#predexprs, )*) && |
2222 | (!__mockall_e.is_done() || self.0.len() == 1)) |
2223 | .map(move |__mockall_e| |
2224 | __mockall_e.call(#(#argnames),*) |
2225 | ) |
2226 | } |
2227 | |
2228 | } |
2229 | ).to_tokens(tokens); |
2230 | } |
2231 | } |
2232 | |
2233 | /// An collection of RefMutExpectation's |
2234 | struct RefMutExpectations<'a> { |
2235 | f: &'a MockFunction |
2236 | } |
2237 | |
2238 | impl<'a> ToTokens for RefMutExpectations<'a> { |
2239 | fn to_tokens(&self, tokens: &mut TokenStream) { |
2240 | let common_methods = CommonExpectationsMethods{f: self.f}; |
2241 | let argnames = &self.f.argnames; |
2242 | let argty = &self.f.argty; |
2243 | let (ig, tg, wc) = self.f.egenerics.split_for_impl(); |
2244 | let lg = lifetimes_to_generics(&self.f.alifetimes); |
2245 | let output = &self.f.output; |
2246 | let predexprs = &self.f.predexprs; |
2247 | let v = &self.f.privmod_vis; |
2248 | quote!( |
2249 | #common_methods |
2250 | impl #ig Expectations #tg #wc { |
2251 | /// Simulate calling the real method. Every current expectation |
2252 | /// will be checked in FIFO order and the first one with |
2253 | /// matching arguments will be used. |
2254 | #v fn call_mut #lg (&mut self, #(#argnames: #argty, )* ) |
2255 | -> Option<#output> |
2256 | { |
2257 | let __mockall_n = self.0.len(); |
2258 | self.0.iter_mut() |
2259 | .find(|__mockall_e| |
2260 | __mockall_e.matches(#(#predexprs, )*) && |
2261 | (!__mockall_e.is_done() || __mockall_n == 1)) |
2262 | .map(move |__mockall_e| |
2263 | __mockall_e.call_mut(#(#argnames, )*) |
2264 | ) |
2265 | } |
2266 | |
2267 | } |
2268 | ).to_tokens(tokens); |
2269 | } |
2270 | } |
2271 | |
2272 | /// An collection of Expectation's for methods returning static values |
2273 | struct StaticExpectations<'a> { |
2274 | f: &'a MockFunction |
2275 | } |
2276 | |
2277 | impl<'a> ToTokens for StaticExpectations<'a> { |
2278 | fn to_tokens(&self, tokens: &mut TokenStream) { |
2279 | let common_methods = CommonExpectationsMethods{f: self.f}; |
2280 | let argnames = &self.f.argnames; |
2281 | let argty = &self.f.argty; |
2282 | let (ig, tg, wc) = self.f.egenerics.split_for_impl(); |
2283 | let lg = lifetimes_to_generics(&self.f.alifetimes); |
2284 | let output = &self.f.output; |
2285 | let predexprs = &self.f.predexprs; |
2286 | let v = &self.f.privmod_vis; |
2287 | quote!( |
2288 | #common_methods |
2289 | impl #ig Expectations #tg #wc { |
2290 | /// Simulate calling the real method. Every current expectation |
2291 | /// will be checked in FIFO order and the first one with |
2292 | /// matching arguments will be used. |
2293 | #v fn call #lg (&self, #(#argnames: #argty, )* ) |
2294 | -> Option<#output> |
2295 | { |
2296 | self.0.iter() |
2297 | .find(|__mockall_e| |
2298 | __mockall_e.matches(#(#predexprs, )*) && |
2299 | (!__mockall_e.is_done() || self.0.len() == 1)) |
2300 | .map(move |__mockall_e| |
2301 | __mockall_e.call(#(#argnames, )*) |
2302 | ) |
2303 | } |
2304 | |
2305 | } |
2306 | ).to_tokens(tokens); |
2307 | } |
2308 | } |
2309 | |
2310 | struct GenericExpectations<'a> { |
2311 | f: &'a MockFunction |
2312 | } |
2313 | |
2314 | impl<'a> ToTokens for GenericExpectations<'a> { |
2315 | fn to_tokens(&self, tokens: &mut TokenStream) { |
2316 | if ! self.f.is_expectation_generic() { |
2317 | return; |
2318 | } |
2319 | if ! self.f.is_static() && ! self.f.is_method_generic() { |
2320 | return; |
2321 | } |
2322 | |
2323 | let ge = StaticGenericExpectations{f: self.f}; |
2324 | let v = &self.f.privmod_vis; |
2325 | quote!( |
2326 | /// A collection of [`Expectation`](struct.Expectations.html) |
2327 | /// objects for a generic method. Users will rarely if ever use |
2328 | /// this struct directly. |
2329 | #[doc(hidden)] |
2330 | #[derive(Default)] |
2331 | #v struct GenericExpectations{ |
2332 | store: std::collections::hash_map::HashMap<::mockall::Key, |
2333 | Box<dyn ::mockall::AnyExpectations>> |
2334 | } |
2335 | impl GenericExpectations { |
2336 | /// Verify that all current expectations are satisfied and clear |
2337 | /// them. This applies to all sets of generic parameters! |
2338 | #v fn checkpoint(&mut self) -> |
2339 | std::collections::hash_map::Drain<::mockall::Key, |
2340 | Box<dyn ::mockall::AnyExpectations>> |
2341 | { |
2342 | self.store.drain() |
2343 | } |
2344 | |
2345 | #v fn new() -> Self { |
2346 | Self::default() |
2347 | } |
2348 | } |
2349 | #ge |
2350 | ).to_tokens(tokens); |
2351 | } |
2352 | } |
2353 | |
2354 | /// Generates methods for GenericExpectations for methods returning static |
2355 | /// values |
2356 | struct StaticGenericExpectations<'a> { |
2357 | f: &'a MockFunction |
2358 | } |
2359 | |
2360 | impl<'a> ToTokens for StaticGenericExpectations<'a> { |
2361 | fn to_tokens(&self, tokens: &mut TokenStream) { |
2362 | let argnames = &self.f.argnames; |
2363 | let argty = &self.f.argty; |
2364 | let (ig, tg, wc) = self.f.egenerics.split_for_impl(); |
2365 | let keyid = gen_keyid(&self.f.egenerics); |
2366 | let mut any_wc = wc.cloned(); |
2367 | if self.f.return_ref || self.f.return_refmut { |
2368 | // Add Senc + Sync, required for downcast, since Expectation |
2369 | // stores an Option<#owned_output> |
2370 | send_syncify(&mut any_wc, self.f.owned_output.clone()); |
2371 | } |
2372 | let tbf = tg.as_turbofish(); |
2373 | let output = &self.f.output; |
2374 | let v = &self.f.privmod_vis; |
2375 | let (call, get, self_, downcast) = if self.f.return_refmut { |
2376 | (format_ident!("call_mut" ), |
2377 | format_ident!("get_mut" ), |
2378 | quote!(&mut self), |
2379 | format_ident!("downcast_mut" )) |
2380 | } else { |
2381 | (format_ident!("call" ), |
2382 | format_ident!("get" ), |
2383 | quote!(&self), |
2384 | format_ident!("downcast_ref" )) |
2385 | }; |
2386 | quote!( |
2387 | impl #ig ::mockall::AnyExpectations for Expectations #tg #any_wc {} |
2388 | impl GenericExpectations { |
2389 | /// Simulating calling the real method. |
2390 | #v fn #call #ig (#self_, #(#argnames: #argty, )* ) |
2391 | -> Option<#output> #wc |
2392 | { |
2393 | self.store.#get(&::mockall::Key::new::#keyid()) |
2394 | .map(|__mockall_e| { |
2395 | __mockall_e.#downcast::<Expectations #tg>() |
2396 | .unwrap() |
2397 | .#call(#(#argnames, )*) |
2398 | }).flatten() |
2399 | } |
2400 | |
2401 | /// Create a new Expectation. |
2402 | #v fn expect #ig (&mut self) -> &mut Expectation #tg #any_wc |
2403 | { |
2404 | self.store.entry(::mockall::Key::new::#keyid()) |
2405 | .or_insert_with(|| Box::new(Expectations #tbf::new())) |
2406 | .downcast_mut::<Expectations #tg>() |
2407 | .unwrap() |
2408 | .expect() |
2409 | } |
2410 | } |
2411 | ).to_tokens(tokens) |
2412 | } |
2413 | } |
2414 | |
2415 | |