-use helix_core::diagnostic::Severity;

-use helix_stdx::path;

-async fn test_exit_w_buffer_w_path() -> anyhow::Result<()> {

- let mut file = tempfile::NamedTempFile::new()?;

- let mut app = helpers::AppBuilder::new()

- .with_file(file.path(), None)

- .build()?;

- // Check for write operation on given path and edited buffer

- test_key_sequence(

- &mut app,

- Some("iBecause of the obvious threat to untold numbers of citizens due to the crisis that is even now developing, this radio station will remain on the air day and night.<ret><esc>:x<ret>"),

- None,

- true,

- )

- .await?;

-

- reload_file(&mut file).unwrap();

- let mut file_content = String::new();

- file.as_file_mut().read_to_string(&mut file_content)?;

-

- assert_eq!(

- LineFeedHandling::Native.apply("Because of the obvious threat to untold numbers of citizens due to the crisis that is even now developing, this radio station will remain on the air day and night.\n"),

- file_content

- );

-

- Ok(())

-}

-

-#[tokio::test(flavor = "multi_thread")]

-async fn test_exit_wo_buffer_w_path() -> anyhow::Result<()> {

- let mut file = tempfile::NamedTempFile::new()?;

- let mut app = helpers::AppBuilder::new()

- .with_file(file.path(), None)

- .build()?;

-

- helpers::run_event_loop_until_idle(&mut app).await;

-

- file.as_file_mut()

- .write_all("extremely important content".as_bytes())?;

- file.as_file_mut().flush()?;

- file.as_file_mut().sync_all()?;

-

- test_key_sequence(&mut app, Some(":x<ret>"), None, true).await?;

-

- reload_file(&mut file).unwrap();

- let mut file_content = String::new();

- file.read_to_string(&mut file_content)?;

- // check that nothing is written to file

- assert_eq!("extremely important content", file_content);

-

- Ok(())

-}

-

-#[tokio::test(flavor = "multi_thread")]

-async fn test_exit_wo_buffer_wo_path() -> anyhow::Result<()> {

- test_key_sequence(

- &mut AppBuilder::new().build()?,

- Some(":x<ret>"),

- Some(&|app| {

- assert!(!app.editor.is_err());

- }),

- true,

- )

- .await?;

-

- Ok(())

-}

-

-#[tokio::test(flavor = "multi_thread")]

-async fn test_exit_w_buffer_wo_file() -> anyhow::Result<()> {

- let mut file = tempfile::NamedTempFile::new()?;

- test_key_sequence(

- // try to write without destination

- &mut AppBuilder::new().build()?,

- Some("itest<esc>:x<ret>"),

- None,

- false,

- )

- .await?;

- test_key_sequence(

- // try to write with path succeeds

- &mut AppBuilder::new().build()?,

- Some(format!("iMicCheck<esc>:x {}<ret>", file.path().to_string_lossy()).as_ref()),

- Some(&|app| {

- assert!(!app.editor.is_err());

- }),

- true,

- )

- .await?;

-

- helpers::assert_file_has_content(&mut file, &LineFeedHandling::Native.apply("MicCheck"))?;

-

- Ok(())

-}

-

-#[tokio::test(flavor = "multi_thread")]

- assert_eq!(Some(&path::normalize(file.path())), doc.path());

- helpers::assert_file_has_content(

- &mut file,

- &LineFeedHandling::Native.apply(&RANGE.end().to_string()),

- )?;

- reload_file(&mut file).unwrap();

- LineFeedHandling::Native.apply("the gostak distims the doshes"),

- .write_all("extremely important content".as_bytes())?;

- test_key_sequence(&mut app, Some("iOverwriteData<esc>:x<ret>"), None, false).await?;

- reload_file(&mut file).unwrap();

- file.read_to_string(&mut file_content)?;

- assert_eq!("extremely important content", file_content);

- reload_file(&mut file).unwrap();

- file.read_to_string(&mut file_content)?;

