#file-io #file-descriptor #sockets #stdout-stderr #cross-platform #io-stream #unix-file

stdio-override

Rust library for overriding Stdin/Stdout/Stderr with a different stream

5 releases

0.2.0 Jan 26, 2025
0.1.3 May 2, 2019
0.1.2 May 2, 2019
0.1.1 May 2, 2019
0.1.0 May 1, 2019

#112 in Debugging

Download history 1904/week @ 2024-11-30 1572/week @ 2024-12-07 1305/week @ 2024-12-14 660/week @ 2024-12-21 818/week @ 2024-12-28 1407/week @ 2025-01-04 1419/week @ 2025-01-11 1413/week @ 2025-01-18 1667/week @ 2025-01-25 1669/week @ 2025-02-01 1941/week @ 2025-02-08 1806/week @ 2025-02-15 1784/week @ 2025-02-22 1474/week @ 2025-03-01 1820/week @ 2025-03-08 1383/week @ 2025-03-15

6,825 downloads per month
Used in 6 crates

MIT/Apache

27KB
474 lines

stdio-override

Build Status Latest version Documentation License

A Rust library to easily override Stdio streams in Rust. It works on Unix and Windows platforms.

Usage

Add this to your Cargo.toml:

[dependencies]
stdio-override = "0.1"

and for Rust Edition 2015 add this to your crate root:

extern crate stdio_override;

In Rust Edition 2018 you can simply do:

use stdio_override::*;

Here's an example on how to write stdout into a file:

use std::{fs::{read_to_string, remove_file}, io};
use stdio_override::StdoutOverride;

fn main() -> io::Result<()> {
    let file_name = "./readme_test.txt";

    let guard = StdoutOverride::from_file(file_name)?;
    println!("some output");
    drop(guard);

    let contents = read_to_string(file_name)?;
    assert_eq!("some output\n", contents);
    println!("Outside!");
    remove_file(file_name)?;
    Ok(())
}

On Unix(Linux/MacOS etc.) you can also do the same with sockets:


use std::{
    io::Read,
    net::{TcpListener, TcpStream},
};
use stdio_override::StdoutOverride;

#[cfg(unix)]
fn main() {
    let address = ("127.0.0.1", 5543);

    let listener = TcpListener::bind(address).unwrap();
    let socket = TcpStream::connect(address).unwrap();

    let guard = StdoutOverride::from_io(socket).unwrap();
    println!("12345");
    drop(guard);

    let mut contents = String::new();
    let (mut stream, _) = listener.accept().unwrap();
    stream.read_to_string(&mut contents).unwrap();

    assert_eq!("12345\n", contents);

    println!("Outside!");
}
#[cfg(not(unix))]
fn main() {}

Both will work the same for Stderr and if you want to input Stdin from a file/socket you can do the following:

use std::{fs::File, io::{self, Write}};
use stdio_override::StdinOverride;

fn main() -> io::Result<()> {
    let file_name = "./test_inputs.txt";

    {
        let mut file = File::create(&file_name)?;
        file.write_all(b"Data")?;
    }

    let guard = StdinOverride::from_file(file_name)?;

    let mut inputs = String::new();
    io::stdin().read_line(&mut inputs)?;

    drop(guard);

    assert_eq!("Data", inputs);
    // Stdin is working as usual again, because the guard is dropped.
    Ok(())
}

Dependencies

~220KB