mod neovim_backed_test_context;mod neovim_connection;mod vim_test_context; use std::time::Duration; use command_palette::CommandPalette;use editor::{display_map::DisplayRow, DisplayPoint};use futures::StreamExt;use gpui::{KeyBinding, Modifiers, MouseButton, TestAppContext};pub use neovim_backed_test_context::*;pub use vim_test_context::*; use indoc::indoc;use search::BufferSearchBar; use crate::{insert::NormalBefore, motion, state::Mode, ModeIndicator}; #[gpui::test]async fn test_initially_disabled(cx: &mut gpui::TestAppContext) {    let mut cx = VimTestContext::new(cx, false).await;    cx.simulate_keystrokes("h j k l");    cx.assert_editor_state("hjklˇ");} #[gpui::test]async fn test_neovim(cx: &mut gpui::TestAppContext) {    let mut cx = NeovimBackedTestContext::new(cx).await;     cx.simulate_shared_keystrokes("i").await;    cx.shared_state().await.assert_matches();    cx.simulate_shared_keystrokes("shift-t e s t space t e s t escape 0 d w")        .await;    cx.shared_state().await.assert_matches();    cx.assert_editor_state("ˇtest");} #[gpui::test]async fn test_toggle_through_settings(cx: &mut gpui::TestAppContext) {    let mut cx = VimTestContext::new(cx, true).await;     cx.simulate_keystrokes("i");    assert_eq!(cx.mode(), Mode::Insert);     // Editor acts as though vim is disabled    cx.disable_vim();    cx.simulate_keystrokes("h j k l");    cx.assert_editor_state("hjklˇ");     // Selections aren't changed if editor is blurred but vim-mode is still disabled.    cx.set_state("«hjklˇ»", Mode::Normal);    cx.assert_editor_state("«hjklˇ»");    cx.update_editor(|_, cx| cx.blur());    cx.assert_editor_state("«hjklˇ»");    cx.update_editor(|_, cx| cx.focus_self());    cx.assert_editor_state("«hjklˇ»");     // Enabling dynamically sets vim mode again and restores normal mode    cx.enable_vim();    assert_eq!(cx.mode(), Mode::Normal);    cx.simulate_keystrokes("h h h l");    assert_eq!(cx.buffer_text(), "hjkl".to_owned());    cx.assert_editor_state("hˇjkl");    cx.simulate_keystrokes("i T e s t");    cx.assert_editor_state("hTestˇjkl");     // Disabling and enabling resets to normal mode    assert_eq!(cx.mode(), Mode::Insert);    cx.disable_vim();    cx.enable_vim();    assert_eq!(cx.mode(), Mode::Normal);} #[gpui::test]async fn test_cancel_selection(cx: &mut gpui::TestAppContext) {    let mut cx = VimTestContext::new(cx, true).await;     cx.set_state(        indoc! {"The quick brown fox juˇmps over the lazy dog"},        Mode::Normal,    );    // jumps    cx.simulate_keystrokes("v l l");    cx.assert_editor_state("The quick brown fox ju«mpsˇ» over the lazy dog");     cx.simulate_keystrokes("escape");    cx.assert_editor_state("The quick brown fox jumpˇs over the lazy dog");     // go back to the same selection state    cx.simulate_keystrokes("v h h");    cx.assert_editor_state("The quick brown fox ju«ˇmps» over the lazy dog");     // Ctrl-[ should behave like Esc    cx.simulate_keystrokes("ctrl-[");    cx.assert_editor_state("The quick brown fox juˇmps over the lazy dog");} #[gpui::test]async fn test_buffer_search(cx: &mut gpui::TestAppContext) {    let mut cx = VimTestContext::new(cx, true).await;     cx.set_state(        indoc! {"            The quick brown            fox juˇmps over            the lazy dog"},        Mode::Normal,    );    cx.simulate_keystrokes("/");     let search_bar = cx.workspace(|workspace, cx| {        workspace            .active_pane()            .read(cx)            .toolbar()            .read(cx)            .item_of_type::<BufferSearchBar>()            .expect("Buffer search bar should be deployed")    });     cx.update_view(search_bar, |bar, cx| {        assert_eq!(bar.query(cx), "");    })} #[gpui::test]async fn test_count_down(cx: &mut gpui::TestAppContext) {    let mut cx = VimTestContext::new(cx, true).await;     cx.set_state(indoc! {"aˇa\nbb\ncc\ndd\nee"}, Mode::Normal);    cx.simulate_keystrokes("2 down");    cx.assert_editor_state("aa\nbb\ncˇc\ndd\nee");    cx.simulate_keystrokes("9 down");    cx.assert_editor_state("aa\nbb\ncc\ndd\neˇe");} #[gpui::test]async fn test_end_of_document_710(cx: &mut gpui::TestAppContext) {    let mut cx = VimTestContext::new(cx, true).await;     // goes to end by default    cx.set_state(indoc! {"aˇa\nbb\ncc"}, Mode::Normal);    cx.simulate_keystrokes("shift-g");    cx.assert_editor_state("aa\nbb\ncˇc");     // can go to line 1 (https://github.com/zed-industries/zed/issues/5812)    cx.simulate_keystrokes("1 shift-g");    cx.assert_editor_state("aˇa\nbb\ncc");} #[gpui::test]async fn test_end_of_line_with_times(cx: &mut gpui::TestAppContext) {    let mut cx = VimTestContext::new(cx, true).await;     // goes to current line end    cx.set_state(indoc! {"ˇaa\nbb\ncc"}, Mode::Normal);    cx.simulate_keystrokes("$");    cx.assert_editor_state("aˇa\nbb\ncc");     // goes to next line end    cx.simulate_keystrokes("2 $");    cx.assert_editor_state("aa\nbˇb\ncc");     // try to exceed the final line.    cx.simulate_keystrokes("4 $");    cx.assert_editor_state("aa\nbb\ncˇc");} #[gpui::test]async fn test_indent_outdent(cx: &mut gpui::TestAppContext) {    let mut cx = VimTestContext::new(cx, true).await;     // works in normal mode    cx.set_state(indoc! {"aa\nbˇb\ncc"}, Mode::Normal);    cx.simulate_keystrokes("> >");    cx.assert_editor_state("aa\n    bˇb\ncc");    cx.simulate_keystrokes("< <");    cx.assert_editor_state("aa\nbˇb\ncc");     // works in visual mode    cx.simulate_keystrokes("shift-v down >");    cx.assert_editor_state("aa\n    bb\n    cˇc");} #[gpui::test]async fn test_escape_command_palette(cx: &mut gpui::TestAppContext) {    let mut cx = VimTestContext::new(cx, true).await;     cx.set_state("aˇbc\n", Mode::Normal);    cx.simulate_keystrokes("i cmd-shift-p");     assert!(cx.workspace(|workspace, cx| workspace.active_modal::<CommandPalette>(cx).is_some()));    cx.simulate_keystrokes("escape");    cx.run_until_parked();    assert!(!cx.workspace(|workspace, cx| workspace.active_modal::<CommandPalette>(cx).is_some()));    cx.assert_state("aˇbc\n", Mode::Insert);} #[gpui::test]async fn test_escape_cancels(cx: &mut gpui::TestAppContext) {    let mut cx = VimTestContext::new(cx, true).await;     cx.set_state("aˇbˇc", Mode::Normal);    cx.simulate_keystrokes("escape");     cx.assert_state("aˇbc", Mode::Normal);} #[gpui::test]async fn test_selection_on_search(cx: &mut gpui::TestAppContext) {    let mut cx = VimTestContext::new(cx, true).await;     cx.set_state(indoc! {"aa\nbˇb\ncc\ncc\ncc\n"}, Mode::Normal);    cx.simulate_keystrokes("/ c c");     let search_bar = cx.workspace(|workspace, cx| {        workspace            .active_pane()            .read(cx)            .toolbar()            .read(cx)            .item_of_type::<BufferSearchBar>()            .expect("Buffer search bar should be deployed")    });     cx.update_view(search_bar, |bar, cx| {        assert_eq!(bar.query(cx), "cc");    });     cx.update_editor(|editor, cx| {        let highlights = editor.all_text_background_highlights(cx);        assert_eq!(3, highlights.len());        assert_eq!(            DisplayPoint::new(DisplayRow(2), 0)..DisplayPoint::new(DisplayRow(2), 2),            highlights[0].0        )    });    cx.simulate_keystrokes("enter");     cx.assert_state(indoc! {"aa\nbb\nˇcc\ncc\ncc\n"}, Mode::Normal);    cx.simulate_keystrokes("n");    cx.assert_state(indoc! {"aa\nbb\ncc\nˇcc\ncc\n"}, Mode::Normal);    cx.simulate_keystrokes("shift-n");    cx.assert_state(indoc! {"aa\nbb\nˇcc\ncc\ncc\n"}, Mode::Normal);} #[gpui::test]async fn test_status_indicator(cx: &mut gpui::TestAppContext) {    let mut cx = VimTestContext::new(cx, true).await;     let mode_indicator = cx.workspace(|workspace, cx| {        let status_bar = workspace.status_bar().read(cx);        let mode_indicator = status_bar.item_of_type::<ModeIndicator>();        assert!(mode_indicator.is_some());        mode_indicator.unwrap()    });     assert_eq!(        cx.workspace(|_, cx| mode_indicator.read(cx).mode),        Some(Mode::Normal)    );     // shows the correct mode    cx.simulate_keystrokes("i");    assert_eq!(        cx.workspace(|_, cx| mode_indicator.read(cx).mode),        Some(Mode::Insert)    );    cx.simulate_keystrokes("escape shift-r");    assert_eq!(        cx.workspace(|_, cx| mode_indicator.read(cx).mode),        Some(Mode::Replace)    );     // shows even in search    cx.simulate_keystrokes("escape v /");    assert_eq!(        cx.workspace(|_, cx| mode_indicator.read(cx).mode),        Some(Mode::Visual)    );     // hides if vim mode is disabled    cx.disable_vim();    cx.run_until_parked();    cx.workspace(|workspace, cx| {        let status_bar = workspace.status_bar().read(cx);        let mode_indicator = status_bar.item_of_type::<ModeIndicator>().unwrap();        assert!(mode_indicator.read(cx).mode.is_none());    });     cx.enable_vim();    cx.run_until_parked();    cx.workspace(|workspace, cx| {        let status_bar = workspace.status_bar().read(cx);        let mode_indicator = status_bar.item_of_type::<ModeIndicator>().unwrap();        assert!(mode_indicator.read(cx).mode.is_some());    });} #[gpui::test]async fn test_word_characters(cx: &mut gpui::TestAppContext) {    let mut cx = VimTestContext::new_typescript(cx).await;    cx.set_state(        indoc! { "        class A {            #ˇgoop = 99;            $ˇgoop () { return this.#gˇoop };        };        console.log(new A().$gooˇp())    "},        Mode::Normal,    );    cx.simulate_keystrokes("v i w");    cx.assert_state(        indoc! {"        class A {            «#goopˇ» = 99;            «$goopˇ» () { return this.«#goopˇ» };        };        console.log(new A().«$goopˇ»())    "},        Mode::Visual,    )} #[gpui::test]async fn test_join_lines(cx: &mut gpui::TestAppContext) {    let mut cx = NeovimBackedTestContext::new(cx).await;     cx.set_shared_state(indoc! {"      ˇone      two      three      four      five      six      "})        .await;    cx.simulate_shared_keystrokes("shift-j").await;    cx.shared_state().await.assert_eq(indoc! {"          oneˇ two          three          four          five          six          "});    cx.simulate_shared_keystrokes("3 shift-j").await;    cx.shared_state().await.assert_eq(indoc! {"          one two threeˇ four          five          six          "});     cx.set_shared_state(indoc! {"      ˇone      two      three      four      five      six      "})        .await;    cx.simulate_shared_keystrokes("j v 3 j shift-j").await;    cx.shared_state().await.assert_eq(indoc! {"      one      two three fourˇ five      six      "});} #[gpui::test]async fn test_wrapped_lines(cx: &mut gpui::TestAppContext) {    let mut cx = NeovimBackedTestContext::new(cx).await;     cx.set_shared_wrap(12).await;    // tests line wrap as follows:    //  1: twelve char    //     twelve char    //  2: twelve char    cx.set_shared_state(indoc! { "        tˇwelve char twelve char        twelve char    "})        .await;    cx.simulate_shared_keystrokes("j").await;    cx.shared_state().await.assert_eq(indoc! {"        twelve char twelve char        tˇwelve char    "});    cx.simulate_shared_keystrokes("k").await;    cx.shared_state().await.assert_eq(indoc! {"        tˇwelve char twelve char        twelve char    "});    cx.simulate_shared_keystrokes("g j").await;    cx.shared_state().await.assert_eq(indoc! {"        twelve char tˇwelve char        twelve char    "});    cx.simulate_shared_keystrokes("g j").await;    cx.shared_state().await.assert_eq(indoc! {"        twelve char twelve char        tˇwelve char    "});     cx.simulate_shared_keystrokes("g k").await;    cx.shared_state().await.assert_eq(indoc! {"        twelve char tˇwelve char        twelve char    "});     cx.simulate_shared_keystrokes("g ^").await;    cx.shared_state().await.assert_eq(indoc! {"        twelve char ˇtwelve char        twelve char    "});     cx.simulate_shared_keystrokes("^").await;    cx.shared_state().await.assert_eq(indoc! {"        ˇtwelve char twelve char        twelve char    "});     cx.simulate_shared_keystrokes("g $").await;    cx.shared_state().await.assert_eq(indoc! {"        twelve charˇ twelve char        twelve char    "});    cx.simulate_shared_keystrokes("$").await;    cx.shared_state().await.assert_eq(indoc! {"        twelve char twelve chaˇr        twelve char    "});     cx.set_shared_state(indoc! { "        tˇwelve char twelve char        twelve char    "})        .await;    cx.simulate_shared_keystrokes("enter").await;    cx.shared_state().await.assert_eq(indoc! {"            twelve char twelve char            ˇtwelve char        "});     cx.set_shared_state(indoc! { "        twelve char        tˇwelve char twelve char        twelve char    "})        .await;    cx.simulate_shared_keystrokes("o o escape").await;    cx.shared_state().await.assert_eq(indoc! {"        twelve char        twelve char twelve char        ˇo        twelve char    "});     cx.set_shared_state(indoc! { "        twelve char        tˇwelve char twelve char        twelve char    "})        .await;    cx.simulate_shared_keystrokes("shift-a a escape").await;    cx.shared_state().await.assert_eq(indoc! {"        twelve char        twelve char twelve charˇa        twelve char    "});    cx.simulate_shared_keystrokes("shift-i i escape").await;    cx.shared_state().await.assert_eq(indoc! {"        twelve char        ˇitwelve char twelve chara        twelve char    "});    cx.simulate_shared_keystrokes("shift-d").await;    cx.shared_state().await.assert_eq(indoc! {"        twelve char        ˇ        twelve char    "});     cx.set_shared_state(indoc! { "        twelve char        twelve char tˇwelve char        twelve char    "})        .await;    cx.simulate_shared_keystrokes("shift-o o escape").await;    cx.shared_state().await.assert_eq(indoc! {"        twelve char        ˇo        twelve char twelve char        twelve char    "});     // line wraps as:    // fourteen ch

Lines 1–500 of 1135. Load more