intspector 1.1.1

A command line integer conversion utility.
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
131
132
133
134
135
136
137
138
139
140
141

use intspector::min_bits;
use intspector::bin_string;
use intspector::twos_complement;
use intspector::parse_int;

#[test]
fn min_bits_pos_input() {
    assert_eq!(min_bits(0), 1);
    assert_eq!(min_bits(1), 1);
    assert_eq!(min_bits(2), 2);
    assert_eq!(min_bits(3), 2);
    assert_eq!(min_bits(4), 3);
    assert_eq!(min_bits(5), 3);
    assert_eq!(min_bits(254), 8);
    assert_eq!(min_bits(255), 8);
    assert_eq!(min_bits(256), 9);
    assert_eq!(min_bits(257), 9);
}

#[test]
fn min_bits_neg_input() {
    assert_eq!(min_bits(-1), 1);
    assert_eq!(min_bits(-2), 2);
    assert_eq!(min_bits(-3), 3);
    assert_eq!(min_bits(-4), 3);
    assert_eq!(min_bits(-5), 4);
    assert_eq!(min_bits(-127), 8);
    assert_eq!(min_bits(-128), 8);
    assert_eq!(min_bits(-129), 9);
    assert_eq!(min_bits(-130), 9);
}

#[test]
fn twos_complement_3bit() {
    assert_eq!(twos_complement(0, 3), 0);
    assert_eq!(twos_complement(1, 3), 7);
    assert_eq!(twos_complement(2, 3), 6);
    assert_eq!(twos_complement(3, 3), 5);
    assert_eq!(twos_complement(4, 3), 4);
    assert_eq!(twos_complement(5, 3), 3);
    assert_eq!(twos_complement(6, 3), 2);
    assert_eq!(twos_complement(7, 3), 1);
}

#[test]
fn twos_complement_64bit() {
    assert_eq!(twos_complement(0, 64), 0);
    assert_eq!(twos_complement(1, 64), 0xFFFFFFFFFFFFFFFF);
    assert_eq!(twos_complement(2, 64), 0xFFFFFFFFFFFFFFFE);
    assert_eq!(twos_complement(0xFFFFFFFFFFFFFFFF, 64), 1);
    assert_eq!(twos_complement(0xFFFFFFFFFFFFFFFE, 64), 2);
}

#[test]
fn bin_string_0b() {
    assert_eq!(bin_string(0, 0), "");
    assert_eq!(bin_string(1, 0), "");
}

#[test]
fn bin_string_1b() {
    assert_eq!(bin_string(0, 1), "0");
    assert_eq!(bin_string(1, 1), "1");
    assert_eq!(bin_string(2, 1), "0");
    assert_eq!(bin_string(3, 1), "1");
}

#[test]
fn bin_string_8b() {
    assert_eq!(bin_string(  0, 8), "0000_0000");
    assert_eq!(bin_string(  1, 8), "0000_0001");
    assert_eq!(bin_string(  2, 8), "0000_0010");
    assert_eq!(bin_string(  3, 8), "0000_0011");
    assert_eq!(bin_string( 15, 8), "0000_1111");
    assert_eq!(bin_string( 16, 8), "0001_0000");
    assert_eq!(bin_string(255, 8), "1111_1111");
    assert_eq!(bin_string(256, 8), "0000_0000");
}

#[test]
fn bin_string_12b() {
    assert_eq!(bin_string(  0, 12), "0000 0000_0000");
    assert_eq!(bin_string(  1, 12), "0000 0000_0001");
    assert_eq!(bin_string(255, 12), "0000 1111_1111");
    assert_eq!(bin_string(256, 12), "0001 0000_0000");
}

#[test]
fn bin_string_16b() {
    assert_eq!(bin_string(  0, 16), "0000_0000 0000_0000");
    assert_eq!(bin_string(  1, 16), "0000_0000 0000_0001");
    assert_eq!(bin_string(255, 16), "0000_0000 1111_1111");
    assert_eq!(bin_string(256, 16), "0000_0001 0000_0000");
}

#[test]
fn parse_int_no_prefix() {
    assert_eq!(parse_int("0"), Some(0));
    assert_eq!(parse_int("00"), Some(0));
    assert_eq!(parse_int("1"), Some(1));
    assert_eq!(parse_int("01"), Some(1));
    assert_eq!(parse_int("101"), Some(101));
    assert_eq!(parse_int("-101"), Some(-101));
}

#[test]
fn parse_int_binary() {
    assert_eq!(parse_int("b0"), Some(0));
    assert_eq!(parse_int("b1"), Some(1));
    assert_eq!(parse_int("b01"), Some(1));
    assert_eq!(parse_int("b101"), Some(5));
    assert_eq!(parse_int("0b101"), Some(5));
}

#[test]
fn parse_int_octal() {
    assert_eq!(parse_int("o0"), Some(0));
    assert_eq!(parse_int("o1"), Some(1));
    assert_eq!(parse_int("o01"), Some(1));
    assert_eq!(parse_int("o101"), Some(65));
    assert_eq!(parse_int("0o101"), Some(65));
}

#[test]
fn parse_int_decimal() {
    assert_eq!(parse_int("d0"), Some(0));
    assert_eq!(parse_int("d1"), Some(1));
    assert_eq!(parse_int("d01"), Some(1));
    assert_eq!(parse_int("d101"), Some(101));
    assert_eq!(parse_int("0d101"), Some(101));
}

#[test]
fn parse_int_hex() {
    assert_eq!(parse_int("x0"), Some(0));
    assert_eq!(parse_int("x1"), Some(1));
    assert_eq!(parse_int("x01"), Some(1));
    assert_eq!(parse_int("x101"), Some(257));
    assert_eq!(parse_int("0x101"), Some(257));
}