[Rust book] why is the insensitive test failing

hello,

This is the code I have from the rust book

use std::env;
use std::process; 
use minigrep::Config;

fn main() {
    let config = Config::new(env::args()).unwrap_or_else(|err| {
        eprintln!("Problem parsing arguments: {}", err);
        process::exit(1);
    });

    if let Err(e) = minigrep::run(config){
        eprintln!("Application error: {}", e);

        process::exit(1);
    }
}

lib.rs

use std::error::Error;

use std::fs;

use std::env;

pub struct Config {

  pub query: String,

  pub filename: String,

  pub case_sensitive: bool,

}

impl Config {

  pub fn new(mut args: env::Args) -> Result<Config, &'static str> {

      args.next();

      let query = match args.next() {

          Some(arg) => arg,

          None => return Err("Didn't get a query string"),

      };

      let filename = match args.next() {

          Some(arg) => arg,

          None => return Err("Didn't get a file name"),

      };

      let case_sensitive = env::var("CASE_INSENSITIVE").is_err();

      Ok(Config {

          query,

          filename,

          case_sensitive,

      })

  }

}

pub fn run(config: Config) -> Result<(), Box<dyn Error>> {

  let contents = fs::read_to_string(config.filename)?;

  let results = if config.case_sensitive {

      search(&config.query, &contents)

  } else {

      search_case_insensitive(&config.query, &contents)

  };

  for line in results {

      println!("{}", line);

  }

  Ok(())

}

pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {

  contents

      .lines()

      .filter(|line| line.contains(query))

      .collect()

}

pub fn search_case_insensitive<'a>(query: &str,contents: &'a str,) -> Vec<&'a str> {

   contents

     .lines()

     .filter(|line| line.contains(&query.to_lowercase()))

     .collect()

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn case_sensitive() {

        let query = "duct";

        let contents = "\

Rust:

safe, fast, productive.

Pick three.

Duct tape.";

        assert_eq!(vec!["safe, fast, productive."], search(query, contents));

    }

    #[test]

    fn case_insensitive() {

        let query = "rUsT";

        let contents = "\

Rust:

safe, fast, productive.

Pick three.

Trust me.";

        assert_eq!(

            vec!["Rust:", "Trust me."],

            search_case_insensitive(query, contents)

        );

    }

}

But now this test is failing and i do not see why ?


failures:

---- tests::case_insensitive stdout ----
thread 'tests::case_insensitive' panicked at 'assertion failed: `(left == right)`
  left: `["Rust:", "Trust me."]`,
 right: `["Trust me."]`', src/lib.rs:90:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Anyone a hint why this is failing ?

You compare them case-insensitively using:

.filter(|line| line.contains(&query.to_lowercase()))

however this only makes the query lower-case. The line may still be upper-case, and indeed "Rust" is not the same as "rust".

Thanks,

chancing the line to this :

 .filter(|line| line.to_lowercase().contains(&query.to_lowercase()))

did the job

This topic was automatically closed 90 days after the last reply. We invite you to open a new topic if you have further questions or comments.