zsplit-cli 0.4.0

Split text into multiple files by line
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

use super::*;
use crate::Error;
use std::convert::TryInto;

fn empty_cli() -> Cli {
    Cli {
        line_factor: non_zero_usize(1),
        source: Source::PathBuf(PathBuf::new()),
        destinations: vec![PathBuf::new(), PathBuf::new(), PathBuf::new()],
        distributions: Vec::new(),
    }
}

#[inline]
fn non_zero_usize(num: usize) -> NonZeroUsize {
    num.try_into().unwrap()
}

#[test]
fn invalid_source_in_destinations() {
    let cli = empty_cli();

    assert_eq!(
        *cli.validate().unwrap_err().current_context(),
        Error::FileDuplicate
    );
}

#[test]
fn valid_source_not_in_destinations() {
    let mut cli = empty_cli();
    cli.source = Source::PathBuf(PathBuf::from("test.txt"));

    cli.validate().unwrap();
}

#[test]
fn valid_source_stdin() {
    let mut cli = empty_cli();
    cli.source = Source::StdIn;

    cli.validate().unwrap();
}

#[test]
fn valid_balanced_distributions_destinations() {
    let mut cli = empty_cli();
    cli.source = Source::StdIn;
    cli.distributions = vec![non_zero_usize(3), non_zero_usize(3), non_zero_usize(3)];

    cli.validate().unwrap();
}

#[test]
fn invalid_more_distributions_than_destinations() {
    let mut cli = empty_cli();
    cli.destinations = Vec::new();
    cli.distributions = vec![non_zero_usize(3), non_zero_usize(3)];

    assert_eq!(
        *cli.validate().unwrap_err().current_context(),
        Error::MoreDistributionsAsDestinations {
            destinations_len: 0,
            distributions_len: 2
        }
    );
}

#[test]
fn default_distribution() {
    let destinations = empty_cli().destinations().unwrap();

    assert_eq!(destinations.len(), 3);
    assert!(destinations
        .iter()
        .all(|destination| destination.assigned_lines == 1));
}

#[test]
fn default_distribution_with_line_factor() {
    let mut cli = empty_cli();
    cli.line_factor = non_zero_usize(2);

    let destinations = cli.destinations().unwrap();

    assert_eq!(destinations.len(), 3);
    assert!(destinations
        .iter()
        .all(|destination| destination.assigned_lines == 2));
}

#[test]
fn partial_distribution() {
    let mut cli = empty_cli();
    cli.distributions = vec![non_zero_usize(3), non_zero_usize(3)];

    let destinations = cli.destinations().unwrap();

    assert_eq!(destinations.len(), 3);
    assert_eq!(destinations[0].assigned_lines, 3);
    assert_eq!(destinations[1].assigned_lines, 3);
    assert_eq!(destinations[2].assigned_lines, 1);
}

#[test]
fn partial_distribution_with_line_factor() {
    let mut cli = empty_cli();
    cli.distributions = vec![non_zero_usize(3), non_zero_usize(3)];
    cli.line_factor = non_zero_usize(2);

    let destinations = cli.destinations().unwrap();

    assert_eq!(destinations.len(), 3);
    assert_eq!(destinations[0].assigned_lines, 6);
    assert_eq!(destinations[1].assigned_lines, 6);
    assert_eq!(destinations[2].assigned_lines, 2);
}

#[cfg(any(unix, target_os = "redox"))]
#[test]
fn error_during_sink_creation() {
    use std::os::unix::ffi::OsStrExt;
    let mut cli = empty_cli();
    cli.destinations[0] = std::ffi::OsStr::from_bytes(&[0x66, 0x6f, 0x80, 0x6f]).into();

    let _ = cli.destinations().unwrap_err();
}