conserve 23.1.1

A robust backup tool.
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

// Conserve backup system.
// Copyright 2015, 2016, 2017, 2018, 2019, 2020, 2021 Martin Pool.

// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

use conserve::Apath;

#[test]
fn parse() {
    use conserve::apath::Apath;
    let apath: Apath = "/something".parse().unwrap();
    assert_eq!(apath.to_string(), "/something");
}

#[test]
fn is_prefix_of() {
    use std::ops::Not;
    assert!(Apath::from("/").is_prefix_of(&Apath::from("/stuff")));
    assert!(Apath::from("/").is_prefix_of(&Apath::from("/")));
    assert!(Apath::from("/stuff").is_prefix_of(&Apath::from("/stuff/file")));
    assert!(Apath::from("/stuff/file")
        .is_prefix_of(&Apath::from("/stuff"))
        .not());
    assert!(Apath::from("/this")
        .is_prefix_of(&Apath::from("/that"))
        .not());
    assert!(Apath::from("/this")
        .is_prefix_of(&Apath::from("/that/other"))
        .not());
}

#[test]
pub fn invalid() {
    let invalid_cases = [
        "",
        "//",
        "//a",
        "/a//b",
        "/a/",
        "/a//",
        "./a/b",
        "/./a/b",
        "/a/b/.",
        "/a/./b",
        "/a/b/../c",
        "../a",
        "/hello\0",
    ];
    for v in invalid_cases.iter() {
        assert!(!Apath::is_valid(v), "{v:?} incorrectly marked valid");
    }
}

#[test]
pub fn valid_and_ordered() {
    let ordered = [
        "/",
        "/...a",
        "/.a",
        "/a",
        "/b",
        "/kleine Katze Fuß",
        "/~~",
        "/ñ",
        "/a/...",
        "/a/..obscure",
        "/a/.config",
        "/a/1",
        "/a/100",
        "/a/2",
        "/a/añejo",
        "/a/b/c",
        "/b/((",
        "/b/,",
        "/b/A",
        "/b/AAAA",
        "/b/a",
        "/b/b",
        "/b/c",
        "/b/a/c",
        "/b/b/c",
        "/b/b/b/z",
        "/b/b/b/{zz}",
    ];
    for (i, a) in ordered.iter().enumerate() {
        assert!(Apath::is_valid(a), "{a:?} incorrectly marked invalid");
        let ap = Apath::from(*a);
        // Check it can be formatted
        assert_eq!(format!("{ap}"), *a);
        for (j, b) in ordered.iter().enumerate() {
            let expected_order = i.cmp(&j);
            let bp = Apath::from(*b);
            let r = ap.cmp(&bp);
            assert_eq!(
                r, expected_order,
                "cmp({ap:?}, {bp:?}): returned {r:?} expected {expected_order:?}"
            );
        }
    }
}