- LineFeedHandling::Native.apply("the gostak distims the doshes"),

- reload_file(&mut file).unwrap();

- file.read_to_string(&mut file_content)?;

- assert_eq!(

- LineFeedHandling::Native.apply(&RANGE.end().to_string()),

- file_content

- );

- assert_eq!(Some(&path::normalize(file.path())), doc.path());

- helpers::assert_file_has_content(&mut file, &LineFeedHandling::Native.apply("hello"))?;

- .with_lang_loader(helpers::test_syntax_loader(Some(lang_conf.into())))

- helpers::assert_file_has_content(&mut file, "let foo = 0;\n")?;

- assert_eq!(&path::normalize(file1.path()), doc.path().unwrap());

- assert_eq!(&path::normalize(file2.path()), doc.path().unwrap());

- &mut file1,

- &LineFeedHandling::Native.apply("i can eat glass, it will not hurt me\n"),

- &mut file2,

- &LineFeedHandling::Native.apply("i can eat glass, it will not hurt me\n"),

-

-#[tokio::test(flavor = "multi_thread")]

-async fn test_write_utf_bom_file() -> anyhow::Result<()> {

- // "ABC" with utf8 bom

- const UTF8_FILE: [u8; 6] = [0xef, 0xbb, 0xbf, b'A', b'B', b'C'];

-

- // "ABC" in UTF16 with bom

- const UTF16LE_FILE: [u8; 8] = [0xff, 0xfe, b'A', 0x00, b'B', 0x00, b'C', 0x00];

- const UTF16BE_FILE: [u8; 8] = [0xfe, 0xff, 0x00, b'A', 0x00, b'B', 0x00, b'C'];

-

- edit_file_with_content(&UTF8_FILE).await?;

- edit_file_with_content(&UTF16LE_FILE).await?;

- edit_file_with_content(&UTF16BE_FILE).await?;

-

- Ok(())

-}

-

-#[tokio::test(flavor = "multi_thread")]

-async fn test_write_trim_trailing_whitespace() -> anyhow::Result<()> {

- let mut file = tempfile::NamedTempFile::new()?;

- let mut app = helpers::AppBuilder::new()

- .with_config(Config {

- editor: helix_view::editor::Config {

- trim_trailing_whitespace: true,

- ..Default::default()

- },

- ..Default::default()

- })

- .with_file(file.path(), None)

- .with_input_text(LineFeedHandling::Native.apply("#[f|]#oo \n\n \nbar "))

- .build()?;

-

- test_key_sequence(&mut app, Some(":w<ret>"), None, false).await?;

-

- helpers::assert_file_has_content(&mut file, &LineFeedHandling::Native.apply("foo\n\n\nbar"))?;

-

- Ok(())

-}

-

-#[tokio::test(flavor = "multi_thread")]

-async fn test_write_trim_final_newlines() -> anyhow::Result<()> {

- let mut file = tempfile::NamedTempFile::new()?;

- let mut app = helpers::AppBuilder::new()

- .with_config(Config {

- editor: helix_view::editor::Config {

- trim_final_newlines: true,

- ..Default::default()

- },

- ..Default::default()

- })

- .with_file(file.path(), None)

- .with_input_text(LineFeedHandling::Native.apply("#[f|]#oo\n \n\n\n"))

- .build()?;

-

- test_key_sequence(&mut app, Some(":w<ret>"), None, false).await?;

-

- helpers::assert_file_has_content(&mut file, &LineFeedHandling::Native.apply("foo\n \n"))?;

-

- Ok(())

-}

-

-#[tokio::test(flavor = "multi_thread")]

