dntk 3.1.1

Command line's multi-platform interactive calculator, GNU bc wrapper.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use assert_cmd::prelude::*;
use std::process::Command;

#[test]
fn test_cmd_with_once() {
    std::env::set_var("DNTK_ENV", "TEST");
    let mut cmd = Command::cargo_bin(env!("CARGO_PKG_NAME")).unwrap();
    cmd.arg("--once").arg("--inject").arg("1/3");
    // Note: f64 precision causes slight rounding differences
    // Just check that the output contains the expression and starts with .333
    let output = cmd.output().unwrap();
    let stdout = String::from_utf8_lossy(&output.stdout);
    assert!(output.status.success(), "Command should succeed");
    assert!(stdout.contains("1/3"), "Output should contain '1/3'");
    assert!(
        stdout.contains(".333"),
        "Output should contain result starting with .333"
    );
}

#[test]
fn test_cmd_with_once_white() {
    std::env::set_var("DNTK_ENV", "TEST");
    let mut cmd = Command::cargo_bin(env!("CARGO_PKG_NAME")).unwrap();
    cmd.arg("--once").arg("--white").arg("--inject").arg("1+2");
    #[cfg(not(target_os = "windows"))]
    cmd.assert()
        .success()
        .stdout("\r(dntk): \r(dntk): 1+2 = 3\u{1b}[4D\n");
    #[cfg(target_os = "windows")]
    cmd.assert()
        .success()
        .stdout("\r(dntk): \r(dntk): 1+2 = 3\n");
}

#[test]
fn test_cmd_with_once_scale() {
    std::env::set_var("DNTK_ENV", "TEST");
    let mut cmd1 = Command::cargo_bin(env!("CARGO_PKG_NAME")).unwrap();
    cmd1.arg("--once")
        .arg("--scale")
        .arg("10")
        .arg("--inject")
        .arg("3/7");
    let mut cmd2 = Command::cargo_bin(env!("CARGO_PKG_NAME")).unwrap();
    cmd2.arg("--once")
        .arg("--scale")
        .arg("1")
        .arg("--inject")
        .arg("3/7");

    // Note: f64 precision causes slight rounding differences
    // Just check that the output contains the expression and approximate results
    let output1 = cmd1.output().unwrap();
    let stdout1 = String::from_utf8_lossy(&output1.stdout);
    assert!(output1.status.success(), "Command 1 should succeed");
    assert!(stdout1.contains("3/7"), "Output 1 should contain '3/7'");
    assert!(
        stdout1.contains(".428"),
        "Output 1 should contain result starting with .428"
    );

    let output2 = cmd2.output().unwrap();
    let stdout2 = String::from_utf8_lossy(&output2.stdout);
    assert!(output2.status.success(), "Command 2 should succeed");
    assert!(stdout2.contains("3/7"), "Output 2 should contain '3/7'");
    assert!(stdout2.contains(".4"), "Output 2 should contain result .4");
}

#[test]
fn test_cmd_with_version() {
    std::env::set_var("DNTK_ENV", "TEST");
    let mut cmd = Command::cargo_bin(env!("CARGO_PKG_NAME")).unwrap();
    cmd.arg("--version").assert().success();
}

#[test]
fn test_cmd_with_help() {
    std::env::set_var("DNTK_ENV", "TEST");
    let mut cmd = Command::cargo_bin(env!("CARGO_PKG_NAME")).unwrap();
    cmd.arg("--help").assert().success();
}

#[test]
fn test_cmd_with_show_limits() {
    std::env::set_var("DNTK_ENV", "TEST");
    let mut cmd = Command::cargo_bin(env!("CARGO_PKG_NAME")).unwrap();
    cmd.arg("--show-limits").assert().success();
}

#[test]
fn test_cmd_with_multi_statements() {
    std::env::set_var("DNTK_ENV", "TEST");
    let mut cmd = Command::cargo_bin(env!("CARGO_PKG_NAME")).unwrap();
    cmd.arg("--once").arg("--inject").arg("a=1; b=a*2; b+3");
    let output = cmd.output().unwrap();
    assert!(output.status.success());
    let stdout = String::from_utf8_lossy(&output.stdout);
    assert!(stdout.contains("a=1; b=a*2; b+3"));
    assert!(stdout.contains("= 5"));
}

#[test]
fn test_cmd_with_function_definition() {
    std::env::set_var("DNTK_ENV", "TEST");
    let mut cmd = Command::cargo_bin(env!("CARGO_PKG_NAME")).unwrap();
    cmd.arg("--once")
        .arg("--inject")
        .arg("define add(x,y){ return x+y; }; add(2,3)");
    let output = cmd.output().unwrap();
    assert!(output.status.success());
    let stdout = String::from_utf8_lossy(&output.stdout);
    assert!(stdout.contains("add(2,3)"));
    assert!(stdout.contains("= 5"));
}

#[test]
fn test_cmd_with_builtin_length_scale() {
    std::env::set_var("DNTK_ENV", "TEST");
    let mut cmd = Command::cargo_bin(env!("CARGO_PKG_NAME")).unwrap();
    cmd.arg("--once")
        .arg("--inject")
        .arg("length(12345) + scale(12.345) + log(100)");
    let output = cmd.output().unwrap();
    assert!(output.status.success());
    let stdout = String::from_utf8_lossy(&output.stdout);
    assert!(stdout.contains("length(12345) + scale(12.345) + log(100)"));
    assert!(stdout.contains("= 10"));
}