test/test_util.c

   1 // Copyright (C) 2010-2016 Joel Rosdahl
   2 //
   3 // This program is free software; you can redistribute it and/or modify it
   4 // under the terms of the GNU General Public License as published by the Free
   5 // Software Foundation; either version 3 of the License, or (at your option)
   6 // any later version.
   7 //
   8 // This program is distributed in the hope that it will be useful, but WITHOUT
   9 // ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10 // FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  11 // more details.
  12 //
  13 // You should have received a copy of the GNU General Public License along with
  14 // this program; if not, write to the Free Software Foundation, Inc., 51
  15 // Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  16
  17 // This file contains tests for functions in util.c.
  18
  19 #include "../ccache.h"
  20 #include "framework.h"
  21
  22 TEST_SUITE(util)
  23
  24 TEST(basename)
  25 {
  26         CHECK_STR_EQ_FREE2("foo.c", basename("foo.c"));
  27         CHECK_STR_EQ_FREE2("foo.c", basename("dir1/dir2/foo.c"));
  28         CHECK_STR_EQ_FREE2("foo.c", basename("/dir/foo.c"));
  29         CHECK_STR_EQ_FREE2("", basename("dir1/dir2/"));
  30 }
  31
  32 TEST(dirname)
  33 {
  34         CHECK_STR_EQ_FREE2(".", dirname("foo.c"));
  35         CHECK_STR_EQ_FREE2(".", dirname(""));
  36         CHECK_STR_EQ_FREE2("/", dirname("/"));
  37         CHECK_STR_EQ_FREE2("/", dirname("/foo.c"));
  38         CHECK_STR_EQ_FREE2("dir1/dir2", dirname("dir1/dir2/foo.c"));
  39         CHECK_STR_EQ_FREE2("/dir", dirname("/dir/foo.c"));
  40         CHECK_STR_EQ_FREE2("dir1/dir2", dirname("dir1/dir2/"));
  41 }
  42
  43 TEST(common_dir_prefix_length)
  44 {
  45         CHECK_INT_EQ(0, common_dir_prefix_length("", ""));
  46         CHECK_INT_EQ(0, common_dir_prefix_length("/", "/"));
  47         CHECK_INT_EQ(0, common_dir_prefix_length("/", "/b"));
  48         CHECK_INT_EQ(0, common_dir_prefix_length("/a", "/b"));
  49         CHECK_INT_EQ(2, common_dir_prefix_length("/a", "/a"));
  50         CHECK_INT_EQ(2, common_dir_prefix_length("/a", "/a/b"));
  51         CHECK_INT_EQ(2, common_dir_prefix_length("/a/b", "/a/c"));
  52         CHECK_INT_EQ(4, common_dir_prefix_length("/a/b", "/a/b"));
  53         CHECK_INT_EQ(2, common_dir_prefix_length("/a/bc", "/a/b"));
  54         CHECK_INT_EQ(2, common_dir_prefix_length("/a/b", "/a/bc"));
  55 }
  56
  57 TEST(get_relative_path)
  58 {
  59 #ifdef _WIN32
  60         CHECK_STR_EQ_FREE2("a", get_relative_path("C:/doesn't matter", "a"));
  61         CHECK_STR_EQ_FREE2("a/b", get_relative_path("C:/doesn't matter", "a/b"));
  62         CHECK_STR_EQ_FREE2(".", get_relative_path("C:/a", "C:/a"));
  63         CHECK_STR_EQ_FREE2("..", get_relative_path("C:/a/b", "C:/a"));
  64         CHECK_STR_EQ_FREE2("b", get_relative_path("C:/a", "C:/a/b"));
  65         CHECK_STR_EQ_FREE2("b/c", get_relative_path("C:/a", "C:/a/b/c"));
  66         CHECK_STR_EQ_FREE2("../c", get_relative_path("C:/a/b", "C:/a/c"));
  67         CHECK_STR_EQ_FREE2("../c/d", get_relative_path("C:/a/b", "C:/a/c/d"));
  68         CHECK_STR_EQ_FREE2("../../c/d", get_relative_path("C:/a/b/c", "C:/a/c/d"));
  69         CHECK_STR_EQ_FREE2("../..", get_relative_path("C:/a/b", "C:/"));
  70         CHECK_STR_EQ_FREE2("../../c", get_relative_path("C:/a/b", "C:/c"));
  71         CHECK_STR_EQ_FREE2("a/b", get_relative_path("C:/", "C:/a/b"));
  72 #else
  73         CHECK_STR_EQ_FREE2("a", get_relative_path("/doesn't matter", "a"));
  74         CHECK_STR_EQ_FREE2("a/b", get_relative_path("/doesn't matter", "a/b"));
  75         CHECK_STR_EQ_FREE2(".", get_relative_path("/a", "/a"));
  76         CHECK_STR_EQ_FREE2("..", get_relative_path("/a/b", "/a"));
  77         CHECK_STR_EQ_FREE2("b", get_relative_path("/a", "/a/b"));
  78         CHECK_STR_EQ_FREE2("b/c", get_relative_path("/a", "/a/b/c"));
  79         CHECK_STR_EQ_FREE2("../c", get_relative_path("/a/b", "/a/c"));
  80         CHECK_STR_EQ_FREE2("../c/d", get_relative_path("/a/b", "/a/c/d"));
  81         CHECK_STR_EQ_FREE2("../../c/d", get_relative_path("/a/b/c", "/a/c/d"));
  82         CHECK_STR_EQ_FREE2("../..", get_relative_path("/a/b", "/"));
  83         CHECK_STR_EQ_FREE2("../../c", get_relative_path("/a/b", "/c"));
  84         CHECK_STR_EQ_FREE2("a/b", get_relative_path("/", "/a/b"));
  85 #endif
  86 }
  87
  88 TEST(format_hash_as_string)
  89 {
  90         unsigned char hash[16] = {
  91                 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
  92         };
  93
  94         CHECK_STR_EQ_FREE2("00000000000000000000000000000000",
  95                            format_hash_as_string(hash, -1));
  96         CHECK_STR_EQ_FREE2("00000000000000000000000000000000-0",
  97                            format_hash_as_string(hash, 0));
  98         hash[0] = 17;
  99         hash[15] = 42;
 100         CHECK_STR_EQ_FREE2("1100000000000000000000000000002a-12345",
 101                            format_hash_as_string(hash, 12345));
 102 }
 103
 104 TEST(subst_env_in_string)
 105 {
 106         char *errmsg;
 107
 108         putenv("FOO=bar");
 109
 110         CHECK_STR_EQ_FREE2("bar",
 111                            subst_env_in_string("$FOO", &errmsg));
 112         CHECK(!errmsg);
 113
 114         errmsg = "";
 115         CHECK_STR_EQ_FREE2("$",
 116                            subst_env_in_string("$", &errmsg));
 117         CHECK(!errmsg);
 118
 119         errmsg = "";
 120         CHECK_STR_EQ_FREE2("bar bar:bar",
 121                            subst_env_in_string("$FOO $FOO:$FOO", &errmsg));
 122         CHECK(!errmsg);
 123
 124         errmsg = "";
 125         CHECK_STR_EQ_FREE2("xbar",
 126                            subst_env_in_string("x$FOO", &errmsg));
 127         CHECK(!errmsg);
 128
 129         errmsg = "";
 130         CHECK_STR_EQ_FREE2("barx",
 131                            subst_env_in_string("${FOO}x", &errmsg));
 132         CHECK(!errmsg);
 133
 134         CHECK(!subst_env_in_string("$surelydoesntexist", &errmsg));
 135         CHECK_STR_EQ_FREE2("environment variable \"surelydoesntexist\" not set",
 136                            errmsg);
 137
 138         CHECK(!subst_env_in_string("${FOO", &errmsg));
 139         CHECK_STR_EQ_FREE2("syntax error: missing '}' after \"FOO\"", errmsg);
 140 }
 141
 142 TEST(format_human_readable_size)
 143 {
 144         CHECK_STR_EQ_FREE2("0.0 kB", format_human_readable_size(0));
 145         CHECK_STR_EQ_FREE2("0.0 kB", format_human_readable_size(49));
 146         CHECK_STR_EQ_FREE2("0.1 kB", format_human_readable_size(50));
 147         CHECK_STR_EQ_FREE2("42.0 kB", format_human_readable_size(42 * 1000));
 148         CHECK_STR_EQ_FREE2("1.0 MB", format_human_readable_size(1000 * 1000));
 149         CHECK_STR_EQ_FREE2("1.2 MB", format_human_readable_size(1234 * 1000));
 150         CHECK_STR_EQ_FREE2("438.5 MB",
 151                            format_human_readable_size(438.5 * 1000 * 1000));
 152         CHECK_STR_EQ_FREE2("1.0 GB",
 153                            format_human_readable_size(1000 * 1000 * 1000));
 154         CHECK_STR_EQ_FREE2("17.1 GB",
 155                            format_human_readable_size(17.11 * 1000 * 1000 * 1000));
 156 }
 157
 158 TEST(format_parsable_size_with_suffix)
 159 {
 160         CHECK_STR_EQ_FREE2("0", format_parsable_size_with_suffix(0));
 161         CHECK_STR_EQ_FREE2("42.0k", format_parsable_size_with_suffix(42 * 1000));
 162         CHECK_STR_EQ_FREE2("1.0M", format_parsable_size_with_suffix(1000 * 1000));
 163         CHECK_STR_EQ_FREE2("1.2M", format_parsable_size_with_suffix(1234 * 1000));
 164         CHECK_STR_EQ_FREE2("438.5M",
 165                            format_parsable_size_with_suffix(438.5 * 1000 * 1000));
 166         CHECK_STR_EQ_FREE2("1.0G",
 167                            format_parsable_size_with_suffix(1000 * 1000 * 1000));
 168         CHECK_STR_EQ_FREE2(
 169           "17.1G",
 170           format_parsable_size_with_suffix(17.11 * 1000 * 1000 * 1000));
 171 }
 172
 173 TEST(parse_size_with_suffix)
 174 {
 175         uint64_t size;
 176         size_t i;
 177         struct { const char *size; int64_t expected; } sizes[] = {
 178                 {"0", 0},
 179                 {"42", (int64_t)42 * 1000 * 1000 * 1000}, // Default suffix: G
 180
 181                 {"78k",       78 * 1000},
 182                 {"78K",       78 * 1000},
 183                 {"1.1 M",     1.1 * 1000 * 1000},
 184                 {"438.55M",   438.55 * 1000 * 1000},
 185                 {"1 G",       1 * 1000 * 1000 * 1000},
 186                 {"2T",        (int64_t)2 * 1000 * 1000 * 1000 * 1000},
 187
 188                 {"78 Ki",     78 * 1024},
 189                 {"1.1Mi",     1.1 * 1024 * 1024},
 190                 {"438.55 Mi", 438.55 * 1024 * 1024},
 191                 {"1Gi",       1 * 1024 * 1024 * 1024},
 192                 {"2 Ti",      (int64_t)2 * 1024 * 1024 * 1024 * 1024},
 193
 194         };
 195
 196         for (i = 0; i < sizeof(sizes) / sizeof(sizes[0]); ++i) {
 197                 CHECKM(parse_size_with_suffix(sizes[i].size, &size), sizes[i].size);
 198                 CHECK_INT_EQ(sizes[i].expected, size);
 199         }
 200 }
 201
 202 TEST_SUITE_END