cpp.rs

  1#[cfg(test)]
  2mod tests {
  3    use gpui::{AppContext as _, BorrowAppContext, TestAppContext};
  4    use language::{AutoindentMode, Buffer};
  5    use settings::SettingsStore;
  6    use std::num::NonZeroU32;
  7    use unindent::Unindent;
  8
  9    #[gpui::test]
 10    async fn test_cpp_autoindent_basic(cx: &mut TestAppContext) {
 11        cx.update(|cx| {
 12            let test_settings = SettingsStore::test(cx);
 13            cx.set_global(test_settings);
 14            cx.update_global::<SettingsStore, _>(|store, cx| {
 15                store.update_user_settings(cx, |s| {
 16                    s.project.all_languages.defaults.tab_size = NonZeroU32::new(2);
 17                });
 18            });
 19        });
 20        let language = crate::language("cpp", tree_sitter_cpp::LANGUAGE.into());
 21
 22        cx.new(|cx| {
 23            let mut buffer = Buffer::local("", cx).with_language_immediate(language, cx);
 24
 25            buffer.edit([(0..0, "int main() {}")], None, cx);
 26
 27            let ix = buffer.len() - 1;
 28            buffer.edit([(ix..ix, "\n\n")], Some(AutoindentMode::EachLine), cx);
 29            assert_eq!(
 30                buffer.text(),
 31                "int main() {\n  \n}",
 32                "content inside braces should be indented"
 33            );
 34
 35            buffer
 36        });
 37    }
 38
 39    #[gpui::test]
 40    async fn test_cpp_autoindent_if_else(cx: &mut TestAppContext) {
 41        cx.update(|cx| {
 42            let test_settings = SettingsStore::test(cx);
 43            cx.set_global(test_settings);
 44            cx.update_global::<SettingsStore, _>(|store, cx| {
 45                store.update_user_settings(cx, |s| {
 46                    s.project.all_languages.defaults.tab_size = NonZeroU32::new(2);
 47                });
 48            });
 49        });
 50        let language = crate::language("cpp", tree_sitter_cpp::LANGUAGE.into());
 51
 52        cx.new(|cx| {
 53            let mut buffer = Buffer::local("", cx).with_language_immediate(language, cx);
 54
 55            buffer.edit(
 56                [(
 57                    0..0,
 58                    r#"
 59                    int main() {
 60                    if (a)
 61                    b;
 62                    }
 63                    "#
 64                    .unindent(),
 65                )],
 66                Some(AutoindentMode::EachLine),
 67                cx,
 68            );
 69            assert_eq!(
 70                buffer.text(),
 71                r#"
 72                int main() {
 73                  if (a)
 74                    b;
 75                }
 76                "#
 77                .unindent(),
 78                "body of if-statement without braces should be indented"
 79            );
 80
 81            let ix = buffer.len() - 4;
 82            buffer.edit([(ix..ix, "\n.c")], Some(AutoindentMode::EachLine), cx);
 83            assert_eq!(
 84                buffer.text(),
 85                r#"
 86                int main() {
 87                  if (a)
 88                    b
 89                      .c;
 90                }
 91                "#
 92                .unindent(),
 93                "field expression (.c) should be indented further than the statement body"
 94            );
 95
 96            buffer.edit([(0..buffer.len(), "")], Some(AutoindentMode::EachLine), cx);
 97            buffer.edit(
 98                [(
 99                    0..0,
100                    r#"
101                    int main() {
102                    if (a) a++;
103                    else b++;
104                    }
105                    "#
106                    .unindent(),
107                )],
108                Some(AutoindentMode::EachLine),
109                cx,
110            );
111            assert_eq!(
112                buffer.text(),
113                r#"
114                int main() {
115                  if (a) a++;
116                  else b++;
117                }
118                "#
119                .unindent(),
120                "single-line if/else without braces should align at the same level"
121            );
122
123            buffer.edit([(0..buffer.len(), "")], Some(AutoindentMode::EachLine), cx);
124            buffer.edit(
125                [(
126                    0..0,
127                    r#"
128                    int main() {
129                    if (a)
130                    b++;
131                    else
132                    c++;
133                    }
134                    "#
135                    .unindent(),
136                )],
137                Some(AutoindentMode::EachLine),
138                cx,
139            );
140            assert_eq!(
141                buffer.text(),
142                r#"
143                int main() {
144                  if (a)
145                    b++;
146                  else
147                    c++;
148                }
149                "#
150                .unindent(),
151                "multi-line if/else without braces should indent statement bodies"
152            );
153
154            buffer.edit([(0..buffer.len(), "")], Some(AutoindentMode::EachLine), cx);
155            buffer.edit(
156                [(
157                    0..0,
158                    r#"
159                    int main() {
160                    if (a)
161                    if (b)
162                    c++;
163                    }
164                    "#
165                    .unindent(),
166                )],
167                Some(AutoindentMode::EachLine),
168                cx,
169            );
170            assert_eq!(
171                buffer.text(),
172                r#"
173                int main() {
174                  if (a)
175                    if (b)
176                      c++;
177                }
178                "#
179                .unindent(),
180                "nested if statements without braces should indent properly"
181            );
182
183            buffer.edit([(0..buffer.len(), "")], Some(AutoindentMode::EachLine), cx);
184            buffer.edit(
185                [(
186                    0..0,
187                    r#"
188                    int main() {
189                    if (a)
190                    b++;
191                    else if (c)
192                    d++;
193                    else
194                    f++;
195                    }
196                    "#
197                    .unindent(),
198                )],
199                Some(AutoindentMode::EachLine),
200                cx,
201            );
202            assert_eq!(
203                buffer.text(),
204                r#"
205                int main() {
206                  if (a)
207                    b++;
208                  else if (c)
209                    d++;
210                  else
211                    f++;
212                }
213                "#
214                .unindent(),
215                "else-if chains should align all conditions at same level with indented bodies"
216            );
217
218            buffer.edit([(0..buffer.len(), "")], Some(AutoindentMode::EachLine), cx);
219            buffer.edit(
220                [(
221                    0..0,
222                    r#"
223                    int main() {
224                    if (a) {
225                    b++;
226                    } else
227                    c++;
228                    }
229                    "#
230                    .unindent(),
231                )],
232                Some(AutoindentMode::EachLine),
233                cx,
234            );
235            assert_eq!(
236                buffer.text(),
237                r#"
238                int main() {
239                  if (a) {
240                    b++;
241                  } else
242                    c++;
243                }
244                "#
245                .unindent(),
246                "mixed braces should indent properly"
247            );
248
249            buffer
250        });
251    }
252}