vendor/dlmalloc/tests/smoke.rs

   1 extern crate dlmalloc;
   2 extern crate rand;
   3
   4 use dlmalloc::Dlmalloc;
   5 use rand::Rng;
   6 use std::cmp;
   7
   8 #[test]
   9 fn smoke() {
  10     let mut a = Dlmalloc::new();
  11     unsafe {
  12         let ptr = a.malloc(1, 1);
  13         assert!(!ptr.is_null());
  14         *ptr = 9;
  15         assert_eq!(*ptr, 9);
  16         a.free(ptr, 1, 1);
  17
  18         let ptr = a.malloc(1, 1);
  19         assert!(!ptr.is_null());
  20         *ptr = 10;
  21         assert_eq!(*ptr, 10);
  22         a.free(ptr, 1, 1);
  23     }
  24 }
  25
  26 #[test]
  27 fn stress() {
  28     let mut a = Dlmalloc::new();
  29     let mut rng = rand::thread_rng();
  30     let mut ptrs = Vec::new();
  31     let max = if cfg!(test_lots) { 1_000_000 } else { 1_000 };
  32     unsafe {
  33         for _ in 0..max {
  34             let free =
  35                 ptrs.len() > 0 && ((ptrs.len() < 10_000 && rng.gen_weighted_bool(3)) || rng.gen());
  36             if free {
  37                 let idx = rng.gen_range(0, ptrs.len());
  38                 let (ptr, size, align) = ptrs.swap_remove(idx);
  39                 a.free(ptr, size, align);
  40                 continue;
  41             }
  42
  43             if ptrs.len() > 0 && rng.gen_weighted_bool(100) {
  44                 let idx = rng.gen_range(0, ptrs.len());
  45                 let (ptr, size, align) = ptrs.swap_remove(idx);
  46                 let new_size = if rng.gen() {
  47                     rng.gen_range(size, size * 2)
  48                 } else if size > 10 {
  49                     rng.gen_range(size / 2, size)
  50                 } else {
  51                     continue;
  52                 };
  53                 let mut tmp = Vec::new();
  54                 for i in 0..cmp::min(size, new_size) {
  55                     tmp.push(*ptr.offset(i as isize));
  56                 }
  57                 let ptr = a.realloc(ptr, size, align, new_size);
  58                 assert!(!ptr.is_null());
  59                 for (i, byte) in tmp.iter().enumerate() {
  60                     assert_eq!(*byte, *ptr.offset(i as isize));
  61                 }
  62                 ptrs.push((ptr, new_size, align));
  63             }
  64
  65             let size = if rng.gen() {
  66                 rng.gen_range(1, 128)
  67             } else {
  68                 rng.gen_range(1, 128 * 1024)
  69             };
  70             let align = if rng.gen_weighted_bool(10) {
  71                 1 << rng.gen_range(3, 8)
  72             } else {
  73                 8
  74             };
  75
  76             let zero = rng.gen_weighted_bool(50);
  77             let ptr = if zero {
  78                 a.calloc(size, align)
  79             } else {
  80                 a.malloc(size, align)
  81             };
  82             for i in 0..size {
  83                 if zero {
  84                     assert_eq!(*ptr.offset(i as isize), 0);
  85                 }
  86                 *ptr.offset(i as isize) = 0xce;
  87             }
  88             ptrs.push((ptr, size, align));
  89         }
  90     }
  91 }