-async fn test_write_insert_final_newline_added_if_missing() -> anyhow::Result<()> {

- let mut file = tempfile::NamedTempFile::new()?;

- let mut app = helpers::AppBuilder::new()

- .with_file(file.path(), None)

- .with_input_text("#[h|]#ave you tried chamomile tea?")

- .build()?;

-

- test_key_sequence(&mut app, Some(":w<ret>"), None, false).await?;

-

- helpers::assert_file_has_content(

- &mut file,

- &LineFeedHandling::Native.apply("have you tried chamomile tea?\n"),

- )?;

-

- Ok(())

-}

-

-#[tokio::test(flavor = "multi_thread")]

-async fn test_write_insert_final_newline_unchanged_if_empty() -> anyhow::Result<()> {

- let mut file = tempfile::NamedTempFile::new()?;

- let mut app = helpers::AppBuilder::new()

- .with_file(file.path(), None)

- .with_input_text("#[|]#")

- .build()?;

-

- test_key_sequence(&mut app, Some(":w<ret>"), None, false).await?;

-

- helpers::assert_file_has_content(&mut file, "")?;

-

- Ok(())

-}

-

-#[tokio::test(flavor = "multi_thread")]

-async fn test_write_insert_final_newline_unchanged_if_not_missing() -> anyhow::Result<()> {

- let mut file = tempfile::NamedTempFile::new()?;

- let mut app = helpers::AppBuilder::new()

- .with_file(file.path(), None)

- .with_input_text(LineFeedHandling::Native.apply("#[t|]#en minutes, please\n"))

- .build()?;

-

- test_key_sequence(&mut app, Some(":w<ret>"), None, false).await?;

-

- helpers::assert_file_has_content(

- &mut file,

- &LineFeedHandling::Native.apply("ten minutes, please\n"),

- )?;

-

- Ok(())

-}

-

-#[tokio::test(flavor = "multi_thread")]

-async fn test_write_insert_final_newline_unchanged_if_missing_and_false() -> anyhow::Result<()> {

- let mut file = tempfile::NamedTempFile::new()?;

- let mut app = helpers::AppBuilder::new()

- .with_config(Config {

- editor: helix_view::editor::Config {

- insert_final_newline: false,

- ..Default::default()

- },

- ..Default::default()

- })

- .with_file(file.path(), None)

- .with_input_text("#[t|]#he quiet rain continued through the night")

- .build()?;

-

- test_key_sequence(&mut app, Some(":w<ret>"), None, false).await?;

-

- reload_file(&mut file).unwrap();

- helpers::assert_file_has_content(&mut file, "the quiet rain continued through the night")?;

-

- Ok(())

-}

-

-#[tokio::test(flavor = "multi_thread")]

-async fn test_write_all_insert_final_newline_add_if_missing_and_modified() -> anyhow::Result<()> {

- let mut file1 = tempfile::NamedTempFile::new()?;

- let mut file2 = tempfile::NamedTempFile::new()?;

- let mut app = helpers::AppBuilder::new()

- .with_file(file1.path(), None)

- .with_input_text("#[w|]#e don't serve time travelers here")

- .build()?;

-

- test_key_sequence(

- &mut app,

- Some(&format!(

- ":o {}<ret>ia time traveler walks into a bar<esc>:wa<ret>",

- file2.path().to_string_lossy()

- )),

- None,

- false,

- )

- .await?;

-

- helpers::assert_file_has_content(

- &mut file1,

- &LineFeedHandling::Native.apply("we don't serve time travelers here\n"),

- )?;

-

- helpers::assert_file_has_content(

- &mut file2,

- &LineFeedHandling::Native.apply("a time traveler walks into a bar\n"),

- )?;

-

- Ok(())

-}

-

-#[tokio::test(flavor = "multi_thread")]

-async fn test_write_all_insert_final_newline_do_not_add_if_unmodified() -> anyhow::Result<()> {

- let mut file = tempfile::NamedTempFile::new()?;

- let mut app = helpers::AppBuilder::new()

- .with_file(file.path(), None)

- .build()?;

-

- file.write_all(b"i lost on Jeopardy!")?;

- file.rewind()?;

-

- test_key_sequence(&mut app, Some(":wa<ret>"), None, false).await?;

-

- helpers::assert_file_has_content(&mut file, "i lost on Jeopardy!")?;

-

- Ok(())

-}

