typhoon-protocol 0.1.0

A sample implementation of TYPHOON protocol
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

use crate::bytes::utils::{allocate_ptr, copy_nonoverlapping, free_ptr, preserve_vector};

pub fn copy_ptr(ptr: *mut u8, length: usize) -> *mut u8 {
    let new_ptr = allocate_ptr(length);
    unsafe {
        copy_nonoverlapping(ptr, new_ptr, length);
    }
    new_ptr
}

// Test: allocate_ptr returns zeroed memory.
#[test]
fn test_allocate_ptr() {
    let ptr = allocate_ptr(100);
    assert!(!ptr.is_null());

    unsafe {
        for i in 0..100 {
            assert_eq!(*ptr.add(i), 0);
        }
    }

    free_ptr(ptr, 100);
}

// Test: copy_ptr creates independent copy.
#[test]
fn test_copy_ptr() {
    let src = allocate_ptr(10);
    unsafe {
        for i in 0..10 {
            *src.add(i) = i as u8;
        }
    }

    let dst = copy_ptr(src, 10);
    assert!(!dst.is_null());
    assert_ne!(src, dst);

    unsafe {
        for i in 0..10 {
            assert_eq!(*dst.add(i), i as u8);
        }
    }

    free_ptr(src, 10);
    free_ptr(dst, 10);
}

// Test: preserve_vector converts Vec to raw pointer.
#[test]
fn test_preserve_vector() {
    let vec = vec![1u8, 2, 3, 4, 5];
    let ptr = preserve_vector(vec);

    unsafe {
        assert_eq!(*ptr, 1);
        assert_eq!(*ptr.add(4), 5);
    }

    free_ptr(ptr, 5);
}

// Test: free_ptr deallocates memory without crash.
#[test]
fn test_free_ptr() {
    let ptr = allocate_ptr(1000);
    free_ptr(ptr, 1000);
}