/// Change a non-utf-8 text file.

#[test]
fn delete_non_utf8_file_test() -> Result<(), anyhow::Error> {
    env_logger::try_init().unwrap_or(());
    let mut buf = Vec::new();
    use std::io::Read;
    let mut fh = std::fs::File::open("src/tests/data/gb.1")?;
    fh.read_to_end(&mut buf)?;
    let mut repo = working_copy::memory::Memory::new();
    repo.add_file("file", buf);
    let env = pristine::sanakirja::Pristine::new_anon()?;
    let mut txn = env.mut_txn_begin();
    let mut channel = txn.open_or_create_channel("main")?;
    txn.add_file("file")?;
    let store = changestore::memory::Memory::new();
    record_all(&mut repo, &store, &mut txn, &mut channel, "")?;
    let mut buf = Vec::new();
    {
        use std::io::Read;
        let mut fh = std::fs::File::open("src/tests/data/8859-1.2")?;
        fh.read_to_end(&mut buf)?;
    }
    repo.remove_path("file")?;
    let (h1, change1) = record_all_change(&mut repo, &store, &mut txn, &mut channel, "")?;
    let mut v = Vec::new();
    change1
        .write(
            &store,
            Some(h1),
            |l, _p| format!("{}:{}", l.path, l.line),
            true,
            &mut v,
        )
        .unwrap();
    let lines: Vec<&str> = std::str::from_utf8(&v)
        .unwrap()
        .lines()
        .filter(|l| l.starts_with(|c| c == '-'))
        .collect();
    assert_eq!(
        vec![
            " -Chinese / 中文,普通话,汉语 (GB 2312 / GB-encoding)",
            "- 你好"
        ],
        lines
    );
    Ok(())
}

use crate::alive::retrieve;

