pipecircuit 0.0.23

Correct. Robust. Fast. Portable. Pick four.
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

use super::super::tests::{Key, index_state, insert_membership};
use super::{SecondaryIndex, SecondaryIndexInconsistency, SecondaryIndexRemoveError};
use crate::storage::warp_table::secondary_index::StableSlot;

#[test]
fn missing_bucket_storage_refuses_removal_without_changing_memberships() -> Result<(), &'static str>
{
    let slot = StableSlot::new(13);
    let mut index = SecondaryIndex::try_new(2).map_err(|_| "index unavailable")?;
    insert_membership(&mut index, Key(7), slot)?;
    let before = index_state(&index);
    assert!(matches!(index.bucket_for_removal(Key(11), slot, 1),
        Err(SecondaryIndexRemoveError::Inconsistent {
            secondary_key: Key(11), slot: actual_slot,
            reason: SecondaryIndexInconsistency::SlotSetUnavailable { row: 1 },
        }) if actual_slot == slot));
    assert_eq!(index_state(&index), before);
    Ok(())
}

#[test]
fn bucket_removal_preserves_the_exact_invalid_preparation_coordinates() -> Result<(), &'static str>
{
    let slot = StableSlot::new(13);
    let mut index = SecondaryIndex::try_new(2).map_err(|_| "index unavailable")?;
    assert_eq!(
        index.prepare_bucket_removal(Key(7), slot, 19),
        Err(SecondaryIndexRemoveError::Inconsistent {
            secondary_key: Key(7),
            slot,
            reason: SecondaryIndexInconsistency::KeyUnavailable { row: 19 },
        })
    );
    insert_membership(&mut index, Key(7), slot)?;
    for (key, row, reason) in [
        (
            Key(11),
            23,
            SecondaryIndexInconsistency::PreparedRemovalAbsent { row: 23 },
        ),
        (
            Key(7),
            29,
            SecondaryIndexInconsistency::PreparedRemovalRowMismatch {
                found_row: 29,
                prepared_row: 0,
            },
        ),
    ] {
        let before = index_state(&index);
        assert_eq!(
            index.prepare_bucket_removal(key, slot, row),
            Err(SecondaryIndexRemoveError::Inconsistent {
                secondary_key: key,
                slot,
                reason,
            })
        );
        assert_eq!(index_state(&index), before);
    }
    insert_membership(&mut index, Key(17), StableSlot::new(31))?;
    index.secondary_keys.pop();
    let before = index_state(&index);
    assert_eq!(
        index.prepare_bucket_removal(Key(7), slot, 0),
        Err(SecondaryIndexRemoveError::Inconsistent {
            secondary_key: Key(7),
            slot,
            reason: SecondaryIndexInconsistency::KeyUnavailable { row: 1 },
        })
    );
    assert_eq!(index_state(&index), before);
    Ok(())
}