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