acyclic-fs 0.1.5

Rust SDK for versioned workspaces and embedded native mounts
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

use super::*;

#[test]
fn checkout_modes_reject_contradictions() {
    let invalid = CheckoutMode {
        access: AccessMode::ReadOnly,
        consistency: ConsistencyMode::Pinned,
        mutations: MutationMode::PrivateOverlay,
    };
    assert_eq!(invalid.validate(), Err(CheckoutModeError::ReadOnlyMutation));

    for (mode, expected) in [
        (
            CheckoutMode {
                access: AccessMode::ReadWrite,
                consistency: ConsistencyMode::Pinned,
                mutations: MutationMode::None,
            },
            CheckoutModeError::WritableWithoutMutationMode,
        ),
        (
            CheckoutMode {
                access: AccessMode::ReadWrite,
                consistency: ConsistencyMode::TrackingSafe,
                mutations: MutationMode::DirectLive,
            },
            CheckoutModeError::DirectRequiresLive,
        ),
    ] {
        assert_eq!(mode.validate(), Err(expected));
    }
}

#[test]
fn default_limits_are_valid() {
    let config = VolumeConfig {
        profile: FilesystemProfile::Portable,
        concurrency: ConcurrencyMode::Optimistic,
        lifecycle: Lifecycle::Durable,
        case_sensitivity: CaseSensitivity::Sensitive,
        unicode: UnicodePolicy::Preserve,
        symbolic_links: true,
        hard_links: true,
        sparse_files: true,
        limits: VolumeLimits::default(),
    };
    assert_eq!(config.validate(), Ok(config));
    let mut invalid = config;
    invalid.limits.maximum_directory_page_entries = 1;
    assert_eq!(
        invalid.validate(),
        Err(VolumeConfigError::InsufficientPageFanout)
    );
    invalid = config;
    invalid.limits.maximum_component_bytes = invalid.limits.maximum_path_bytes + 1;
    assert_eq!(
        invalid.validate(),
        Err(VolumeConfigError::ComponentExceedsPath)
    );
}

#[test]
fn native_component_limit_matches_host_encoding() {
    let native = VolumeConfig::native(Lifecycle::Durable);
    assert_eq!(native.validate(), Ok(native));
    #[cfg(windows)]
    assert_eq!(native.limits.maximum_component_bytes, 510);
    #[cfg(not(windows))]
    assert_eq!(native.limits.maximum_component_bytes, 255);
}