lib/util/tests/test_sys_rw.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *
   4  *  Unit test for sys_rw.c
   5  *
   6  *  Copyright (C) Ralph Böhme 2021
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 3 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22 #include <stdarg.h>
  23 #include <stddef.h>
  24 #include <stdint.h>
  25 #include <setjmp.h>
  26 #include <cmocka.h>
  27
  28 #include "lib/replace/replace.h"
  29 #include "system/dir.h"
  30
  31 #include "lib/util/sys_rw.c"
  32
  33 static void test_sys_io_ranges_overlap(void **state)
  34 {
  35         bool overlap;
  36
  37         /*
  38          * sys_io_ranges_overlap() args are:
  39          *
  40          * src size, src offset, dst size, dst offset
  41          */
  42
  43         /* src and dst size 0 => no overlap */
  44         overlap = sys_io_ranges_overlap(0, 0, 0, 0);
  45         assert_false(overlap);
  46
  47         /* dst size 0 => no overlap */
  48         overlap = sys_io_ranges_overlap(1, 0, 0, 0);
  49         assert_false(overlap);
  50
  51         /* src size 0 => no overlap */
  52         overlap = sys_io_ranges_overlap(0, 0, 1, 0);
  53         assert_false(overlap);
  54
  55         /* same range => overlap */
  56         overlap = sys_io_ranges_overlap(1, 0, 1, 0);
  57         assert_true(overlap);
  58
  59         /*
  60          * |.|
  61          *   |.|
  62          * src before dst => no overlap
  63          */
  64         overlap = sys_io_ranges_overlap(1, 0, 1, 1);
  65         assert_false(overlap);
  66
  67         /*
  68          * |..|
  69          *  |..|
  70          * src into dst => overlap
  71          */
  72         overlap = sys_io_ranges_overlap(2, 0, 2, 1);
  73         assert_true(overlap);
  74
  75         /*
  76          * |....|
  77          *  |..|
  78          * src encompasses dst => overlap
  79          */
  80         overlap = sys_io_ranges_overlap(4, 0, 1, 2);
  81         assert_true(overlap);
  82
  83
  84         /*
  85          *  |..|
  86          * |..|
  87          * dst into src => overlap
  88          */
  89         overlap = sys_io_ranges_overlap(2, 1, 2, 0);
  90         assert_true(overlap);
  91
  92         /*
  93          *  |..|
  94          * |....|
  95          * dst encompasses src => overlap
  96          */
  97         overlap = sys_io_ranges_overlap(2, 1, 4, 0);
  98         assert_true(overlap);
  99 }
 100
 101 static void test_sys_block_align(void **state)
 102 {
 103         int asize;
 104
 105         asize = sys_block_align(0, 2);
 106         assert_int_equal(asize, 0);
 107         asize = sys_block_align(1, 2);
 108         assert_int_equal(asize, 2);
 109         asize = sys_block_align(2, 2);
 110         assert_int_equal(asize, 2);
 111         asize = sys_block_align(3, 2);
 112         assert_int_equal(asize, 4);
 113
 114         asize = sys_block_align(0, 4);
 115         assert_int_equal(asize, 0);
 116         asize = sys_block_align(1, 4);
 117         assert_int_equal(asize, 4);
 118         asize = sys_block_align(3, 4);
 119         assert_int_equal(asize, 4);
 120         asize = sys_block_align(4, 4);
 121         assert_int_equal(asize, 4);
 122         asize = sys_block_align(5, 4);
 123         assert_int_equal(asize, 8);
 124         asize = sys_block_align(7, 4);
 125         assert_int_equal(asize, 8);
 126         asize = sys_block_align(8, 4);
 127         assert_int_equal(asize, 8);
 128         asize = sys_block_align(9, 4);
 129         assert_int_equal(asize, 12);
 130 }
 131
 132 static void test_sys_block_align_truncate(void **state)
 133 {
 134         int asize;
 135
 136         asize = sys_block_align_truncate(0, 2);
 137         assert_int_equal(asize, 0);
 138         asize = sys_block_align_truncate(1, 2);
 139         assert_int_equal(asize, 0);
 140         asize = sys_block_align_truncate(2, 2);
 141         assert_int_equal(asize, 2);
 142         asize = sys_block_align_truncate(3, 2);
 143         assert_int_equal(asize, 2);
 144         asize = sys_block_align_truncate(4, 2);
 145         assert_int_equal(asize, 4);
 146         asize = sys_block_align_truncate(5, 2);
 147         assert_int_equal(asize, 4);
 148
 149         asize = sys_block_align_truncate(0, 4);
 150         assert_int_equal(asize, 0);
 151         asize = sys_block_align_truncate(1, 4);
 152         assert_int_equal(asize, 0);
 153         asize = sys_block_align_truncate(3, 4);
 154         assert_int_equal(asize, 0);
 155         asize = sys_block_align_truncate(4, 4);
 156         assert_int_equal(asize, 4);
 157         asize = sys_block_align_truncate(5, 4);
 158         assert_int_equal(asize, 4);
 159         asize = sys_block_align_truncate(7, 4);
 160         assert_int_equal(asize, 4);
 161         asize = sys_block_align_truncate(8, 4);
 162         assert_int_equal(asize, 8);
 163         asize = sys_block_align_truncate(9, 4);
 164         assert_int_equal(asize, 8);
 165 }
 166
 167 int main(int argc, char **argv)
 168 {
 169         const struct CMUnitTest tests[] = {
 170                 cmocka_unit_test(test_sys_io_ranges_overlap),
 171                 cmocka_unit_test(test_sys_block_align),
 172                 cmocka_unit_test(test_sys_block_align_truncate),
 173         };
 174
 175         cmocka_set_message_output(CM_OUTPUT_SUBUNIT);
 176
 177         return cmocka_run_group_tests(tests, NULL, NULL);
 178 }