-

-#[tokio::test(flavor = "multi_thread")]

-async fn test_symlink_write() -> anyhow::Result<()> {

- #[cfg(unix)]

- use std::os::unix::fs::symlink;

- #[cfg(not(unix))]

- use std::os::windows::fs::symlink_file as symlink;

-

- let dir = tempfile::tempdir()?;

-

- let mut file = tempfile::NamedTempFile::new_in(&dir)?;

- let symlink_path = dir.path().join("linked");

- symlink(file.path(), &symlink_path)?;

-

- let mut app = helpers::AppBuilder::new()

- .with_file(&symlink_path, None)

- .build()?;

-

- test_key_sequence(

- &mut app,

- Some("ithe gostak distims the doshes<ret><esc>:w<ret>"),

- None,

- false,

- )

- .await?;

-

- reload_file(&mut file).unwrap();

- let mut file_content = String::new();

- file.as_file_mut().read_to_string(&mut file_content)?;

-

- assert_eq!(

- LineFeedHandling::Native.apply("the gostak distims the doshes"),

- file_content

- );

- assert!(symlink_path.is_symlink());

-

- Ok(())

-}

-

-#[tokio::test(flavor = "multi_thread")]

-async fn test_symlink_write_fail() -> anyhow::Result<()> {

- #[cfg(unix)]

- use std::os::unix::fs::symlink;

- #[cfg(not(unix))]

- use std::os::windows::fs::symlink_file as symlink;

-

- let dir = tempfile::tempdir()?;

-

- let file = helpers::new_readonly_tempfile_in_dir(&dir)?;

- let symlink_path = dir.path().join("linked");

- symlink(file.path(), &symlink_path)?;

-

- let mut app = helpers::AppBuilder::new()

- .with_file(&symlink_path, None)

- .build()?;

-

- test_key_sequence(

- &mut app,

- Some("ihello<esc>:wq<ret>"),

- Some(&|app| {

- let mut docs: Vec<_> = app.editor.documents().collect();

- assert_eq!(1, docs.len());

-

- let doc = docs.pop().unwrap();

- assert_eq!(Some(&path::normalize(&symlink_path)), doc.path());

- assert_eq!(&Severity::Error, app.editor.get_status().unwrap().1);

- }),

- false,

- )

- .await?;

-

- assert!(symlink_path.is_symlink());

-

- Ok(())

-}

-

-#[tokio::test(flavor = "multi_thread")]

-async fn test_symlink_write_relative() -> anyhow::Result<()> {

- #[cfg(unix)]

- use std::os::unix::fs::symlink;

- #[cfg(not(unix))]

- use std::os::windows::fs::symlink_file as symlink;

-

- // tempdir

- // |- - b

- // | |- file

- // |- linked (symlink to file)

- let dir = tempfile::tempdir()?;

- let inner_dir = dir.path().join("b");

- std::fs::create_dir(&inner_dir)?;

-

- let mut file = tempfile::NamedTempFile::new_in(&inner_dir)?;

- let symlink_path = dir.path().join("linked");

- let relative_path = std::path::PathBuf::from("b").join(file.path().file_name().unwrap());

- symlink(relative_path, &symlink_path)?;

-

- let mut app = helpers::AppBuilder::new()

- .with_file(&symlink_path, None)

- .build()?;

-

- test_key_sequence(

- &mut app,

- Some("ithe gostak distims the doshes<ret><esc>:w<ret>"),

- None,

- false,

- )

- .await?;

-

- reload_file(&mut file).unwrap();

- let mut file_content = String::new();

- file.as_file_mut().read_to_string(&mut file_content)?;

-

- assert_eq!(

- LineFeedHandling::Native.apply("the gostak distims the doshes"),

- file_content

- );

- assert!(symlink_path.is_symlink());

-

- Ok(())

-}

