मैं stdin और stdout का परीक्षण कैसे कर सकता हूं?

Question

मैं एक त्वरित फ़ंक्शन लिखना चाहता हूं जो stdout में पास-इन स्ट्रिंग भेजता है और फिर स्ट्रिंग को स्ट्रिंग से वापस लौटाता है। मैं इसका परीक्षण कैसे कर सकता हूं?

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

और यहाँ मेरे परीक्षण प्रयास

#[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

उपयोग निर्भरता इंजेक्शन है:

यहाँ समारोह का एक उदाहरण है। जेनरिक और monomorphism साथ यह युग्मन, आप किसी भी प्रदर्शन खोना नहीं है:

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); 
} 

कई मामलों में, आप, वास्तव में expect उपयोग करने के बजाय वापस फोन करने वाले के लिए ऊपर त्रुटि का प्रचार करना चाहते हैं के रूप में आईओ एक बहुत है असफलताओं के लिए आम जगह होती है।

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); 
} 

:

---

यह तरीकों में कार्यों से आगे बढ़ाया जा सकता है