1 use racer_testutils::*;
2 
3 #[test]
try_operator()4 fn try_operator() {
5     let src = "
6         pub struct Foo(u16);
7 
8         #[derive(Debug, Clone, PartialEq, Eq)]
9         pub struct OddError;
10 
11         fn be_even(val: Foo) -> Result<Foo, OddError> {
12             if val.0 % 2 == 1 {
13                 Err(OddError)
14             } else {
15                 Ok(val)
16             }
17         }
18 
19         pub fn half(val: Foo) -> Result<Foo, OddError> {
20             Ok(Foo(be_even(val)?.~0 / 2))
21         }
22     ";
23 
24     let got = get_definition(src, None);
25     assert_eq!("0", got.matchstr);
26 }
27 
28 #[test]
try_operator_struct()29 fn try_operator_struct() {
30     let src = "
31     struct Foo {
32         pub bar: String,
33         pub baz: bool,
34     }
35 
36     struct LongError;
37 
38     fn validate(s: String) -> Result<Foo, LongError> {
39         if s.chars().count() < 10 {
40             Ok(Foo { bar: s, baz: true })
41         } else {
42             Err(())
43         }
44     }
45 
46     fn process(s: String) -> Result<bool, LongError> {
47         Ok(validate(s)?.b~az)
48     }
49     ";
50 
51     let got = get_all_completions(src, None);
52     assert_eq!(2, got.len());
53     assert_eq!("bar", got[0].matchstr);
54     assert_eq!("baz", got[1].matchstr);
55 }
56 
57 #[test]
let_then_try_with_struct()58 fn let_then_try_with_struct() {
59     let src = "
60     struct Foo {
61         pub bar: String,
62         pub baz: bool,
63     }
64 
65     struct LongError;
66 
67     fn validate(s: String) -> Result<Foo, LongError> {
68         if s.chars().count() < 10 {
69             Ok(Foo { bar: s, baz: true })
70         } else {
71             Err(())
72         }
73     }
74 
75     fn process(s: String) -> Result<bool, LongError> {
76         let foo = validate(s);
77         Ok(foo?.b~az)
78     }
79     ";
80 
81     let got = get_all_completions(src, None);
82     assert_eq!(2, got.len());
83     assert_eq!("bar", got[0].matchstr);
84     assert_eq!("baz", got[1].matchstr);
85 }
86 
87 #[test]
let_try()88 fn let_try() {
89     let src = "
90     pub struct Foo(u16);
91 
92     #[derive(Debug, Clone, PartialEq, Eq)]
93     pub struct OddError;
94 
95     fn be_even(val: Foo) -> Result<Foo, OddError> {
96         if val.0 % 2 == 1 {
97             Err(OddError)
98         } else {
99             Ok(val)
100         }
101     }
102 
103     pub fn half(val: Foo) -> Result<Foo, OddError> {
104         let foo = be_even(val)?;
105         Ok(Foo(foo.~0 / 2))
106     }
107     ";
108 
109     let got = get_definition(src, None);
110     assert_eq!("0", got.matchstr);
111 }
112 
113 #[test]
let_try_socket()114 fn let_try_socket() {
115     let src = r#"
116     use std::net::UdpSocket;
117     use std::io;
118     fn main() -> io::Result<()> {
119         let sock = UdpSocket::bind("127.0.0.1:1234")?;
120         sock.multicast_~
121     }
122 "#;
123     let got = get_all_completions(src, None);
124     assert!(got.into_iter().any(|ma| ma.matchstr == "multicast_loop_v6"));
125 }
126 
127 #[test]
let_try_option()128 fn let_try_option() {
129     let src = r#"
130     fn f() -> Option<String> {
131         Some(String::new())
132     }
133     fn f2() -> Option<()> {
134         let s = f()?;
135         s.as_mut_v~
136     }
137 "#;
138     let got = get_only_completion(src, None);
139     assert_eq!(got.matchstr, "as_mut_vec");
140 }
141 
142 #[test]
try_option()143 fn try_option() {
144     let src = r#"
145     fn f() -> Option<String> {
146         Some(String::new())
147     }
148     fn f2() -> Option<()> {
149         f()?.as_mut_v~
150     }
151 "#;
152     let got = get_only_completion(src, None);
153     assert_eq!(got.matchstr, "as_mut_vec");
154 }
155