-

-#[tokio::test(flavor = "multi_thread")]

-#[cfg(not(target_os = "android"))]

-async fn test_hardlink_write() -> anyhow::Result<()> {

- let dir = tempfile::tempdir()?;

-

- let mut file = tempfile::NamedTempFile::new_in(&dir)?;

- let hardlink_path = dir.path().join("linked");

- std::fs::hard_link(file.path(), &hardlink_path)?;

-

- let mut app = helpers::AppBuilder::new()

- .with_file(&hardlink_path, None)

- .build()?;

-

- test_key_sequence(

- &mut app,

- Some("ithe gostak distims the doshes<ret><esc>:w<ret>"),

- None,

- false,

- )

- .await?;

-

- reload_file(&mut file).unwrap();

- let mut file_content = String::new();

- file.as_file_mut().read_to_string(&mut file_content)?;

-

- assert_eq!(

- LineFeedHandling::Native.apply("the gostak distims the doshes"),

- file_content

- );

- assert!(helix_stdx::faccess::hardlink_count(&hardlink_path)? > 1);

- assert!(same_file::is_same_file(file.path(), &hardlink_path)?);

-

- Ok(())

-}

-

-async fn edit_file_with_content(file_content: &[u8]) -> anyhow::Result<()> {

- let mut file = tempfile::NamedTempFile::new()?;

-

- file.as_file_mut().write_all(&file_content)?;

-

- helpers::test_key_sequence(

- &mut helpers::AppBuilder::new()

- .with_config(Config {

- editor: helix_view::editor::Config {

- insert_final_newline: false,

- ..Default::default()

- },

- ..Default::default()

- })

- .build()?,

- Some(&format!(":o {}<ret>:x<ret>", file.path().to_string_lossy())),

- None,

- true,

- )

- .await?;

-

- reload_file(&mut file).unwrap();

- let mut new_file_content: Vec<u8> = Vec::new();

- file.read_to_end(&mut new_file_content)?;

-

- assert_eq!(file_content, new_file_content);

-

- Ok(())

-}

-

-#[tokio::test(flavor = "multi_thread")]

-async fn test_move_file_when_given_dir_and_filename() -> anyhow::Result<()> {

- let dir = tempfile::tempdir()?;

- let source_file = tempfile::NamedTempFile::new_in(&dir)?;

- let target_file = dir.path().join("new_name.ext");

-

- let mut app = helpers::AppBuilder::new()

- .with_file(source_file.path(), None)

- .build()?;

-

- test_key_sequence(

- &mut app,

- Some(format!(":move {}<ret>", target_file.to_string_lossy()).as_ref()),

- None,

- false,

- )

- .await?;

-

- assert!(

- target_file.is_file(),

- "target file '{}' should have been created",

- target_file.display()

- );

- assert!(

- !source_file.path().exists(),

- "Source file '{}' should have been removed",

- source_file.path().display()

- );

-

- Ok(())

-}

-

-#[tokio::test(flavor = "multi_thread")]

-async fn test_move_file_when_given_dir_only() -> anyhow::Result<()> {

- let source_dir = tempfile::tempdir()?;

- let target_dir = tempfile::tempdir()?;

- let source_file = source_dir.path().join("file.ext");

- std::fs::File::create(&source_file)?;

-

- let mut app = helpers::AppBuilder::new()

- .with_file(&source_file, None)

- .build()?;

-

- test_key_sequence(

- &mut app,

- Some(format!(":move {}<ret>", target_dir.path().to_string_lossy()).as_ref()),

- None,

- false,

- )

- .await?;

-

- let target_file = target_dir.path().join("file.ext");

-

- assert!(

- target_file.is_file(),

- "target file '{}' should have been created",

- target_file.display()

- );

- assert!(

- !source_file.exists(),

- "Source file '{}' should have been removed",

- source_file.display()

- );

-

- Ok(())

-}