Jak mogę przetestować stdin i stdout?

Question

Chciałbym napisać funkcję monitującą, która wysyła łańcuch przekazany na standardowe wyjście, a następnie zwraca ciąg znaków, który odczytuje ze standardowego wejścia. Jak mogę to przetestować?

Oto przykład funkcji:

fn prompt(question: String) -> String { 
    let mut stdin = BufferedReader::new(stdin()); 
    print!("{}", question); 
    match stdin.read_line() { 
     Ok(line) => line, 
     Err(e) => panic!(e), 
    } 
} 

I tu jest moje badania próba

#[test] 
fn try_to_test_stdout() { 
    let writer: Vec<u8> = vec![]; 
    set_stdout(Box::new(writer)); 
    print!("testing"); 
// `writer` is now gone, can't check to see if "testing" was sent 
} 

Answer 1

wtrysku Wykorzystanie zależność. Sprzężenie go z rodzajowych i monomorfizm, nie tracić wydajność:

use std::io::{self, BufRead, Write}; 

fn prompt<R, W>(mut reader: R, mut writer: W, question: &str) -> String 
where 
    R: BufRead, 
    W: Write, 
{ 
    write!(&mut writer, "{}", question).expect("Unable to write"); 
    let mut s = String::new(); 
    reader.read_line(&mut s).expect("Unable to read"); 
    s 
} 

#[test] 
fn test_with_in_memory() { 
    let input = b"I'm George"; 
    let mut output = Vec::new(); 

    let answer = prompt(&input[..], &mut output, "Who goes there?"); 

    let output = String::from_utf8(output).expect("Not UTF-8"); 

    assert_eq!("Who goes there?", output); 
    assert_eq!("I'm George", answer); 
} 

fn main() { 
    let stdio = io::stdin(); 
    let input = stdio.lock(); 

    let output = io::stdout(); 

    let answer = prompt(input, output, "Who goes there?"); 
    println!("was: {}", answer); 
} 

w wielu przypadkach, że chcesz, aby rzeczywiście propagują błąd powrotem do rozmówcy zamiast korzystania expect, jak IO jest bardzo powszechne miejsce występowania awarii.

---

ten może zostać przedłużony poza funkcji do metod:

use std::io::{self, BufRead, Write}; 

struct Quizzer<R, W> { 
    reader: R, 
    writer: W, 
} 

impl<R, W> Quizzer<R, W> 
where 
    R: BufRead, 
    W: Write, 
{ 
    fn prompt(&mut self, question: &str) -> String { 
     write!(&mut self.writer, "{}", question).expect("Unable to write"); 
     let mut s = String::new(); 
     self.reader.read_line(&mut s).expect("Unable to read"); 
     s 
    } 
} 

#[test] 
fn test_with_in_memory() { 
    let input = b"I'm George"; 
    let mut output = Vec::new(); 

    let answer = { 
     let mut quizzer = Quizzer { 
      reader: &input[..], 
      writer: &mut output, 
     }; 

     quizzer.prompt("Who goes there?") 
    }; 

    let output = String::from_utf8(output).expect("Not UTF-8"); 

    assert_eq!("Who goes there?", output); 
    assert_eq!("I'm George", answer); 
} 

fn main() { 
    let stdio = io::stdin(); 
    let input = stdio.lock(); 

    let output = io::stdout(); 

    let mut quizzer = Quizzer { 
     reader: input, 
     writer: output, 
    }; 

    let answer = quizzer.prompt("Who goes there?"); 
    println!("was: {}", answer); 
}