use crate::{alive::retrieve, text_encoding::Encoding};

    encoding: Option<Encoding>,

                changes,

        let name_start = ChangePosition(self.rec.contents.len().into());
        let file_meta = FileMetadata {
            metadata: meta,
            basename: item.basename.as_str(),
        };
        file_meta.write(&mut self.rec.contents);
        let name_end = ChangePosition(self.rec.contents.len().into());
        self.rec.contents.push(0);

        let name_start = ChangePosition(self.rec.contents.len().into());
        let file_meta = FileMetadata {
            metadata: meta,
            basename: item.basename.as_str(),
            encoding: encoding.clone(),
        };
        file_meta.write(&mut self.rec.contents);
        let name_end = ChangePosition(self.rec.contents.len().into());
        self.rec.contents.push(0);

            let mut name = Vec::new();
            let FileMetadata { basename, metadata } = changes

            let mut meta = Vec::new();
            let FileMetadata {
                basename,
                metadata,
                encoding,
            } = changes

                    &mut name,

                    &mut meta,

                        encoding,

                    self.former_parents[0].encoding.clone(),

                changes,

                    let mut name = Vec::new();

                    let mut meta = Vec::new();

                            &mut name,

                            &mut meta,

                    if name.len() > 2 {
                        if let Ok(name) = std::str::from_utf8(&name[2..]) {
                            if !full_path.is_empty() {
                                full_path.push('/');
                            }
                            full_path.push_str(name);
                        }

                    let FileMetadata { basename: name, .. } = FileMetadata::read(&mut meta);
                    if !full_path.is_empty() {
                        full_path.push('/');

                    full_path.push_str(name);

                        changes,

        changes: &C,

                    changes,

        encoding: Option<Encoding>,

            encoding: encoding.clone(),

                encoding,

            ..

        C: ChangeStore,

    ) -> Result<(), TxnErr<T::GraphError>> {

        changes: &C,
    ) -> Result<(), RecordError<C::Error, W::Error, T::GraphError>>
    where
        <W as WorkingCopy>::Error: 'static,
    {

            let name_dest = txn.find_block_end(channel, current_vertex).unwrap();
            let mut meta = Vec::new();
            let FileMetadata { encoding, .. } = changes
                .get_file_meta(
                    |p| txn.get_external(&p).unwrap().map(From::from),
                    *name_dest,
                    &mut meta,
                )
                .map_err(RecordError::Changestore)?;

                self.delete_inode_vertex(txn, channel, vertex, vertex.start_pos(), full_path)?

                self.delete_inode_vertex(
                    txn,
                    channel,
                    vertex,
                    vertex.start_pos(),
                    full_path,
                    encoding,
                )?

        encoding: Option<Encoding>,

                encoding,

    let mut cursor = ::sanakirja::btree::cursor::Cursor::new(txn, graph)
        .map_err(|x| BlockError::Txn(x.into()))?;

    let mut cursor =
        btree::cursor::Cursor::new(txn, graph).map_err(|x| BlockError::Txn(x.into()))?;

use super::vertex::*;
use super::inode_metadata::*;

use super::inode_metadata::*;
use super::vertex::*;

pub metadata: InodeMetadata,
pub position: Position<ChangeId>,

    pub metadata: InodeMetadata,
    pub position: Position<ChangeId>,

            ..

            ..

        let basename = basename.to_string();

            basename.to_string(),

            basename,

                ..

            let basename = basename.to_owned();

                        return Some(Ok((grandparent.dest(), perms, basename.to_owned())))

                        return Some(Ok((grandparent.dest(), perms, basename)))

use crate::change::{Change, ChangeHeader};

use crate::{
    change::{Change, ChangeHeader},
    text_encoding::Encoding,
};

    // pub encoding: Encoding,

    pub encoding: Option<Encoding>,

                encoding,

                encoding: encoding.clone(),

                encoding,

                encoding: encoding.clone(),

                ..

                encoding,

                    encoding: encoding.clone(),

        encoding: Option<Encoding>,

        encoding: Option<Encoding>,

                encoding,

                encoding,

                encoding,

                encoding,

                        ..

                encoding,

                write!(w, "File deletion: {:?} ", path)?;

                write!(
                    w,
                    "File deletion: {:?} {:?}",
                    path,
                    encoding_label(encoding)
                )?;

                    print_change_contents(w, changes, contents, change_contents, &None)?;

                    print_change_contents(w, changes, contents, change_contents, encoding)?;

                encoding,

                write!(w, "File un-deletion: {:?} ", path)?;

                write!(
                    w,
                    "File un-deletion: {:?} {:?}",
                    path,
                    encoding_label(encoding)
                )?;

                    print_change_contents(w, changes, contents, change_contents, &None)?;

                    print_change_contents(w, changes, contents, change_contents, encoding)?;

                        ..

                print_change_contents(w, changes, change, change_contents, &None)?;

                print_change_contents(w, changes, change, change_contents, encoding)?;

                Regex::new(r#"^([0-9]+)\. File deletion: "([^"]*)" (\d+\.\d+)"#).unwrap();

                Regex::new(r#"^([0-9]+)\. File deletion: "([^"]*)" (\d+\.\d+) "(?P<encoding>[^"]*)""#).unwrap();

                Regex::new(r#"^([0-9]+)\. File un-deletion: "([^"]*)" (\d+\.\d+)"#).unwrap();

                Regex::new(r#"^([0-9]+)\. File un-deletion: "([^"]*)" (\d+\.\d+) "(?P<encoding>[^"]*)""#).unwrap();

            let n = cap.name("n").unwrap().as_str().parse().unwrap();
            let encoding = encoding_from_label(cap);

                encoding: encoding.clone(),

            let n = cap.name("n").unwrap().as_str().parse().unwrap();

                    encoding: encoding_from_label(cap),

                    encoding,

                    encoding: encoding_from_label(cap),

                    encoding: encoding_from_label(cap),

                encoding: None,

        for a in encoding.decode(&contents).split_terminator('\n') {

        for a in encoding.decode(&contents).split('\n') {

    debug!("print_change_contents {:?}", change);

                debug!("print_change_contents {:?}", c);

                    debug!("print_change_contents {:?}", buf);