[go: up one dir, main page]

crc 1.8.1

Rust implementation of CRC(16, 32, 64) with support of various standards
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

extern crate crc;

mod crc16 {
    use crc::{crc16, Hasher16};

    const X25_CHECK_VALUE: u16 = 0x906e;
    const USB_CHECK_VALUE: u16 = 0xb4c8;

    #[test]
    fn checksum_x25() {
        assert_eq!(crc16::checksum_x25(b"123456789"), X25_CHECK_VALUE)
    }

    #[test]
    fn checksum_usb() {
        assert_eq!(crc16::checksum_usb(b"123456789"), USB_CHECK_VALUE)
    }

    #[test]
    fn digest_x25() {
        verify_checksum(crc16::X25, X25_CHECK_VALUE);
    }

    #[test]
    fn digest_usb() {
        verify_checksum(crc16::USB, USB_CHECK_VALUE);
    }

    fn verify_checksum(poly: u16, check_value: u16) {
        let mut digest = crc16::Digest::new(poly);
        digest.write(b"123456789");
        assert_eq!(digest.sum16(), check_value);
        digest.reset();
        for i in 1..10 {
            digest.write(i.to_string().as_bytes());
        }
        assert_eq!(digest.sum16(), check_value);
    }
}

mod crc32 {
    use crc::{crc32, Hasher32};

    const CASTAGNOLI_CHECK_VALUE: u32 = 0xe3069283;
    const IEEE_CHECK_VALUE: u32 = 0xcbf43926;
    const KOOPMAN_CHECK_VALUE: u32 = 0x2d3dd0ae;

    #[test]
    fn checksum_castagnoli() {
        assert_eq!(crc32::checksum_castagnoli(b"123456789"), CASTAGNOLI_CHECK_VALUE)
    }

    #[test]
    fn checksum_ieee() {
        assert_eq!(crc32::checksum_ieee(b"123456789"), IEEE_CHECK_VALUE)
    }

    #[test]
    fn checksum_koopman() {
        assert_eq!(crc32::checksum_koopman(b"123456789"), KOOPMAN_CHECK_VALUE)
    }

    #[test]
    fn digest_castagnoli() {
        verify_checksum(crc32::CASTAGNOLI, CASTAGNOLI_CHECK_VALUE);
    }

    #[test]
    fn digest_ieee() {
        verify_checksum(crc32::IEEE, IEEE_CHECK_VALUE);
    }

    #[test]
    fn digest_koopman() {
        verify_checksum(crc32::KOOPMAN, KOOPMAN_CHECK_VALUE);
    }

    fn verify_checksum(poly: u32, check_value: u32) {
        let mut digest = crc32::Digest::new(poly);
        digest.write(b"123456789");
        assert_eq!(digest.sum32(), check_value);
        digest.reset();
        for i in 1..10 {
            digest.write(i.to_string().as_bytes());
        }
        assert_eq!(digest.sum32(), check_value);
    }
}

mod crc64 {
    use crc::{crc64, Hasher64};

    const ECMA_CHECK_VALUE: u64 = 0x995dc9bbdf1939fa;
    const ISO_CHECK_VALUE: u64 = 0xb90956c775a41001;

    #[test]
    fn checksum_ecma() {
        assert_eq!(crc64::checksum_ecma(b"123456789"), ECMA_CHECK_VALUE)
    }

    #[test]
    fn checksum_iso() {
        assert_eq!(crc64::checksum_iso(b"123456789"), ISO_CHECK_VALUE)
    }

    #[test]
    fn digest_ecma() {
        verify_checksum(crc64::ECMA, ECMA_CHECK_VALUE);
    }

    #[test]
    fn digest_iso() {
        verify_checksum(crc64::ISO, ISO_CHECK_VALUE);
    }

    fn verify_checksum(poly: u64, check_value: u64) {
        let mut digest = crc64::Digest::new(poly);
        digest.write(b"123456789");
        assert_eq!(digest.sum64(), check_value);
        digest.reset();
        for i in 1..10 {
            digest.write(i.to_string().as_bytes());
        }
        assert_eq!(digest.sum64(), check_value);
    }
}