conch-runtime 0.1.2

A library for evaluating/executing programs written in the shell programming language.
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

extern crate conch_runtime;

use conch_runtime::env::{ExportedVariableEnvironment, VarEnv, VarEnvRestorer2,
                         VarRestorer, VariableEnvironment, UnsetVariableEnvironment};

#[test]
fn smoke() {
    let key_exported = "key_exported";
    let val_existing_exported = "var_exported";
    let mut env = VarEnv::with_env_vars(vec!((key_exported, val_existing_exported)));

    let key_existing = "key_existing";
    let val_existing = "val_existing";
    env.set_var(key_existing, val_existing);

    let key_originally_unset = "key_originally_unset";
    env.unset_var(&key_originally_unset);

    let env_original = env.clone();

    let val_new = "val_new";
    let val_new_alt = "val_new_alt";

    // Existing values set to multiple other values
    {
        let restorer: &mut VarEnvRestorer2<_> = &mut VarRestorer::new();

        restorer.set_exported_var2(key_exported, "some other exported value", None, &mut env);

        restorer.set_exported_var2(key_existing, val_new, Some(false), &mut env);
        assert_eq!(env.exported_var(&key_existing), Some((&val_new, false)));

        restorer.set_exported_var2(key_existing, val_new_alt, Some(true), &mut env);
        assert_eq!(env.exported_var(&key_existing), Some((&val_new_alt, true)));

        restorer.set_exported_var2(key_existing, val_new, None, &mut env);
        assert_eq!(env.exported_var(&key_existing), Some((&val_new, true)));

        assert_ne!(env_original, env);
        restorer.restore(&mut env);
        assert_eq!(env_original, env);
    }

    // Unset existing values
    {
        let restorer: &mut VarEnvRestorer2<_> = &mut VarRestorer::new();

        restorer.unset_var(key_exported, &mut env);
        assert_eq!(env.var(key_exported), None);
        restorer.unset_var(key_existing, &mut env);
        assert_eq!(env.var(key_existing), None);

        assert_ne!(env_original, env);
        restorer.restore(&mut env);
        assert_eq!(env_original, env);
    }

    // Unset then set existing values
    {
        let restorer: &mut VarEnvRestorer2<_> = &mut VarRestorer::new();

        restorer.unset_var(key_exported, &mut env);
        assert_eq!(env.var(key_exported), None);
        restorer.unset_var(key_existing, &mut env);
        assert_eq!(env.var(key_existing), None);
        restorer.set_exported_var2(key_exported, "some other exported value", None, &mut env);
        restorer.set_exported_var2(key_existing, "some other value", None, &mut env);
        restorer.set_exported_var2(key_originally_unset, "some new value", None, &mut env);

        assert_ne!(env_original, env);
        restorer.restore(&mut env);
        assert_eq!(env_original, env);
    }
}