How can I avoid repeating this struct code for my tests

This is the part that's being repeated in many files. It's to mock stdout (Terminal standard output).

#[cfg(test)]
mod tests {
    use std::io::Write;

    use super::*;

    #[derive(Default, Debug)]
    pub struct MockStdout {
        pub buffer: Vec<u8>,
        pub cursor_pos: (u16, u16),
    }

    impl MockStdout {
        pub fn new() -> Self {
            let buffer = Vec::new();

            Self {
                buffer,
                cursor_pos: (1, 1),
            }
        }
    }

    impl Write for MockStdout {
        fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
            self.buffer.write(buf)
        }

        fn flush(&mut self) -> std::io::Result<()> {
            self.buffer.flush()
        }
    }

In each file, the implementation of write_term will be different:

    impl TermCursor for MockStdout {
        fn write_term(&mut self, fmt: std::fmt::Arguments) -> std::io::Result<()> {
            // the different implementation
        }
    }
}

I could put the repeated code in a file called mock_stdout.rs, then import it in tests. But this will cause some problems:

a. Having impl TermCursor for MockStdout in many files will cause an implementation conflict.

b. If I do:

MyMockStdout {
    stdout: MockStdout
}

All the code will break because it's expecting stdout, not stdout.stdout.

What's the best way to prevent repetition in a situation like this?

Seems to me like the best way to go about doing this, since you need multiple implementations for the same trait, is to use a (declarative) macro which takes in a name for the struct and produces the boilerplate code you need:

#[macro_export]
macro_rules! mock_stdout {
    ( $name:tt ) => {
        #[derive(Default, Debug)]
        pub struct $name {
            pub buffer: Vec<u8>,
            pub cursor_pos: (u16, u16),
        }

        impl $name {
            pub fn new() -> Self {
                let buffer = Vec::new();

                Self {
                    buffer,
                    cursor_pos: (1, 1),
                }
            }
        }

        impl std::io::Write for $name {
            fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
                self.buffer.write(buf)
            }

            fn flush(&mut self) -> std::io::Result<()> {
                self.buffer.flush()
            }
        }
    };
}

You can then invoke the macro with whatever name you want to use in that local segment of your code for testing. Something like this will then work:

#[cfg(test)]
mod tests {
    use path::to::mock_stdout;

    mock_stdout!(FirstMockStdout);
    mock_stdout!(SecondMockStdout);

    impl TermCursor for FirstMockStdout {
        fn write_term(&mut self, fmt: std::fmt::Arguments) -> std::io::Result<()> {
            // the first implementation
        }
    }

    impl TermCursor for SecondMockStdout {
        fn write_term(&mut self, fmt: std::fmt::Arguments) -> std::io::Result<()> {
            // the second implementation
        }
    }

    #[test]
    fn my_test() {
        let first = FirstMockStdout::new();
        ...

        let second = SecondMockStdout::new();
        ...
    }
}