rust_dense_bitset/
lib.rs

1#![allow(clippy::suspicious_op_assign_impl)]
2#![allow(clippy::unreadable_literal)]
3
4mod bitset;
5mod u64impl;
6mod vec64impl;
7
8pub use crate::bitset::BitSet;
9pub use crate::u64impl::DenseBitSet;
10pub use crate::vec64impl::DenseBitSetExtended;
11
12#[cfg(test)]
13mod tests {
14    use super::*;
15
16    // Tests for data initialization methods
17    // dbs : from_integer, from_string
18    // dbse : from_dense_bitset, from_string
19    //
20    // Test of functionality (The method is doing what is expected)
21    // Test of panic cases
22
23    #[test]
24    fn test_from_integer_dbs() {
25        let mut bs1 = DenseBitSet::from_integer(2047);
26        bs1.set_bit(11, true);
27        assert_eq!(bs1.to_integer(), 4095);
28    }
29
30    #[test]
31    fn test_from_dense_bitset_dbse() {
32        let bs1 = DenseBitSet::from_integer(2048);
33        let mut bs2 = DenseBitSetExtended::from_dense_bitset(bs1);
34        bs2.set_bit(70, true);
35        assert_eq!(bs2.get_weight(), 2);
36        assert_eq!(bs2.get_size(), 71);
37        assert!(bs2.get_bit(11));
38    }
39
40    #[test]
41    fn test_from_string_dbs() {
42        let bs1 = DenseBitSet::from_string("101110001", 2);
43        let bs2 = DenseBitSet::from_string("FFFFF", 16);
44        let bs3 = DenseBitSet::from_string("123465", 10);
45
46        assert_eq!(bs1.to_integer(), 0b101110001);
47        assert_eq!(bs2.to_integer(), 0xfffff);
48        assert_eq!(bs3.to_integer(), 123465);
49    }
50
51    #[test]
52    fn test_from_string_dbse() {
53        let val = "11111000110101010010000101011010010100101011010101111110101000001010111010110010100101001010111101010111011010100000101011101011";
54        let bs1 = DenseBitSetExtended::from_string(String::from(val), 2);
55        assert_eq!(bs1.to_string(), val);
56
57        let bs2 =
58            DenseBitSetExtended::from_string(String::from("f8d5215a52b57ea0aeb294af576a0aeb"), 16);
59        assert_eq!(bs2.to_string(), val);
60    }
61
62    // Panics if the string contains a char that
63    // can't be converted to an integer value in the specified base
64
65    #[test]
66    #[should_panic]
67    fn catch_invalid_string_dbs_incorrect_char() {
68        let _bs = DenseBitSet::from_string("Hello World!", 12);
69    }
70
71    #[test]
72    #[should_panic]
73    fn catch_invalid_string_dbse_incorrect_char() {
74        let _bs = DenseBitSetExtended::from_string(String::from("Hello World!"), 12);
75    }
76
77    // Panics if the radix is > 32
78
79    #[test]
80    #[should_panic]
81    fn catch_invalid_string_dbs_incorrect_radix() {
82        let _bs = DenseBitSet::from_string("1234", 33);
83    }
84
85    #[test]
86    #[should_panic]
87    fn catch_invalid_string_dbse_incorrect_radix() {
88        let _bs = DenseBitSetExtended::from_string(String::from("1234"), 33);
89    }
90
91    // Panics if radix is < 2
92
93    #[test]
94    #[should_panic]
95    fn catch_invalid_string_dbs_incorrect_radix2() {
96        let _bs = DenseBitSet::from_string("0000", 1);
97    }
98
99    #[test]
100    #[should_panic]
101    fn catch_invalid_string_dbse_incorrect_radix2() {
102        let _bs = DenseBitSetExtended::from_string(String::from("0000"), 1);
103    }
104
105    // Tests for information data
106    // generic : any, all, none, first_set
107    // dbse : get_size
108
109    #[test]
110    fn test_all_dbs() {
111        let mut bs = DenseBitSet::from_integer(u64::max_value());
112        assert_eq!(bs.all(), true);
113        bs.set_bit(3, false);
114        assert_eq!(bs.all(), false);
115    }
116
117    #[test]
118    fn test_all_dbse() {
119        let mut bs =
120            DenseBitSetExtended::from_string(String::from("fffffffffffffffffffffffffffff"), 16);
121        assert!(bs.all());
122        bs.set_bit(28, false);
123        assert!(!bs.all());
124    }
125
126    #[test]
127    fn test_any_dbs() {
128        let mut bs = DenseBitSet::from_integer(1234567890);
129        assert_eq!(bs.any(), true);
130        bs.reset();
131        assert_eq!(bs.any(), false);
132    }
133
134    #[test]
135    fn test_any_dbse() {
136        let mut bs = DenseBitSetExtended::with_capacity(10);
137        bs.set_bit(1234, true);
138        assert_eq!(bs.any(), true);
139        bs.reset();
140        assert_eq!(bs.any(), false);
141    }
142
143    #[test]
144    fn test_none_dbs() {
145        let mut bs = DenseBitSet::from_integer(0);
146        assert_eq!(bs.none(), true);
147        bs.set_bit(3, true);
148        assert_eq!(bs.none(), false);
149    }
150
151    #[test]
152    fn test_none_dbse() {
153        let mut bs = DenseBitSetExtended::with_capacity(10);
154        bs.set_bit(1234, true);
155        bs.set_bit(1234, false);
156        assert_eq!(bs.none(), true);
157        bs.set_bit(1235, true);
158        assert_eq!(bs.none(), false);
159    }
160
161    #[test]
162    fn test_get_size_dbse() {
163        let mut bs = DenseBitSetExtended::from_string(String::from("deadbeef"), 16);
164        assert_eq!(bs.get_size(), 32);
165        bs.set_bit(8975, false);
166        assert_eq!(bs.get_size(), 8976);
167    }
168
169    #[test]
170    fn test_first_set_dbs() {
171        let dbs = DenseBitSet::from_integer(256);
172        assert_eq!(8, dbs.first_set());
173    }
174
175    #[test]
176    fn test_first_set_dbse() {
177        let dbs = DenseBitSetExtended::from_dense_bitset(DenseBitSet::from_integer(256)) << 223;
178        assert_eq!(231, dbs.first_set());
179    }
180
181    // Tests for set manipulations
182    // generic : reverse, rotr, rotl
183    // dbs: insert, extract
184    // dbse: insert(set), subset, insert_u64, extract_u64
185
186    #[test]
187    fn test_rotr_dbs() {
188        let mut bs = DenseBitSet::from_integer(0b0001110101);
189        let bs_cp = bs;
190        bs.rotr(40);
191        assert_eq!(bs.to_integer(), 0b1110101000000000000000000000000);
192        bs.rotr(24);
193        assert_eq!(bs, bs_cp);
194    }
195
196    #[test]
197    fn test_rotl_dbs() {
198        let mut bs = DenseBitSet::from_integer(0b0001110101);
199        let bs_cp = bs;
200        bs.rotl(10);
201        assert_eq!(bs.to_integer(), 0b11101010000000000);
202        bs.rotl(54);
203        assert_eq!(bs, bs_cp);
204    }
205
206    #[test]
207    fn test_rotr_dbse() {
208        let bs = DenseBitSet::from_integer(0b11110001);
209        let mut bs2 = DenseBitSetExtended::from_dense_bitset(bs);
210        let bs_cp = bs2.clone();
211        bs2 = bs2.rotr(40);
212        bs2 = bs2.rotr(24);
213        assert_eq!(bs2, bs_cp);
214    }
215
216    #[test]
217    fn test_rotl_dbse() {
218        let bs = DenseBitSet::from_integer(0b11110001);
219        let mut bs2 = DenseBitSetExtended::from_dense_bitset(bs);
220        let bs_cp = bs2.clone();
221        bs2 = bs2.rotl(40);
222        bs2 = bs2.rotl(24);
223        assert_eq!(bs2, bs_cp);
224    }
225
226    #[test]
227    fn test_reverse_dbs() {
228        let bs = DenseBitSet::from_integer(666123);
229        let srev = bs.to_string().chars().rev().collect::<String>();
230        assert_eq!(srev, bs.reverse().to_string());
231    }
232
233    #[test]
234    fn test_reverse_dbse() {
235        let bs = DenseBitSetExtended::from_dense_bitset(DenseBitSet::from_integer(666123)) >> 63;
236        let rs = bs.reverse();
237        let srev = bs.to_string().chars().rev().collect::<String>();
238        assert_eq!(srev, rs.to_string());
239    }
240
241    // Tests for extract and insert on dbs
242
243    #[test]
244    fn no_crash_on_insertion_dbs() {
245        let mut bs = DenseBitSet::from_integer(0);
246        for i in 0..63 {
247            bs.set_bit(i, true);
248        }
249    }
250
251    #[test]
252    fn no_crash_on_insertion_dbse() {
253        let mut bs = DenseBitSetExtended::with_capacity(10);
254        for i in 0..1024 {
255            bs.set_bit(i, true);
256        }
257    }
258
259    #[test]
260    fn no_crash_on_read_dbs() {
261        let bs = DenseBitSet::from_integer(1234567890);
262        let mut hw = 0;
263        for i in 0..64 {
264            hw += if bs.get_bit(i) { 1 } else { 0 };
265        }
266        assert_eq!(hw, 12, "Error: mismatch between expected and read bits.");
267    }
268
269    #[test]
270    #[should_panic]
271    fn catch_get_overflow_dbs() {
272        let bs = DenseBitSet::from_integer(1234567890);
273        let _r = bs.get_bit(64); // Should panic: bit #64 is out of bounds
274    }
275
276    #[test]
277    #[should_panic]
278    fn catch_set_overflow_dbs() {
279        let mut bs = DenseBitSet::from_integer(1234567890);
280        bs.set_bit(64, true); // Should panic: bit #64 is out of bounds
281    }
282
283    #[test]
284    fn read_write_test_dbs() {
285        let mut bs1 = DenseBitSet::from_integer(1234567890);
286        let mut bs2 = DenseBitSet::from_integer(0);
287
288        for i in 0..64 {
289            bs2.set_bit(i, bs1.get_bit(i));
290            bs1.set_bit(i, false);
291        }
292        assert_eq!(bs1.to_integer(), 0);
293        assert_eq!(bs2.to_integer(), 1234567890);
294    }
295
296    #[test]
297    fn full_extract_dbs() {
298        let bs = DenseBitSet::from_integer(1234567890);
299        assert_eq!(bs.extract(0, 64), 1234567890);
300    }
301
302    #[test]
303    fn partial_extracts_dbs() {
304        let bs = DenseBitSet::from_integer(1234567890);
305        let e1 = bs.extract(1, 63);
306        let e2 = bs.extract(0, 8);
307        let e3 = bs.extract(5, 14);
308
309        assert_eq!(e1, 617283945);
310        assert_eq!(e2, 210);
311        assert_eq!(e3, 12310);
312    }
313
314    #[test]
315    #[should_panic]
316    fn catch_extract_zero_width_dbs() {
317        let bs = DenseBitSet::from_integer(1234567890);
318        let _r = bs.extract(12, 0); // Should panic: 0 is passed as 2nd argument
319    }
320
321    #[test]
322    #[should_panic]
323    fn catch_extract_overflow_dbs() {
324        let bs = DenseBitSet::from_integer(1234567890);
325        let _r = bs.extract(12, 55); // Should panic: 12+55 exceeds the 64 bit boundary
326    }
327
328    #[test]
329    fn full_insert_dbs() {
330        let mut bs = DenseBitSet::from_integer(1234567890);
331        bs.insert(0, 64, 9876);
332        assert_eq!(bs.to_integer(), 9876);
333    }
334
335    #[test]
336    fn partial_insert_dbs() {
337        let mut bs = DenseBitSet::from_integer(0b11101101010100011001);
338        bs.insert(12, 2, 0b10);
339        assert_eq!(bs.to_integer(), 0b11101110010100011001)
340    }
341
342    #[test]
343    #[should_panic]
344    fn catch_insert_zero_width_dbs() {
345        let mut bs = DenseBitSet::from_integer(1234567890);
346        bs.insert(0, 0, 12); // Should panic: 0 is passed as 2nd argument
347    }
348
349    #[test]
350    #[should_panic]
351    fn catch_insert_overflow_dbs() {
352        let mut bs = DenseBitSet::from_integer(1234567890);
353        bs.insert(12, 55, 79885); // Should panic: 12+55 exceeds the 64 bit boundary
354    }
355
356    // Tests for insert and extract functions for dbse
357
358    #[test]
359    fn test_extract_u64_dbse() {
360        let offset = 140;
361        let bs =
362            DenseBitSetExtended::from_dense_bitset(DenseBitSet::from_integer(1234567890)) << offset;
363        let e1 = bs.extract_u64(1 + offset, 63);
364        let e2 = bs.extract_u64(0 + offset, 8);
365        let e3 = bs.extract_u64(5 + offset, 14);
366
367        assert_eq!(e1, 617283945);
368        assert_eq!(e2, 210);
369        assert_eq!(e3, 12310);
370    }
371
372    #[test]
373    #[should_panic]
374    fn catch_extract_u64_zero_width_dbse() {
375        let bs = DenseBitSetExtended::new();
376        let _r = bs.extract_u64(12, 0); // Should panic: 0 is passed as 2nd argument
377    }
378
379    #[test]
380    #[should_panic]
381    fn catch_extract_u64_overflow_dbse() {
382        let bs = DenseBitSetExtended::from_dense_bitset(DenseBitSet::from_integer(1234567890));
383        let _r = bs.extract_u64(12, 75); // Should panic: 12+75 exceeds the 64 bit size limit
384    }
385
386    #[test]
387    fn test_subset_dbse() {
388        let bs = DenseBitSetExtended::from_dense_bitset(DenseBitSet::from_integer(1234567890));
389        let e1 = bs.subset(0, 12);
390        let e2 = bs.subset(4, 128).subset(0, 4);
391
392        assert_eq!(
393            e1.to_string(),
394            "0000000000000000000000000000000000000000000000000000001011010010"
395        );
396        assert_eq!(
397            e2.to_string(),
398            "0000000000000000000000000000000000000000000000000000000000001101"
399        );
400    }
401
402    #[test]
403    fn test_insert_u64_dbse() {
404        let mut bs = DenseBitSetExtended::new();
405        bs.insert_u64(0b1011011101111, 50, 64);
406
407        assert_eq!(bs.to_string(), "00000000000000000000000000000000000000000000000000000000000000000101101110111100000000000000000000000000000000000000000000000000");
408    }
409
410    #[test]
411    fn test_insert_dbse() {
412        let mut bs = DenseBitSetExtended::new();
413        let bs2 =
414            DenseBitSetExtended::from_dense_bitset(DenseBitSet::from_integer(0b1011011101111));
415        bs.insert(&bs2, 60, 13);
416
417        assert_eq!(bs.to_string(), "00000000000000000000000000000000000000000000000000000001011011101111000000000000000000000000000000000000000000000000000000000000");
418    }
419
420    // Tests for `BitSet` trait methods implementations
421    // generic : set_bit, get_bit, get_weight, reset, to_string
422
423    #[test]
424    fn test_reset_dbs() {
425        let mut bs = DenseBitSet::from_integer(1234567890);
426        bs.reset();
427        assert_eq!(bs.to_integer(), 0);
428    }
429
430    #[test]
431    fn test_reset_dbse() {
432        let mut bs = DenseBitSetExtended::from_string(String::from("0101"), 2);
433        bs.reset();
434        assert_eq!(
435            bs.to_string(),
436            "0000000000000000000000000000000000000000000000000000000000000000"
437        );
438    }
439
440    #[test]
441    fn test_hamming_weight_dbs() {
442        let bs1 = DenseBitSet::from_integer(0);
443        let bs2 = DenseBitSet::from_integer(1234567890);
444        let bs3 = DenseBitSet::from_integer(u64::max_value());
445
446        assert_eq!(bs1.get_weight(), 0);
447        assert_eq!(bs2.get_weight(), 12);
448        assert_eq!(bs3.get_weight(), 64);
449    }
450
451    #[test]
452    fn test_hamming_weight_dbse() {
453        let bs1 = DenseBitSet::from_integer(1234567890);
454        let mut bs2 = DenseBitSetExtended::from_dense_bitset(bs1);
455
456        bs2.set_bit(78, true);
457        bs2.set_bit(289, true);
458
459        assert_eq!(bs2.get_weight(), 14);
460    }
461
462    #[test]
463    fn test_to_string_dbs() {
464        let bs1 = DenseBitSet::from_integer(7891234);
465        let bs2 = DenseBitSet::from_integer(65536);
466        assert_eq!(
467            bs1.to_string(),
468            "0000000000000000000000000000000000000000011110000110100100100010"
469        );
470        assert_eq!(
471            bs2.to_string(),
472            "0000000000000000000000000000000000000000000000010000000000000000"
473        )
474    }
475
476    #[test]
477    fn test_to_string_dbse() {
478        let mut bs1 = DenseBitSetExtended::with_capacity(100);
479        bs1.set_bit(99, true);
480        assert_eq!(bs1.to_string(), "00000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000")
481    }
482
483    // Tests for other Traits implementations
484
485    #[test]
486    fn test_equality_trait_dbs() {
487        let bs1 = DenseBitSet::from_integer(1234567890);
488        let mut bs2 = DenseBitSet::from_integer(1234567891);
489
490        bs2.set_bit(0, false); // The two bitsets are now equal
491        assert_eq!(bs1, bs2);
492    }
493
494    #[test]
495    fn test_equality_trait_dbse() {
496        let mut bs1 = DenseBitSetExtended::with_capacity(2000);
497        let mut bs2 = DenseBitSetExtended::with_capacity(2000);
498
499        bs1.set_bit(1290, true);
500        bs2.set_bit(1290, true); // The two bitsets are now equal
501        assert_eq!(bs1, bs2);
502    }
503
504    #[test]
505    fn test_bitand_dbs() {
506        let bs1 = DenseBitSet::from_integer(0b10101);
507        let bs2 = DenseBitSet::from_integer(0b11100);
508        let bs3 = bs1 & bs2;
509        assert_eq!(bs3.to_integer(), 0b10100);
510    }
511
512    #[test]
513    fn test_bitand_dbse() {
514        let mut bs1 = DenseBitSetExtended::with_capacity(10);
515        let mut bs2 = DenseBitSetExtended::with_capacity(10);
516
517        bs1.set_bit(1, true);
518        bs1.set_bit(70, true);
519        bs1.set_bit(72, true);
520        bs1.set_bit(74, true);
521        bs2.set_bit(1, true);
522        bs2.set_bit(2, true);
523        bs2.set_bit(72, true);
524        bs2.set_bit(73, true);
525        bs2.set_bit(74, true);
526
527        let bs3 = bs1 & bs2;
528        assert_eq!(bs3.to_string(), "00000000000000000000000000000000000000000000000000000101000000000000000000000000000000000000000000000000000000000000000000000010");
529    }
530
531    #[test]
532    fn test_bitand_assign_dbs() {
533        let bs1 = DenseBitSet::from_integer(0b11000);
534        let mut bs2 = DenseBitSet::from_integer(0b1001);
535        bs2 &= bs1;
536        assert_eq!(bs2.to_integer(), 0b1000);
537    }
538
539    #[test]
540    fn test_bitand_assign_dbse() {
541        let mut bs1 = DenseBitSetExtended::with_capacity(10);
542        let mut bs2 = DenseBitSetExtended::with_capacity(10);
543
544        bs1.set_bit(1, true);
545        bs1.set_bit(70, true);
546        bs1.set_bit(72, true);
547        bs1.set_bit(74, true);
548        bs2.set_bit(1, true);
549        bs2.set_bit(2, true);
550        bs2.set_bit(72, true);
551        bs2.set_bit(73, true);
552        bs2.set_bit(74, true);
553        bs2 &= bs1;
554
555        assert_eq!(bs2.to_string(), "00000000000000000000000000000000000000000000000000000101000000000000000000000000000000000000000000000000000000000000000000000010");
556    }
557
558    #[test]
559    fn test_bitor_dbs() {
560        let bs1 = DenseBitSet::from_integer(0b10101);
561        let bs2 = DenseBitSet::from_integer(0b11100);
562        let bs3 = bs1 | bs2;
563        assert_eq!(bs3.to_integer(), 0b11101);
564    }
565
566    #[test]
567    fn test_bitor_dbse() {
568        let mut bs1 = DenseBitSetExtended::with_capacity(10);
569        let mut bs2 = DenseBitSetExtended::with_capacity(10);
570
571        bs1.set_bit(1, true);
572        bs1.set_bit(70, true);
573        bs1.set_bit(72, true);
574        bs1.set_bit(74, true);
575        bs2.set_bit(1, true);
576        bs2.set_bit(2, true);
577        bs2.set_bit(72, true);
578        bs2.set_bit(73, true);
579        bs2.set_bit(74, true);
580
581        let bs3 = bs2 | bs1;
582
583        assert_eq!(bs3.to_string(), "00000000000000000000000000000000000000000000000000000111010000000000000000000000000000000000000000000000000000000000000000000110");
584    }
585
586    #[test]
587    fn test_bitor_assign_dbs() {
588        let bs1 = DenseBitSet::from_integer(0b11000);
589        let mut bs2 = DenseBitSet::from_integer(0b1001);
590        bs2 |= bs1;
591        assert_eq!(bs2.to_integer(), 0b11001);
592    }
593
594    #[test]
595    fn test_bitor_assign_dbse() {
596        let mut bs1 = DenseBitSetExtended::with_capacity(10);
597        let mut bs2 = DenseBitSetExtended::with_capacity(10);
598
599        bs1.set_bit(1, true);
600        bs1.set_bit(70, true);
601        bs1.set_bit(72, true);
602        bs1.set_bit(74, true);
603        bs2.set_bit(1, true);
604        bs2.set_bit(2, true);
605        bs2.set_bit(72, true);
606        bs2.set_bit(73, true);
607        bs2.set_bit(74, true);
608        bs2 |= bs1;
609
610        assert_eq!(bs2.to_string(), "00000000000000000000000000000000000000000000000000000111010000000000000000000000000000000000000000000000000000000000000000000110");
611    }
612
613    #[test]
614    fn test_bitxor_dbs() {
615        let bs1 = DenseBitSet::from_integer(0b10101);
616        let bs2 = DenseBitSet::from_integer(0b11100);
617        let bs3 = bs1 ^ bs2;
618        assert_eq!(bs3.to_integer(), 0b1001);
619    }
620
621    #[test]
622    fn test_bitxor_dbse() {
623        let mut bs1 = DenseBitSetExtended::with_capacity(10);
624        let mut bs2 = DenseBitSetExtended::with_capacity(10);
625
626        bs1.set_bit(1, true);
627        bs1.set_bit(70, true);
628        bs1.set_bit(72, true);
629        bs1.set_bit(74, true);
630        bs2.set_bit(1, true);
631        bs2.set_bit(2, true);
632        bs2.set_bit(72, true);
633        bs2.set_bit(73, true);
634        bs2.set_bit(74, true);
635
636        let bs3 = bs2 ^ bs1;
637
638        assert_eq!(bs3.to_string(), "00000000000000000000000000000000000000000000000000000010010000000000000000000000000000000000000000000000000000000000000000000100");
639    }
640
641    #[test]
642    fn test_bitxor_assign_dbs() {
643        let bs1 = DenseBitSet::from_integer(0b11000);
644        let mut bs2 = DenseBitSet::from_integer(0b1001);
645        bs2 ^= bs1;
646        assert_eq!(bs2.to_integer(), 0b10001);
647    }
648
649    #[test]
650    fn test_bitxor_assign_dbse() {
651        let mut bs1 = DenseBitSetExtended::with_capacity(10);
652        let mut bs2 = DenseBitSetExtended::with_capacity(10);
653
654        bs1.set_bit(1, true);
655        bs1.set_bit(70, true);
656        bs1.set_bit(72, true);
657        bs1.set_bit(74, true);
658        bs2.set_bit(1, true);
659        bs2.set_bit(2, true);
660        bs2.set_bit(72, true);
661        bs2.set_bit(73, true);
662        bs2.set_bit(74, true);
663        bs2 ^= bs1;
664
665        assert_eq!(bs2.to_string(), "00000000000000000000000000000000000000000000000000000010010000000000000000000000000000000000000000000000000000000000000000000100");
666    }
667
668    #[test]
669    fn test_not_dbs() {
670        let mut bs1 = DenseBitSet::from_integer(0b111010100011101011);
671        bs1 = !bs1;
672        assert_eq!(
673            bs1.to_integer(),
674            0b1111111111111111111111111111111111111111111111000101011100010100
675        );
676    }
677
678    #[test]
679    fn test_not_dbse() {
680        let mut bs1 = DenseBitSetExtended::from_string(String::from("ff00ff00ff00ff00"), 16);
681        bs1 = !bs1;
682        assert_eq!(
683            bs1.to_string(),
684            "0000000011111111000000001111111100000000111111110000000011111111"
685        )
686    }
687
688    #[test]
689    fn test_shl_dbs() {
690        let bs1 = DenseBitSet::from_integer(0b10101);
691        let bs2 = bs1 << 6;
692        assert_eq!(bs2.to_integer(), 0b10101000000);
693        let bs3 = bs1 << 65;
694        assert!(bs3.none());
695    }
696
697    #[test]
698    fn test_shl_dbse() {
699        let mut bs1 = DenseBitSetExtended::with_capacity(2);
700        bs1.set_bit(60, true);
701        let bs2 = bs1 << 46;
702        assert!(bs2.get_bit(106));
703    }
704
705    #[test]
706    fn test_shl_assign_dbs() {
707        let mut bs1 = DenseBitSet::from_integer(0b11000);
708        bs1 <<= 6;
709        assert_eq!(bs1.to_integer(), 0b11000000000);
710        bs1 <<= 65;
711        assert!(bs1.none());
712    }
713
714    #[test]
715    fn test_shl_assign_dbse() {
716        let mut bs1 = DenseBitSetExtended::with_capacity(2);
717        bs1.set_bit(60, true);
718        bs1 <<= 46;
719        assert!(bs1.get_bit(106));
720    }
721
722    #[test]
723    fn test_shr_dbs() {
724        let bs1 = DenseBitSet::from_integer(0b101011111111111101);
725        let bs2 = bs1 >> 6;
726        assert_eq!(bs2.to_integer(), 0b101011111111);
727        let bs3 = bs1 >> 65;
728        assert!(bs3.none());
729    }
730
731    #[test]
732    fn test_shr_dbse() {
733        let mut bs1 = DenseBitSetExtended::with_capacity(2);
734        bs1.set_bit(100, true);
735        let bs2 = bs1 >> 46;
736        assert!(bs2.get_bit(54));
737    }
738
739    #[test]
740    fn test_shr_assign_dbs() {
741        let mut bs1 = DenseBitSet::from_integer(0b1001111001101);
742        bs1 >>= 6;
743        assert_eq!(bs1.to_integer(), 0b1001111);
744        bs1 >>= 65;
745        assert!(bs1.none());
746    }
747
748    #[test]
749    fn test_shr_assign_dbse() {
750        let mut bs1 = DenseBitSetExtended::with_capacity(2);
751        bs1.set_bit(100, true);
752        bs1 >>= 46;
753        assert!(bs1.get_bit(54));
754    }
755
756    // Test for README.md source code
757
758    #[test]
759    fn test_readme() {
760        let mut bs = DenseBitSetExtended::from_string(
761            String::from("f001eddadf411eddec0de5ca1ab1ec0feefeeb1e01dc0b01"),
762            16,
763        );
764        let bs2 = DenseBitSetExtended::from_string(String::from("0J2aG5BaMRS443FEBRGS5DTMV2A"), 32);
765        bs = bs.rotr(17) | (bs2 << 43);
766        bs.set_bit(123, true);
767        println!("{}", bs.subset(3, 64).to_string());
768    }
769}
rust_dense_bitset/lib.rs

rust_dense_bitset/
lib.rs
