test-bd 0.2.0

A library and CLI tool for creating procedurally generated test block devices using ublk
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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

// Stress tests for test-bd
//
// These tests push the system to its limits to find resource constraints.
// They may take longer to run and consume more resources than regular tests.

mod common;

use test_bd::{DeviceManager, TestBlockDeviceConfig};

#[test]
fn test_max_device_count_explicit_ids() {
    // Setup: ensure clean state before test
    common::test_utils::test_setup().expect("Test setup failed - please clean up before running");

    let mut manager = DeviceManager::new();
    let mut created_devices = Vec::new();

    let start_time = std::time::Instant::now();

    // Try creating devices with explicit IDs
    for id in 0..64 {
        let config = TestBlockDeviceConfig {
            dev_id: id,
            size: 64 * 1024 * 1024,
            seed: id as u64,
            fill_percent: 100,
            duplicate_percent: 0,
            random_percent: 0,
            segments: 10,
            unprivileged: true,
        };

        match manager.create(config) {
            Ok(device) => {
                if id % 10 == 0 || id < 10 {
                    log::debug!("Created device with ID {}: /dev/ublkb{}", id, device.dev_id);
                }
                assert_eq!(device.dev_id, id, "Device ID should match requested ID");
                created_devices.push(device.dev_id);
            }
            Err(e) => {
                log::error!("\nFailed to create device with ID {} with error {}", id, e);
                log::debug!(
                    "Successfully created {} devices (IDs 0-{})",
                    created_devices.len(),
                    created_devices.len() - 1
                );
                break;
            }
        }
    }

    let elapsed = start_time.elapsed();

    // Verify we created at least one device
    assert!(
        !created_devices.is_empty(),
        "Should be able to create at least one device"
    );

    log::debug!(
        "Average create time per device: {:.2?}",
        elapsed / created_devices.len() as u32
    );

    // Clean up all devices
    let cleanup_start = std::time::Instant::now();
    manager.delete_all().expect("Failed to clean up devices");
    let cleanup_elapsed = cleanup_start.elapsed();
    log::debug!(
        "Average cleanup time per device: {:.2?}\n",
        cleanup_elapsed / created_devices.len() as u32
    );

    // Teardown: verify clean state after test
    common::test_utils::test_teardown().expect("Test teardown found issues - see logs above");
}

#[test]
fn test_rapid_create_delete() {
    // Setup: ensure clean state before test
    common::test_utils::test_setup().expect("Test setup failed - please clean up before running");

    log::debug!("\n=== Testing Rapid Device Creation and Deletion ===");
    log::debug!("Creating and deleting devices 100 times...\n");

    let start_time = std::time::Instant::now();

    for i in 0..100 {
        let mut manager = DeviceManager::new();

        let config = TestBlockDeviceConfig {
            dev_id: 0,
            size: 1024 * 1024 * 1024,
            seed: i,
            fill_percent: 100,
            duplicate_percent: 0,
            random_percent: 0,
            segments: 10,
            unprivileged: true,
        };

        let device = manager
            .create(config)
            .unwrap_or_else(|_| panic!("Failed to create device {}", i));

        if i % 10 == 0 || i < 10 {
            log::debug!(
                "Iteration {}: Created and deleting /dev/ublkb{}",
                i,
                device.dev_id
            );
        }

        // Delete immediately
        manager
            .delete(device.dev_id)
            .unwrap_or_else(|_| panic!("Failed to delete device {}", i));
    }

    let elapsed = start_time.elapsed();

    log::debug!("\n=== Summary ===");
    log::debug!("Successfully completed 100 create/delete cycles");
    log::debug!("Total time: {:.2?}", elapsed);
    log::debug!("Average time per cycle: {:.2?}\n", elapsed / 100);

    // Teardown: verify clean state after test
    common::test_utils::test_teardown().expect("Test teardown found issues - see logs above");
}