Ch1

echo hello
hello

echo "hello world"
hello world

echo hello   world # 传入了两个参数 
hello world

echo会在字符串末尾自动添加换行, 因此这里有两次换行

echo "a\n" 
a

这里只有一次换行, 因为-n选项使得末尾换行被替换为 '\c'

echo -n "a\n" 
a

echo -n  "hello"
hello%
echo -n "a"  
a%            

fn main() {
    println!("{:?}", std::env::args()); 
}

{} 是一个占位符, 只有实现了 std::fmt:Display 的对象才能用它打印. 在这里不能用, 而是要使用 {:?} 来输出 debug 版本的struct

# inner: 后面的就是struct中的内容  
~/src/rust-learning/echor $ cargo run -q
Args { inner: ["target/debug/echor"] }

$ cargo run -q arg1 hello

Args { inner: ["target/debug/echor", "arg1", "hello"] }

但是加入我们希望传入一个选项参数, -n 会被当成是cargo的参数

cargo run -n hello

因此需要用 -- 来指明cargo选项参数的结束:

cargo run -- -n hello 

$ cargo run -q -- -n -q hello
Args { inner: ["target/debug/echor", "-n", "-q", "hello"] }

[dependencies]
clap = "2"

cargo build

查看文件大小

du -shc .

use clap::App;

fn main() {
    let _matches = App::new("echor") // 应用名 
        .version("0.1.0")
        .author("sun")
        .about("echo in rust")
        .get_matches() ; // 解析命令行参数 
}

$ cargo run -q -- -h
echor 0.1.0
sun
echo in rust

USAGE:
    echor

FLAGS:
    -h, --help       Prints help information
    -V, --version    Prints version information

use clap::{App,Arg};


fn main() {

    //  println!("{:?}", std::env::args());
    let matches = App::new("echor") // 应用名 
    .version("0.1.0")
    .author("sun")
    .about("echo in rust")
    .arg(Arg::with_name("test") // 作为map的key, 用于取出值
         .value_name("TEXT") 
         .help("input test")
         .required(true) // 是否是必须的参数 
         .min_values(1), // 且此参数至少要有一个 
    )
    .arg(Arg::with_name("omit_newline") 
         .short("n")
         .help("don't print newline")
         .takes_value(false), // 无需为此选项传值 
    )
    .get_matches() ; // 解析命令行参数
    println!("{:#?}", matches); //用换行和缩进进行打印 
}

 $ cargo run -q -- -n  hello world 
ArgMatches {
    args: {
        "omit_newline": MatchedArg {
            occurs: 1,
            indices: [
                1,
            ],
            vals: [],
        },
        "test": MatchedArg {
            occurs: 2,
            indices: [
                2,
                3,
            ],
            vals: [
                "hello",
                "world",
            ],
        },
    },
    subcommand: None,
    usage: Some(
        "USAGE:\n    echor [FLAGS] <TEXT>...",
    ),
}

$ cargo run -q -- -h
echor 0.1.0
sun
echo in rust

USAGE:
    echor [FLAGS] <TEXT>...

FLAGS:
    -h, --help       Prints help information
    -n               don't print newline
    -V, --version    Prints version information

ARGS:
    <TEXT>...    input test

ArgMatches::values_of -> Option<Values> // Values是迭代器 

ArgMatches::values_of_lossy -> Option<Vec<String>> 

取出必需的 "text" 参数 :

matches.values_of_lossy("text").unwrap(); 

对可选的 -n 参数, 要先判断其是否存在

matches.is_present("omit_newline");

为了让输出的结果h之间每个都恰好间隔以后一个空格, 我们需要用到 Vec::join 函数 :

let v = vec!["hello","world"];
println!("{}", v.join("@")) ;

hello@world

use clap::{App,Arg};

fn main() {
    let matches = App::new("echor") // 应用名 
    .version("0.1.0")
    .author("sun")
    .about("echo in rust")
    .arg(Arg::with_name("test") // 作为map的key, 用于取出值
         .value_name("TEXT") 
         .help("input test")
         .required(true) // 是否是必须的参数 
         .min_values(1), // 且此参数至少要有一个 
    )
    .arg(Arg::with_name("omit_newline") 
         .short("n")
         .help("don't print newline")
         .takes_value(false), // 无需为此选项传值 
    )
    .get_matches() ; // 解析命令行参数

    let text = matches.values_of_lossy("text").unwrap();
    let is_newline = matches.is_present("omit_newline");

    print!("{}{}", text.join(" "), if is_newline  {""} else {"\n" }) ;
}

为了进行测试, 除了使用 assert_cmd 之外, 还要使用 predicates , 即: "谓词".

[dev-dependencies]
 assert_cmd = "2"
 predicates = "2"

因为有的时候测试应满足的条件不是简单地判断是否等于某个值, 比如说输出中应包含了 "USAGE" 这个字符串. 这时候就需要使用"谓词".

use assert_cmd::Command;
use predicates::prelude::* ;
#[test]
fn dies_no_args() {
    let mut cmd = Command::cargo_bin("echor").unwrap();
    cmd.assert().failure().stderr(predicate::str::contains("USAGE") ); 
}

另外有一个技巧就是为一组测试的函数名用相同的前缀, 例如 dies 这样可以使cargo test只运行这些包含了前缀的测试:

cargo test dies

用 .arg() 传入参数进行测试:

#[test]
fn one_arg(){
    let mut cmd = Command::cargo_bin("echor").unwrap();
    cmd.arg("hello").assert().success().stdout(predicate::str::contains("hello"));
}

#!/bin/bash

OUTDIR="tests/expected"
# 注意中括号之间的空格 
[[ ! -d "$OUTDIR" ]] && mkdir -p "$OUTDIR" # 判断是否存在此目录, 不存在则创建 

echo "hello there" > $OUTDIR/hello1
echo "hello"   "there" > $OUTDIR/hello2
echo -n "hello   there" > $OUTDIR/hello1n
echo -n "hello" "there" > $OUTDIR/hello2n

use std::fs;
#[test]
fn hello1(){
    let outfile = "tests/expected/hello1" ;
    let expected = fs::read_to_string(outfile).unwrap();
    let mut cmd = Command::cargo_bin("echor").unwrap();
    cmd.arg("hello there").assert().success().stdout(expected);
}

//  TestResult = Ok of unit | Err of Box<dyn std::error::Error>
type TestResult = Result<(), Box<dyn std::error::Error>> ;