systemd/systemd | Build 15175033720 | src/test/test-string-util.c | Coveralls

10

TEST(string_erase) {

1✔

11

        char *x;

1✔

12

        x = strdupa_safe("");

1✔

13

        ASSERT_STREQ(string_erase(x), "");

1✔

15

        x = strdupa_safe("1");

1✔

16

        ASSERT_STREQ(string_erase(x), "");

1✔

18

        x = strdupa_safe("123456789");

1✔

19

        ASSERT_STREQ(string_erase(x), "");

1✔

21

        assert_se(x[1] == '\0');

1✔

22

        assert_se(x[2] == '\0');

1✔

23

        assert_se(x[3] == '\0');

1✔

24

        assert_se(x[4] == '\0');

1✔

25

        assert_se(x[5] == '\0');

1✔

26

        assert_se(x[6] == '\0');

1✔

27

        assert_se(x[7] == '\0');

1✔

28

        assert_se(x[8] == '\0');

1✔

29

        assert_se(x[9] == '\0');

1✔

30

1✔

32

static void test_free_and_strndup_one(char **t, const char *src, size_t l, const char *expected, bool change) {

25✔

33

        log_debug("%s: \"%s\", \"%s\", %zu (expect \"%s\", %s)",

54✔

36

        int r = free_and_strndup(t, src, l);

25✔

37

        ASSERT_STREQ(*t, expected);

25✔

38

        assert_se(r == change); /* check that change occurs only when necessary */

25✔

39

25✔

41

TEST(free_and_strndup) {

1✔

42

        static const struct test_case {

1✔

77

        _cleanup_free_ char *t = NULL;

2✔

78

        const char *prev_expected = t;

1✔

80

        FOREACH_ELEMENT(c, cases) {

26✔

81

                test_free_and_strndup_one(&t,

25✔

82

                                          c->src, c->len, c->expected,

25✔

83

                                          !streq_ptr(c->expected, prev_expected));

25✔

84

                prev_expected = t;

25✔

86

1✔

88

TEST(strdup_to_full) {

1✔

89

        _cleanup_free_ char *dst;

2✔

91

        assert_se(strdup_to_full(NULL, NULL) == 0);

1✔

92

        assert_se(strdup_to_full(&dst, NULL) == 0);

1✔

94

        assert_se(strdup_to_full(NULL, "") == 1);

1✔

95

        assert_se(strdup_to_full(&dst, "") == 1);

1✔

96

        ASSERT_STREQ(dst, "");

1✔

97

        dst = mfree(dst);

1✔

99

        assert_se(strdup_to_full(NULL, "x") == 1);

1✔

100

        assert_se(strdup_to_full(&dst, "x") == 1);

1✔

101

        ASSERT_STREQ(dst, "x");

1✔

102

1✔

104

TEST(strdup_to) {

1✔

105

        _cleanup_free_ char *dst;

2✔

107

        assert_se(strdup_to(&dst, NULL) == 0);

1✔

109

        assert_se(strdup_to(&dst, "") == 0);

1✔

110

        ASSERT_STREQ(dst, "");

1✔

111

        dst = mfree(dst);

1✔

113

        assert_se(strdup_to(&dst, "x") == 0);

1✔

114

        ASSERT_STREQ(dst, "x");

1✔

115

1✔

117

TEST(ascii_strcasecmp_n) {

1✔

118

        assert_se(ascii_strcasecmp_n("", "", 0) == 0);

1✔

119

        assert_se(ascii_strcasecmp_n("", "", 1) == 0);

1✔

120

        assert_se(ascii_strcasecmp_n("", "a", 1) < 0);

1✔

121

        assert_se(ascii_strcasecmp_n("", "a", 2) < 0);

1✔

122

        assert_se(ascii_strcasecmp_n("a", "", 1) > 0);

1✔

123

        assert_se(ascii_strcasecmp_n("a", "", 2) > 0);

1✔

124

        assert_se(ascii_strcasecmp_n("a", "a", 1) == 0);

1✔

125

        assert_se(ascii_strcasecmp_n("a", "a", 2) == 0);

1✔

126

        assert_se(ascii_strcasecmp_n("a", "b", 1) < 0);

1✔

127

        assert_se(ascii_strcasecmp_n("a", "b", 2) < 0);

1✔

128

        assert_se(ascii_strcasecmp_n("b", "a", 1) > 0);

1✔

129

        assert_se(ascii_strcasecmp_n("b", "a", 2) > 0);

1✔

130

        assert_se(ascii_strcasecmp_n("xxxxyxxxx", "xxxxYxxxx", 9) == 0);

1✔

131

        assert_se(ascii_strcasecmp_n("xxxxxxxxx", "xxxxyxxxx", 9) < 0);

1✔

132

        assert_se(ascii_strcasecmp_n("xxxxXxxxx", "xxxxyxxxx", 9) < 0);

1✔

133

        assert_se(ascii_strcasecmp_n("xxxxxxxxx", "xxxxYxxxx", 9) < 0);

1✔

134

        assert_se(ascii_strcasecmp_n("xxxxXxxxx", "xxxxYxxxx", 9) < 0);

1✔

136

        assert_se(ascii_strcasecmp_n("xxxxYxxxx", "xxxxYxxxx", 9) == 0);

1✔

137

        assert_se(ascii_strcasecmp_n("xxxxyxxxx", "xxxxxxxxx", 9) > 0);

1✔

138

        assert_se(ascii_strcasecmp_n("xxxxyxxxx", "xxxxXxxxx", 9) > 0);

1✔

139

        assert_se(ascii_strcasecmp_n("xxxxYxxxx", "xxxxxxxxx", 9) > 0);

1✔

140

        assert_se(ascii_strcasecmp_n("xxxxYxxxx", "xxxxXxxxx", 9) > 0);

1✔

141

1✔

143

TEST(ascii_strcasecmp_nn) {

1✔

144

        assert_se(ascii_strcasecmp_nn("", 0, "", 0) == 0);

1✔

145

        assert_se(ascii_strcasecmp_nn("", 0, "", 1) < 0);

1✔

146

        assert_se(ascii_strcasecmp_nn("", 1, "", 0) > 0);

1✔

147

        assert_se(ascii_strcasecmp_nn("", 1, "", 1) == 0);

1✔

149

        assert_se(ascii_strcasecmp_nn("aaaa", 4, "aaAa", 4) == 0);

1✔

150

        assert_se(ascii_strcasecmp_nn("aaa", 3, "aaAa", 4) < 0);

1✔

151

        assert_se(ascii_strcasecmp_nn("aaa", 4, "aaAa", 4) < 0);

1✔

152

        assert_se(ascii_strcasecmp_nn("aaaa", 4, "aaA", 3) > 0);

1✔

153

        assert_se(ascii_strcasecmp_nn("aaaa", 4, "AAA", 4) > 0);

1✔

155

        assert_se(ascii_strcasecmp_nn("aaaa", 4, "bbbb", 4) < 0);

1✔

156

        assert_se(ascii_strcasecmp_nn("aaAA", 4, "BBbb", 4) < 0);

1✔

157

        assert_se(ascii_strcasecmp_nn("BBbb", 4, "aaaa", 4) > 0);

1✔

158

1✔

160

TEST(cellescape) {

1✔

161

        char buf[40];

1✔

163

        ASSERT_STREQ(cellescape(buf, 1, ""), "");

1✔

164

        ASSERT_STREQ(cellescape(buf, 1, "1"), "");

1✔

165

        ASSERT_STREQ(cellescape(buf, 1, "12"), "");

1✔

167

        ASSERT_STREQ(cellescape(buf, 2, ""), "");

1✔

168

        ASSERT_STREQ(cellescape(buf, 2, "1"), "1");

1✔

169

        ASSERT_STREQ(cellescape(buf, 2, "12"), ".");

1✔

170

        ASSERT_STREQ(cellescape(buf, 2, "123"), ".");

1✔

172

        ASSERT_STREQ(cellescape(buf, 3, ""), "");

1✔

173

        ASSERT_STREQ(cellescape(buf, 3, "1"), "1");

1✔

174

        ASSERT_STREQ(cellescape(buf, 3, "12"), "12");

1✔

175

        ASSERT_STREQ(cellescape(buf, 3, "123"), "..");

1✔

176

        ASSERT_STREQ(cellescape(buf, 3, "1234"), "..");

1✔

178

        ASSERT_STREQ(cellescape(buf, 4, ""), "");

1✔

179

        ASSERT_STREQ(cellescape(buf, 4, "1"), "1");

1✔

180

        ASSERT_STREQ(cellescape(buf, 4, "12"), "12");

1✔

181

        ASSERT_STREQ(cellescape(buf, 4, "123"), "123");

1✔

182

        ASSERT_STREQ(cellescape(buf, 4, "1234"), is_locale_utf8() ? "…" : "...");

1✔

183

        ASSERT_STREQ(cellescape(buf, 4, "12345"), is_locale_utf8() ? "…" : "...");

1✔

185

        ASSERT_STREQ(cellescape(buf, 5, ""), "");

1✔

186

        ASSERT_STREQ(cellescape(buf, 5, "1"), "1");

1✔

187

        ASSERT_STREQ(cellescape(buf, 5, "12"), "12");

1✔

188

        ASSERT_STREQ(cellescape(buf, 5, "123"), "123");

1✔

189

        ASSERT_STREQ(cellescape(buf, 5, "1234"), "1234");

1✔

190

        ASSERT_STREQ(cellescape(buf, 5, "12345"), is_locale_utf8() ? "1…" : "1...");

1✔

191

        ASSERT_STREQ(cellescape(buf, 5, "123456"), is_locale_utf8() ? "1…" : "1...");

1✔

193

        ASSERT_STREQ(cellescape(buf, 1, "\020"), "");

1✔

194

        ASSERT_STREQ(cellescape(buf, 2, "\020"), ".");

1✔

195

        ASSERT_STREQ(cellescape(buf, 3, "\020"), "..");

1✔

196

        ASSERT_STREQ(cellescape(buf, 4, "\020"), is_locale_utf8() ? "…" : "...");

1✔

197

        ASSERT_STREQ(cellescape(buf, 5, "\020"), "\\020");

1✔

199

        ASSERT_STREQ(cellescape(buf, 5, "1234\020"), is_locale_utf8() ? "1…" : "1...");

1✔

200

        ASSERT_STREQ(cellescape(buf, 6, "1234\020"), is_locale_utf8() ? "12…" : "12...");

1✔

201

        ASSERT_STREQ(cellescape(buf, 7, "1234\020"), is_locale_utf8() ? "123…" : "123...");

1✔

202

        ASSERT_STREQ(cellescape(buf, 8, "1234\020"), is_locale_utf8() ? "1234…" : "1234...");

1✔

203

        ASSERT_STREQ(cellescape(buf, 9, "1234\020"), "1234\\020");

1✔

205

        ASSERT_STREQ(cellescape(buf, 1, "\t\n"), "");

1✔

206

        ASSERT_STREQ(cellescape(buf, 2, "\t\n"), ".");

1✔

207

        ASSERT_STREQ(cellescape(buf, 3, "\t\n"), "..");

1✔

208

        ASSERT_STREQ(cellescape(buf, 4, "\t\n"), is_locale_utf8() ? "…" : "...");

1✔

209

        ASSERT_STREQ(cellescape(buf, 5, "\t\n"), "\\t\\n");

1✔

211

        ASSERT_STREQ(cellescape(buf, 5, "1234\t\n"), is_locale_utf8() ? "1…" : "1...");

1✔

212

        ASSERT_STREQ(cellescape(buf, 6, "1234\t\n"), is_locale_utf8() ? "12…" : "12...");

1✔

213

        ASSERT_STREQ(cellescape(buf, 7, "1234\t\n"), is_locale_utf8() ? "123…" : "123...");

1✔

214

        ASSERT_STREQ(cellescape(buf, 8, "1234\t\n"), is_locale_utf8() ? "1234…" : "1234...");

1✔

215

        ASSERT_STREQ(cellescape(buf, 9, "1234\t\n"), "1234\\t\\n");

1✔

217

        ASSERT_STREQ(cellescape(buf, 4, "x\t\020\n"), is_locale_utf8() ? "…" : "...");

1✔

218

        ASSERT_STREQ(cellescape(buf, 5, "x\t\020\n"), is_locale_utf8() ? "x…" : "x...");

1✔

219

        ASSERT_STREQ(cellescape(buf, 6, "x\t\020\n"), is_locale_utf8() ? "x…" : "x...");

1✔

220

        ASSERT_STREQ(cellescape(buf, 7, "x\t\020\n"), is_locale_utf8() ? "x\\t…" : "x\\t...");

1✔

221

        ASSERT_STREQ(cellescape(buf, 8, "x\t\020\n"), is_locale_utf8() ? "x\\t…" : "x\\t...");

1✔

222

        ASSERT_STREQ(cellescape(buf, 9, "x\t\020\n"), is_locale_utf8() ? "x\\t…" : "x\\t...");

1✔

223

        ASSERT_STREQ(cellescape(buf, 10, "x\t\020\n"), "x\\t\\020\\n");

1✔

225

        ASSERT_STREQ(cellescape(buf, 6, "1\011"), "1\\t");

1✔

226

        ASSERT_STREQ(cellescape(buf, 6, "1\020"), "1\\020");

1✔

227

        ASSERT_STREQ(cellescape(buf, 6, "1\020x"), is_locale_utf8() ? "1…" : "1...");

1✔

229

        ASSERT_STREQ(cellescape(buf, 40, "1\020"), "1\\020");

1✔

230

        ASSERT_STREQ(cellescape(buf, 40, "1\020x"), "1\\020x");

1✔

232

        ASSERT_STREQ(cellescape(buf, 40, "\a\b\f\n\r\t\v\\\"'"), "\\a\\b\\f\\n\\r\\t\\v\\\\\\\"\\'");

1✔

233

        ASSERT_STREQ(cellescape(buf, 6, "\a\b\f\n\r\t\v\\\"'"), is_locale_utf8() ? "\\a…" : "\\a...");

1✔

234

        ASSERT_STREQ(cellescape(buf, 7, "\a\b\f\n\r\t\v\\\"'"), is_locale_utf8() ? "\\a…" : "\\a...");

1✔

235

        ASSERT_STREQ(cellescape(buf, 8, "\a\b\f\n\r\t\v\\\"'"), is_locale_utf8() ? "\\a\\b…" : "\\a\\b...");

1✔

237

        ASSERT_STREQ(cellescape(buf, sizeof buf, "1\020"), "1\\020");

1✔

238

        ASSERT_STREQ(cellescape(buf, sizeof buf, "1\020x"), "1\\020x");

1✔

239

1✔

241

TEST(streq_ptr) {

1✔

242

        assert_se(streq_ptr(NULL, NULL));

1✔

243

        assert_se(!streq_ptr("abc", "cdef"));

1✔

244

1✔

246

TEST(strstrip) {

1✔

247

        char *ret, input[] = "   hello, waldo.   ";

1✔

249

        ret = strstrip(input);

1✔

250

        ASSERT_STREQ(ret, "hello, waldo.");

1✔

251

1✔

253

TEST(strextend) {

1✔

254

        _cleanup_free_ char *str = NULL;

2✔

256

        assert_se(strextend(&str, NULL));

1✔

257

        ASSERT_STREQ(str, "");

1✔

258

        assert_se(strextend(&str, "", "0", "", "", "123"));

1✔

259

        ASSERT_STREQ(str, "0123");

1✔

260

        assert_se(strextend(&str, "456", "78", "9"));

1✔

261

        ASSERT_STREQ(str, "0123456789");

1✔

263

        assert_se(strextend(&str, "more", NULL, "huch"));

1✔

264

        ASSERT_STREQ(str, "0123456789more");

1✔

266

        assert_se(strextend(&str, "MORE", POINTER_MAX, "HUCH"));

1✔

267

        ASSERT_STREQ(str, "0123456789moreMOREHUCH");

1✔

268

1✔

270

TEST(strextend_with_separator) {

1✔

271

        _cleanup_free_ char *str = NULL;

2✔

273

        assert_se(strextend_with_separator(&str, NULL, NULL));

1✔

274

        ASSERT_STREQ(str, "");

1✔

275

        str = mfree(str);

1✔

277

        assert_se(strextend_with_separator(&str, "...", NULL));

1✔

278

        ASSERT_STREQ(str, "");

1✔

279

        assert_se(strextend_with_separator(&str, "...", NULL));

1✔

280

        ASSERT_STREQ(str, "");

1✔

281

        str = mfree(str);

1✔

283

        assert_se(strextend_with_separator(&str, "xyz", "a", "bb", "ccc"));

1✔

284

        ASSERT_STREQ(str, "axyzbbxyzccc");

1✔

285

        str = mfree(str);

1✔

287

        assert_se(strextend_with_separator(&str, ",", "start", "", "1", "234"));

1✔

288

        ASSERT_STREQ(str, "start,,1,234");

1✔

289

        assert_se(strextend_with_separator(&str, ";", "more", "5", "678"));

1✔

290

        ASSERT_STREQ(str, "start,,1,234;more;5;678");

1✔

292

        assert_se(strextend_with_separator(&str, ";", "xxxx", POINTER_MAX, "yyy"));

1✔

293

        ASSERT_STREQ(str, "start,,1,234;more;5;678;xxxx;yyy");

1✔

294

1✔

296

TEST(strrep) {

1✔

298

        char *onea, *threea;

1✔

300

        one = strrep("waldo", 1);

1✔

301

        three = strrep("waldo", 3);

1✔

302

        zero = strrep("waldo", 0);

1✔

304

        ASSERT_STREQ(one, "waldo");

1✔

305

        ASSERT_STREQ(three, "waldowaldowaldo");

1✔

306

        ASSERT_STREQ(zero, "");

1✔

308

        onea = strrepa("waldo", 1);

2✔

309

        threea = strrepa("waldo", 3);

4✔

311

        ASSERT_STREQ(onea, "waldo");

1✔

312

        ASSERT_STREQ(threea, "waldowaldowaldo");

1✔

313

1✔

315

TEST(string_has_cc) {

1✔

316

        assert_se(string_has_cc("abc\1", NULL));

1✔

317

        assert_se(string_has_cc("abc\x7f", NULL));

1✔

318

        assert_se(string_has_cc("abc\x7f", NULL));

1✔

319

        assert_se(string_has_cc("abc\t\x7f", "\t"));

1✔

320

        assert_se(string_has_cc("abc\t\x7f", "\t"));

1✔

321

        assert_se(string_has_cc("\x7f", "\t"));

1✔

322

        assert_se(string_has_cc("\x7f", "\t\a"));

1✔

324

        assert_se(!string_has_cc("abc\t\t", "\t"));

1✔

325

        assert_se(!string_has_cc("abc\t\t\a", "\t\a"));

1✔

326

        assert_se(!string_has_cc("a\ab\tc", "\t\a"));

1✔

327

1✔

329

TEST(ascii_strlower) {

1✔

330

        char a[] = "AabBcC Jk Ii Od LKJJJ kkd LK";

1✔

331

        ASSERT_STREQ(ascii_strlower(a), "aabbcc jk ii od lkjjj kkd lk");

1✔

332

1✔

334

TEST(strshorten) {

1✔

335

        char s[] = "foobar";

1✔

337

        assert_se(strlen(strshorten(s, SIZE_MAX)) == 6);

1✔

338

        assert_se(strlen(strshorten(s, SIZE_MAX-1)) == 6);

1✔

339

        assert_se(strlen(strshorten(s, SIZE_MAX-2)) == 6);

1✔

340

        assert_se(strlen(strshorten(s, 6)) == 6);

1✔

341

        assert_se(strlen(strshorten(s, 7)) == 6);

1✔

342

        assert_se(strlen(strshorten(s, 12)) == 6);

1✔

343

        assert_se(strlen(strshorten(s, 5)) == 5);

1✔

344

        assert_se(strlen(strshorten(s, 2)) == 2);

1✔

345

        assert_se(strlen(strshorten(s, 0)) == 0);

1✔

346

1✔

348

TEST(strjoina) {

1✔

349

        char *actual;

1✔

351

        actual = strjoina("", "foo", "bar");

7✔

352

        ASSERT_STREQ(actual, "foobar");

1✔

354

        actual = strjoina("foo", "bar", "baz");

7✔

355

        ASSERT_STREQ(actual, "foobarbaz");

1✔

357

        actual = strjoina("foo", "", "bar", "baz");

9✔

358

        ASSERT_STREQ(actual, "foobarbaz");

1✔

360

        actual = strjoina("foo");

3✔

361

        ASSERT_STREQ(actual, "foo");

1✔

363

        actual = strjoina(NULL);

1✔

364

        ASSERT_STREQ(actual, "");

1✔

366

        actual = strjoina(NULL, "foo");

1✔

367

        ASSERT_STREQ(actual, "");

1✔

369

        actual = strjoina("foo", NULL, "bar");

3✔

370

        ASSERT_STREQ(actual, "foo");

1✔

372

        actual = strjoina("/sys/fs/cgroup/", "dn", "/a/b/c", "/cgroup.procs");

9✔

373

        ASSERT_STREQ(actual, "/sys/fs/cgroup/dn/a/b/c/cgroup.procs");

1✔

375

        actual = strjoina("/sys/fs/cgroup/", "dn", NULL, NULL);

5✔

376

        ASSERT_STREQ(actual, "/sys/fs/cgroup/dn");

1✔

377

1✔

379

TEST(strjoin) {

1✔

380

        char *actual;

1✔

382

        actual = strjoin("", "foo", "bar");

1✔

383

        ASSERT_STREQ(actual, "foobar");

1✔

384

        free(actual);

1✔

386

        actual = strjoin("foo", "bar", "baz");

1✔

387

        ASSERT_STREQ(actual, "foobarbaz");

1✔

388

        free(actual);

1✔

390

        actual = strjoin("foo", "", "bar", "baz");

1✔

391

        ASSERT_STREQ(actual, "foobarbaz");

1✔

392

        free(actual);

1✔

394

        actual = strjoin("foo", NULL);

1✔

395

        ASSERT_STREQ(actual, "foo");

1✔

396

        free(actual);

1✔

398

        actual = strjoin(NULL, NULL);

1✔

399

        ASSERT_STREQ(actual, "");

1✔

400

        free(actual);

1✔

402

        actual = strjoin(NULL, "foo");

1✔

403

        ASSERT_STREQ(actual, "");

1✔

404

        free(actual);

1✔

406

        actual = strjoin("foo", NULL, "bar");

1✔

407

        ASSERT_STREQ(actual, "foo");

1✔

408

        free(actual);

1✔

410

        actual = strjoin("foo", POINTER_MAX, "bar");

1✔

411

        ASSERT_STREQ(actual, "foobar");

1✔

412

        free(actual);

1✔

413

1✔

415

TEST(strcmp_ptr) {

1✔

416

        assert_se(strcmp_ptr(NULL, NULL) == 0);

1✔

417

        assert_se(strcmp_ptr("", NULL) > 0);

1✔

418

        assert_se(strcmp_ptr("foo", NULL) > 0);

1✔

419

        assert_se(strcmp_ptr(NULL, "") < 0);

1✔

420

        assert_se(strcmp_ptr(NULL, "bar") < 0);

1✔

421

        assert_se(strcmp_ptr("foo", "bar") > 0);

1✔

422

        assert_se(strcmp_ptr("bar", "baz") < 0);

1✔

423

        assert_se(strcmp_ptr("foo", "foo") == 0);

1✔

424

        assert_se(strcmp_ptr("", "") == 0);

1✔

425

1✔

427

TEST(foreach_word) {

1✔

428

        const char *test = "test abc d\te   f   ";

1✔

429

        const char * const expected[] = {

1✔

437

        size_t i = 0;

1✔

438

        int r;

1✔

439

        for (const char *p = test;;) {

1✔

440

                _cleanup_free_ char *word = NULL;

5✔

442

                r = extract_first_word(&p, &word, NULL, 0);

6✔

443

                if (r == 0) {

6✔

444

                        assert_se(i == ELEMENTSOF(expected));

1✔

445

                        break;

1✔

447

                assert_se(r > 0);

5✔

449

                ASSERT_STREQ(expected[i++], word);

5✔

451

1✔

453

static void check(const char *test, char** expected, bool trailing) {

3✔

454

        size_t i = 0;

3✔

455

        int r;

3✔

457

        printf("<<<%s>>>\n", test);

3✔

458

        for (;;) {

29✔

459

                _cleanup_free_ char *word = NULL;

13✔

461

                r = extract_first_word(&test, &word, NULL, EXTRACT_UNQUOTE);

16✔

462

                if (r == 0) {

16✔

463

                        assert_se(!trailing);

1✔

465

                } else if (r < 0) {

15✔

466

                        assert_se(trailing);

2✔

470

                ASSERT_STREQ(word, expected[i++]);

13✔

471

                printf("<%s>\n", word);

13✔

473

        ASSERT_NULL(expected[i]);

3✔

474

3✔

476

TEST(foreach_word_quoted) {

1✔

477

        check("test a b c 'd' e '' '' hhh '' '' \"a b c\"",

1✔

478

              STRV_MAKE("test",

1✔

492

        check("test \"xxx",

1✔

493

              STRV_MAKE("test"),

1✔

496

        check("test\\",

1✔

497

              STRV_MAKE_EMPTY,

1✔

499

1✔

501

TEST(endswith) {

1✔

502

        assert_se(endswith("foobar", "bar"));

1✔

503

        assert_se(endswith("foobar", ""));

1✔

504

        assert_se(endswith("foobar", "foobar"));

1✔

505

        assert_se(endswith("", ""));

1✔

507

        assert_se(!endswith("foobar", "foo"));

1✔

508

        assert_se(!endswith("foobar", "foobarfoofoo"));

1✔

509

1✔

511

TEST(endswith_no_case) {

1✔

512

        assert_se(endswith_no_case("fooBAR", "bar"));

1✔

513

        assert_se(endswith_no_case("foobar", ""));

1✔

514

        assert_se(endswith_no_case("foobar", "FOOBAR"));

1✔

515

        assert_se(endswith_no_case("", ""));

1✔

517

        assert_se(!endswith_no_case("foobar", "FOO"));

1✔

518

        assert_se(!endswith_no_case("foobar", "FOOBARFOOFOO"));

1✔

519

1✔

521

TEST(delete_chars) {

1✔

522

        char *s, input[] = "   hello, waldo.   abc";

1✔

524

        s = delete_chars(input, WHITESPACE);

1✔

525

        ASSERT_STREQ(s, "hello,waldo.abc");

1✔

526

        assert_se(s == input);

1✔

527

1✔

529

TEST(delete_trailing_chars) {

1✔

530

        char *s,

1✔

531

                input1[] = " \n \r k \n \r ",

1✔

532

                input2[] = "kkkkthiskkkiskkkaktestkkk",

1✔

533

                input3[] = "abcdef";

1✔

535

        s = delete_trailing_chars(input1, WHITESPACE);

1✔

536

        ASSERT_STREQ(s, " \n \r k");

1✔

537

        assert_se(s == input1);

1✔

539

        s = delete_trailing_chars(input2, "kt");

1✔

540

        ASSERT_STREQ(s, "kkkkthiskkkiskkkaktes");

1✔

541

        assert_se(s == input2);

1✔

543

        s = delete_trailing_chars(input3, WHITESPACE);

1✔

544

        ASSERT_STREQ(s, "abcdef");

1✔

545

        assert_se(s == input3);

1✔

547

        s = delete_trailing_chars(input3, "fe");

1✔

548

        ASSERT_STREQ(s, "abcd");

1✔

549

        assert_se(s == input3);

1✔

550

1✔

552

TEST(delete_trailing_slashes) {

1✔

553

        char s1[] = "foobar//",

1✔

554

             s2[] = "foobar/",

1✔

555

             s3[] = "foobar",

1✔

556

             s4[] = "";

1✔

558

        ASSERT_STREQ(delete_trailing_chars(s1, "_"), "foobar//");

1✔

559

        ASSERT_STREQ(delete_trailing_chars(s1, "/"), "foobar");

1✔

560

        ASSERT_STREQ(delete_trailing_chars(s2, "/"), "foobar");

1✔

561

        ASSERT_STREQ(delete_trailing_chars(s3, "/"), "foobar");

1✔

562

        ASSERT_STREQ(delete_trailing_chars(s4, "/"), "");

1✔

563

1✔

565

TEST(skip_leading_chars) {

1✔

566

        char input1[] = " \n \r k \n \r ",

1✔

567

                input2[] = "kkkkthiskkkiskkkaktestkkk",

1✔

568

                input3[] = "abcdef";

1✔

570

        ASSERT_STREQ(skip_leading_chars(input1, WHITESPACE), "k \n \r ");

1✔

571

        ASSERT_STREQ(skip_leading_chars(input2, "k"), "thiskkkiskkkaktestkkk");

1✔

572

        ASSERT_STREQ(skip_leading_chars(input2, "tk"), "hiskkkiskkkaktestkkk");

1✔

573

        ASSERT_STREQ(skip_leading_chars(input3, WHITESPACE), "abcdef");

1✔

574

        ASSERT_STREQ(skip_leading_chars(input3, "bcaef"), "def");

1✔

575

1✔

577

TEST(in_charset) {

1✔

578

        assert_se(in_charset("dddaaabbbcccc", "abcd"));

1✔

579

        assert_se(!in_charset("dddaaabbbcccc", "abc f"));

1✔

580

1✔

582

TEST(split_pair) {

1✔

585

        ASSERT_SIGNAL(split_pair("", NULL, &a, &b), SIGABRT);

1✔

586

        ASSERT_SIGNAL(split_pair("", "", &a, &b), SIGABRT);

1✔

587

        ASSERT_SIGNAL(split_pair("foo=bar", "", &a, &b), SIGABRT);

1✔

588

        ASSERT_SIGNAL(split_pair(NULL, "=", &a, &b), SIGABRT);

1✔

589

        ASSERT_ERROR(split_pair("", "=", &a, &b), EINVAL);

1✔

590

        ASSERT_OK(split_pair("foo=bar", "=", &a, &b));

1✔

591

        ASSERT_STREQ(a, "foo");

1✔

592

        ASSERT_STREQ(b, "bar");

1✔

593

        a = mfree(a);

1✔

594

        b = mfree(b);

1✔

595

        ASSERT_OK(split_pair("==", "==", &a, &b));

1✔

596

        ASSERT_STREQ(a, "");

1✔

597

        ASSERT_STREQ(b, "");

1✔

598

        a = mfree(a);

1✔

599

        b = mfree(b);

1✔

600

        ASSERT_OK(split_pair("===", "==", &a, &b));

1✔

601

        ASSERT_STREQ(a, "");

1✔

602

        ASSERT_STREQ(b, "=");

1✔

603

1✔

605

TEST(first_word) {

1✔

606

        assert_se(first_word("Hello", ""));

1✔

607

        assert_se(first_word("Hello", "Hello"));

1✔

608

        assert_se(first_word("Hello world", "Hello"));

1✔

609

        assert_se(first_word("Hello\tworld", "Hello"));

1✔

610

        assert_se(first_word("Hello\nworld", "Hello"));

1✔

611

        assert_se(first_word("Hello\rworld", "Hello"));

1✔

612

        assert_se(first_word("Hello ", "Hello"));

1✔

614

        assert_se(!first_word("Hello", "Hellooo"));

1✔

615

        assert_se(!first_word("Hello", "xxxxx"));

1✔

616

        assert_se(!first_word("Hellooo", "Hello"));

1✔

617

1✔

619

TEST(strlen_ptr) {

1✔

620

        assert_se(strlen_ptr("foo") == 3);

1✔

621

        assert_se(strlen_ptr("") == 0);

1✔

622

        assert_se(strlen_ptr(NULL) == 0);

1✔

623

1✔

625

TEST(memory_startswith) {

1✔

626

        ASSERT_STREQ(memory_startswith("", 0, ""), "");

1✔

627

        ASSERT_STREQ(memory_startswith("", 1, ""), "");

1✔

628

        ASSERT_STREQ(memory_startswith("x", 2, ""), "x");

1✔

629

        assert_se(!memory_startswith("", 1, "x"));

1✔

630

        assert_se(!memory_startswith("", 1, "xxxxxxxx"));

1✔

631

        ASSERT_STREQ(memory_startswith("xxx", 4, "x"), "xx");

1✔

632

        ASSERT_STREQ(memory_startswith("xxx", 4, "xx"), "x");

1✔

633

        ASSERT_STREQ(memory_startswith("xxx", 4, "xxx"), "");

1✔

634

        assert_se(!memory_startswith("xxx", 4, "xxxx"));

1✔

635

1✔

637

TEST(memory_startswith_no_case) {

1✔

638

        ASSERT_STREQ(memory_startswith_no_case("", 0, ""), "");

1✔

639

        ASSERT_STREQ(memory_startswith_no_case("", 1, ""), "");

1✔

640

        ASSERT_STREQ(memory_startswith_no_case("x", 2, ""), "x");

1✔

641

        ASSERT_STREQ(memory_startswith_no_case("X", 2, ""), "X");

1✔

642

        assert_se(!memory_startswith_no_case("", 1, "X"));

1✔

643

        assert_se(!memory_startswith_no_case("", 1, "xxxxXXXX"));

1✔

644

        ASSERT_STREQ(memory_startswith_no_case("xxx", 4, "X"), "xx");

1✔

645

        ASSERT_STREQ(memory_startswith_no_case("XXX", 4, "x"), "XX");

1✔

646

        ASSERT_STREQ(memory_startswith_no_case("XXX", 4, "X"), "XX");

1✔

647

        ASSERT_STREQ(memory_startswith_no_case("xxx", 4, "XX"), "x");

1✔

648

        ASSERT_STREQ(memory_startswith_no_case("XXX", 4, "xx"), "X");

1✔

649

        ASSERT_STREQ(memory_startswith_no_case("XXX", 4, "XX"), "X");

1✔

650

        ASSERT_STREQ(memory_startswith_no_case("xxx", 4, "XXX"), "");

1✔

651

        ASSERT_STREQ(memory_startswith_no_case("XXX", 4, "xxx"), "");

1✔

652

        ASSERT_STREQ(memory_startswith_no_case("XXX", 4, "XXX"), "");

1✔

654

        assert_se(memory_startswith_no_case((char[2]){'x', 'x'}, 2, "xx"));

1✔

655

        assert_se(memory_startswith_no_case((char[2]){'x', 'X'}, 2, "xX"));

1✔

656

        assert_se(memory_startswith_no_case((char[2]){'X', 'x'}, 2, "Xx"));

1✔

657

        assert_se(memory_startswith_no_case((char[2]){'X', 'X'}, 2, "XX"));

1✔

658

1✔

660

static void test_string_truncate_lines_one(const char *input, size_t n_lines, const char *output, bool truncation) {

48✔

661

        _cleanup_free_ char *b = NULL;

96✔

662

        int k;

48✔

664

        assert_se((k = string_truncate_lines(input, n_lines, &b)) >= 0);

48✔

665

        ASSERT_STREQ(b, output);

48✔

666

        assert_se(!!k == truncation);

48✔

667

48✔

669

TEST(string_truncate_lines) {

1✔

670

        test_string_truncate_lines_one("", 0, "", false);

1✔

671

        test_string_truncate_lines_one("", 1, "", false);

1✔

672

        test_string_truncate_lines_one("", 2, "", false);

1✔

673

        test_string_truncate_lines_one("", 3, "", false);

1✔

675

        test_string_truncate_lines_one("x", 0, "", true);

1✔

676

        test_string_truncate_lines_one("x", 1, "x", false);

1✔

677

        test_string_truncate_lines_one("x", 2, "x", false);

1✔

678

        test_string_truncate_lines_one("x", 3, "x", false);

1✔

680

        test_string_truncate_lines_one("x\n", 0, "", true);

1✔

681

        test_string_truncate_lines_one("x\n", 1, "x", false);

1✔

682

        test_string_truncate_lines_one("x\n", 2, "x", false);

1✔

683

        test_string_truncate_lines_one("x\n", 3, "x", false);

1✔

685

        test_string_truncate_lines_one("x\ny", 0, "", true);

1✔

686

        test_string_truncate_lines_one("x\ny", 1, "x", true);

1✔

687

        test_string_truncate_lines_one("x\ny", 2, "x\ny", false);

1✔

688

        test_string_truncate_lines_one("x\ny", 3, "x\ny", false);

1✔

690

        test_string_truncate_lines_one("x\ny\n", 0, "", true);

1✔

691

        test_string_truncate_lines_one("x\ny\n", 1, "x", true);

1✔

692

        test_string_truncate_lines_one("x\ny\n", 2, "x\ny", false);

1✔

693

        test_string_truncate_lines_one("x\ny\n", 3, "x\ny", false);

1✔

695

        test_string_truncate_lines_one("x\ny\nz", 0, "", true);

1✔

696

        test_string_truncate_lines_one("x\ny\nz", 1, "x", true);

1✔

697

        test_string_truncate_lines_one("x\ny\nz", 2, "x\ny", true);

1✔

698

        test_string_truncate_lines_one("x\ny\nz", 3, "x\ny\nz", false);

1✔

700

        test_string_truncate_lines_one("x\ny\nz\n", 0, "", true);

1✔

701

        test_string_truncate_lines_one("x\ny\nz\n", 1, "x", true);

1✔

702

        test_string_truncate_lines_one("x\ny\nz\n", 2, "x\ny", true);

1✔

703

        test_string_truncate_lines_one("x\ny\nz\n", 3, "x\ny\nz", false);

1✔

705

        test_string_truncate_lines_one("\n", 0, "", false);

1✔

706

        test_string_truncate_lines_one("\n", 1, "", false);

1✔

707

        test_string_truncate_lines_one("\n", 2, "", false);

1✔

708

        test_string_truncate_lines_one("\n", 3, "", false);

1✔

710

        test_string_truncate_lines_one("\n\n", 0, "", false);

1✔

711

        test_string_truncate_lines_one("\n\n", 1, "", false);

1✔

712

        test_string_truncate_lines_one("\n\n", 2, "", false);

1✔

713

        test_string_truncate_lines_one("\n\n", 3, "", false);

1✔

715

        test_string_truncate_lines_one("\n\n\n", 0, "", false);

1✔

716

        test_string_truncate_lines_one("\n\n\n", 1, "", false);

1✔

717

        test_string_truncate_lines_one("\n\n\n", 2, "", false);

1✔

718

        test_string_truncate_lines_one("\n\n\n", 3, "", false);

1✔

720

        test_string_truncate_lines_one("\nx\n\n", 0, "", true);

1✔

721

        test_string_truncate_lines_one("\nx\n\n", 1, "", true);

1✔

722

        test_string_truncate_lines_one("\nx\n\n", 2, "\nx", false);

1✔

723

        test_string_truncate_lines_one("\nx\n\n", 3, "\nx", false);

1✔

725

        test_string_truncate_lines_one("\n\nx\n", 0, "", true);

1✔

726

        test_string_truncate_lines_one("\n\nx\n", 1, "", true);

1✔

727

        test_string_truncate_lines_one("\n\nx\n", 2, "", true);

1✔

728

        test_string_truncate_lines_one("\n\nx\n", 3, "\n\nx", false);

1✔

729

1✔

731

static void test_string_extract_lines_one(const char *input, size_t i, const char *output, bool more) {

52✔

732

        _cleanup_free_ char *b = NULL;

104✔

733

        int k;

52✔

735

        assert_se((k = string_extract_line(input, i, &b)) >= 0);

52✔

736

        ASSERT_STREQ(b ?: input, output);

52✔

737

        assert_se(!!k == more);

52✔

738

52✔

740

TEST(string_extract_line) {

1✔

741

        test_string_extract_lines_one("", 0, "", false);

1✔

742

        test_string_extract_lines_one("", 1, "", false);

1✔

743

        test_string_extract_lines_one("", 2, "", false);

1✔

744

        test_string_extract_lines_one("", 3, "", false);

1✔

746

        test_string_extract_lines_one("x", 0, "x", false);

1✔

747

        test_string_extract_lines_one("x", 1, "", false);

1✔

748

        test_string_extract_lines_one("x", 2, "", false);

1✔

749

        test_string_extract_lines_one("x", 3, "", false);

1✔

751

        test_string_extract_lines_one("x\n", 0, "x", false);

1✔

752

        test_string_extract_lines_one("x\n", 1, "", false);

1✔

753

        test_string_extract_lines_one("x\n", 2, "", false);

1✔

754

        test_string_extract_lines_one("x\n", 3, "", false);

1✔

756

        test_string_extract_lines_one("x\ny", 0, "x", true);

1✔

757

        test_string_extract_lines_one("x\ny", 1, "y", false);

1✔

758

        test_string_extract_lines_one("x\ny", 2, "", false);

1✔

759

        test_string_extract_lines_one("x\ny", 3, "", false);

1✔

761

        test_string_extract_lines_one("x\ny\n", 0, "x", true);

1✔

762

        test_string_extract_lines_one("x\ny\n", 1, "y", false);

1✔

763

        test_string_extract_lines_one("x\ny\n", 2, "", false);

1✔

764

        test_string_extract_lines_one("x\ny\n", 3, "", false);

1✔

766

        test_string_extract_lines_one("x\ny\nz", 0, "x", true);

1✔

767

        test_string_extract_lines_one("x\ny\nz", 1, "y", true);

1✔

768

        test_string_extract_lines_one("x\ny\nz", 2, "z", false);

1✔

769

        test_string_extract_lines_one("x\ny\nz", 3, "", false);

1✔

771

        test_string_extract_lines_one("\n", 0, "", false);

1✔

772

        test_string_extract_lines_one("\n", 1, "", false);

1✔

773

        test_string_extract_lines_one("\n", 2, "", false);

1✔

774

        test_string_extract_lines_one("\n", 3, "", false);

1✔

776

        test_string_extract_lines_one("\n\n", 0, "", true);

1✔

777

        test_string_extract_lines_one("\n\n", 1, "", false);

1✔

778

        test_string_extract_lines_one("\n\n", 2, "", false);

1✔

779

        test_string_extract_lines_one("\n\n", 3, "", false);

1✔

781

        test_string_extract_lines_one("\n\n\n", 0, "", true);

1✔

782

        test_string_extract_lines_one("\n\n\n", 1, "", true);

1✔

783

        test_string_extract_lines_one("\n\n\n", 2, "", false);

1✔

784

        test_string_extract_lines_one("\n\n\n", 3, "", false);

1✔

786

        test_string_extract_lines_one("\n\n\n\n", 0, "", true);

1✔

787

        test_string_extract_lines_one("\n\n\n\n", 1, "", true);

1✔

788

        test_string_extract_lines_one("\n\n\n\n", 2, "", true);

1✔

789

        test_string_extract_lines_one("\n\n\n\n", 3, "", false);

1✔

791

        test_string_extract_lines_one("\nx\n\n\n", 0, "", true);

1✔

792

        test_string_extract_lines_one("\nx\n\n\n", 1, "x", true);

1✔

793

        test_string_extract_lines_one("\nx\n\n\n", 2, "", true);

1✔

794

        test_string_extract_lines_one("\nx\n\n\n", 3, "", false);

1✔

796

        test_string_extract_lines_one("\n\nx\n\n", 0, "", true);

1✔

797

        test_string_extract_lines_one("\n\nx\n\n", 1, "", true);

1✔

798

        test_string_extract_lines_one("\n\nx\n\n", 2, "x", true);

1✔

799

        test_string_extract_lines_one("\n\nx\n\n", 3, "", false);

1✔

801

        test_string_extract_lines_one("\n\n\nx\n", 0, "", true);

1✔

802

        test_string_extract_lines_one("\n\n\nx\n", 1, "", true);

1✔

803

        test_string_extract_lines_one("\n\n\nx\n", 2, "", true);

1✔

804

        test_string_extract_lines_one("\n\n\nx\n", 3, "x", false);

1✔

805

1✔

807

TEST(string_contains_word_strv) {

1✔

808

        const char *w;

1✔

810

        assert_se(string_contains_word_strv("a b cc", NULL, STRV_MAKE("a", "b"), NULL));

1✔

812

        assert_se(string_contains_word_strv("a b cc", NULL, STRV_MAKE("a", "b"), &w));

1✔

813

        ASSERT_STREQ(w, "a");

1✔

815

        assert_se(!string_contains_word_strv("a b cc", NULL, STRV_MAKE("d"), &w));

1✔

816

        ASSERT_NULL(w);

1✔

818

        assert_se(string_contains_word_strv("a b cc", NULL, STRV_MAKE("b", "a"), &w));

1✔

819

        ASSERT_STREQ(w, "a");

1✔

821

        assert_se(string_contains_word_strv("b a b cc", NULL, STRV_MAKE("b", "a", "b"), &w));

1✔

822

        ASSERT_STREQ(w, "b");

1✔

824

        assert_se(string_contains_word_strv("a b cc", NULL, STRV_MAKE("b", ""), &w));

1✔

825

        ASSERT_STREQ(w, "b");

1✔

827

        assert_se(!string_contains_word_strv("a b cc", NULL, STRV_MAKE(""), &w));

1✔

828

        ASSERT_NULL(w);

1✔

830

        assert_se(string_contains_word_strv("a b  cc", " ", STRV_MAKE(""), &w));

1✔

831

        ASSERT_STREQ(w, "");

1✔

832

1✔

834

TEST(string_contains_word) {

1✔

835

        assert_se( string_contains_word("a b cc", NULL, "a"));

1✔

836

        assert_se( string_contains_word("a b cc", NULL, "b"));

1✔

837

        assert_se(!string_contains_word("a b cc", NULL, "c"));

1✔

838

        assert_se( string_contains_word("a b cc", NULL, "cc"));

1✔

839

        assert_se(!string_contains_word("a b cc", NULL, "d"));

1✔

840

        assert_se(!string_contains_word("a b cc", NULL, "a b"));

1✔

841

        assert_se(!string_contains_word("a b cc", NULL, "a b c"));

1✔

842

        assert_se(!string_contains_word("a b cc", NULL, "b c"));

1✔

843

        assert_se(!string_contains_word("a b cc", NULL, "b cc"));

1✔

844

        assert_se(!string_contains_word("a b cc", NULL, "a "));

1✔

845

        assert_se(!string_contains_word("a b cc", NULL, " b "));

1✔

846

        assert_se(!string_contains_word("a b cc", NULL, " cc"));

1✔

848

        assert_se( string_contains_word("  a  b\t\tcc", NULL, "a"));

1✔

849

        assert_se( string_contains_word("  a  b\t\tcc", NULL, "b"));

1✔

850

        assert_se(!string_contains_word("  a  b\t\tcc", NULL, "c"));

1✔

851

        assert_se( string_contains_word("  a  b\t\tcc", NULL, "cc"));

1✔

852

        assert_se(!string_contains_word("  a  b\t\tcc", NULL, "d"));

1✔

853

        assert_se(!string_contains_word("  a  b\t\tcc", NULL, "a b"));

1✔

854

        assert_se(!string_contains_word("  a  b\t\tcc", NULL, "a b\t\tc"));

1✔

855

        assert_se(!string_contains_word("  a  b\t\tcc", NULL, "b\t\tc"));

1✔

856

        assert_se(!string_contains_word("  a  b\t\tcc", NULL, "b\t\tcc"));

1✔

857

        assert_se(!string_contains_word("  a  b\t\tcc", NULL, "a "));

1✔

858

        assert_se(!string_contains_word("  a  b\t\tcc", NULL, " b "));

1✔

859

        assert_se(!string_contains_word("  a  b\t\tcc", NULL, " cc"));

1✔

861

        assert_se(!string_contains_word("  a  b\t\tcc", NULL, ""));

1✔

862

        assert_se(!string_contains_word("  a  b\t\tcc", NULL, " "));

1✔

863

        assert_se(!string_contains_word("  a  b\t\tcc", NULL, "  "));

1✔

864

        assert_se( string_contains_word("  a  b\t\tcc", " ", ""));

1✔

865

        assert_se( string_contains_word("  a  b\t\tcc", "\t", ""));

1✔

866

        assert_se( string_contains_word("  a  b\t\tcc", WHITESPACE, ""));

1✔

868

        assert_se( string_contains_word("a:b:cc", ":#", "a"));

1✔

869

        assert_se( string_contains_word("a:b:cc", ":#", "b"));

1✔

870

        assert_se(!string_contains_word("a:b:cc", ":#", "c"));

1✔

871

        assert_se( string_contains_word("a:b:cc", ":#", "cc"));

1✔

872

        assert_se(!string_contains_word("a:b:cc", ":#", "d"));

1✔

873

        assert_se(!string_contains_word("a:b:cc", ":#", "a:b"));

1✔

874

        assert_se(!string_contains_word("a:b:cc", ":#", "a:b:c"));

1✔

875

        assert_se(!string_contains_word("a:b:cc", ":#", "b:c"));

1✔

876

        assert_se(!string_contains_word("a#b#cc", ":#", "b:cc"));

1✔

877

        assert_se( string_contains_word("a#b#cc", ":#", "b"));

1✔

878

        assert_se( string_contains_word("a#b#cc", ":#", "cc"));

1✔

879

        assert_se(!string_contains_word("a:b:cc", ":#", "a:"));

1✔

880

        assert_se(!string_contains_word("a:b cc", ":#", "b"));

1✔

881

        assert_se( string_contains_word("a:b cc", ":#", "b cc"));

1✔

882

        assert_se(!string_contains_word("a:b:cc", ":#", ":cc"));

1✔

883

1✔

885

static void test_strverscmp_improved_one(const char* a, const char *b, int expected) {

401✔

886

        int r = strverscmp_improved(a, b);

401✔

888

        log_info("'%s' %s '%s'%s",

874✔

893

        assert_se(r == expected);

401✔

894

401✔

896

static void test_strverscmp_improved_newer(const char *older, const char *newer) {

298✔

897

        test_strverscmp_improved_one(older, newer, -1);

298✔

899

        assert_se(strverscmp_improved(older, older) == 0);

298✔

900

        assert_se(strverscmp_improved(older, newer) < 0);

298✔

901

        assert_se(strverscmp_improved(newer, older) > 0);

298✔

902

        assert_se(strverscmp_improved(newer, newer) == 0);

298✔

903

298✔

905

TEST(strverscmp_improved) {

1✔

906

        static const char * const versions[] = {

1✔

934

        STRV_FOREACH(p, versions)

25✔

935

                STRV_FOREACH(q, p + 1)

300✔

936

                        test_strverscmp_improved_newer(*p, *q);

276✔

938

        test_strverscmp_improved_newer("123.45-67.88", "123.45-67.89");

1✔

939

        test_strverscmp_improved_newer("123.45-67.89", "123.45-67.89a");

1✔

940

        test_strverscmp_improved_newer("123.45-67.ab", "123.45-67.89");

1✔

941

        test_strverscmp_improved_newer("123.45-67.9", "123.45-67.89");

1✔

942

        test_strverscmp_improved_newer("123.45-67", "123.45-67.89");

1✔

943

        test_strverscmp_improved_newer("123.45-66.89", "123.45-67.89");

1✔

944

        test_strverscmp_improved_newer("123.45-9.99", "123.45-67.89");

1✔

945

        test_strverscmp_improved_newer("123.42-99.99", "123.45-67.89");

1✔

946

        test_strverscmp_improved_newer("123-99.99", "123.45-67.89");

1✔

949

        test_strverscmp_improved_newer("123~rc1-99.99", "123.45-67.89");

1✔

950

        test_strverscmp_improved_newer("123~rc1-99.99", "123-45.67.89");

1✔

951

        test_strverscmp_improved_newer("123~rc1-99.99", "123~rc2-67.89");

1✔

952

        test_strverscmp_improved_newer("123~rc1-99.99", "123^aa2-67.89");

1✔

953

        test_strverscmp_improved_newer("123~rc1-99.99", "123aa2-67.89");

1✔

956

        test_strverscmp_improved_newer("123-99.99", "123.45-67.89");

1✔

957

        test_strverscmp_improved_newer("123-99.99", "123^aa2-67.89");

1✔

958

        test_strverscmp_improved_newer("123-99.99", "123aa2-67.89");

1✔

961

        test_strverscmp_improved_newer("123^45-67.89", "123.45-67.89");

1✔

962

        test_strverscmp_improved_newer("123^aa1-99.99", "123^aa2-67.89");

1✔

963

        test_strverscmp_improved_newer("123^aa2-67.89", "123aa2-67.89");

1✔

966

        test_strverscmp_improved_newer("123.aa2-67.89", "123aa2-67.89");

1✔

967

        test_strverscmp_improved_newer("123.aa2-67.89", "123.ab2-67.89");

1✔

970

        assert_se(strverscmp_improved("123_aa2-67.89", "123aa+2-67.89") == 0);

1✔

973

        assert_se(strverscmp_improved("123.", "123") > 0);     /* One more version segment */

1✔

974

        assert_se(strverscmp_improved("12_3", "123") < 0);     /* 12 < 123 */

1✔

975

        assert_se(strverscmp_improved("12_3", "12") > 0);      /* 3 > '' */

1✔

976

        assert_se(strverscmp_improved("12_3", "12.3") > 0);    /* 3 > '' */

1✔

977

        assert_se(strverscmp_improved("123.0", "123") > 0);    /* 0 > '' */

1✔

978

        assert_se(strverscmp_improved("123_0", "123") > 0);    /* 0 > '' */

1✔

979

        assert_se(strverscmp_improved("123..0", "123.0") < 0); /* '' < 0 */

1✔

982

        assert_se(strverscmp_improved("", NULL) == 0);

1✔

983

        assert_se(strverscmp_improved(NULL, "") == 0);

1✔

984

        assert_se(strverscmp_improved("0_", "0") == 0);

1✔

985

        assert_se(strverscmp_improved("_0_", "0") == 0);

1✔

986

        assert_se(strverscmp_improved("_0", "0") == 0);

1✔

987

        assert_se(strverscmp_improved("0", "0___") == 0);

1✔

988

        assert_se(strverscmp_improved("", "_") == 0);

1✔

989

        assert_se(strverscmp_improved("_", "") == 0);

1✔

990

        assert_se(strverscmp_improved("_", "_") == 0);

1✔

991

        assert_se(strverscmp_improved("", "~") > 0);

1✔

992

        assert_se(strverscmp_improved("~", "") < 0);

1✔

993

        assert_se(strverscmp_improved("~", "~") == 0);

1✔

996

        (void) setlocale(LC_NUMERIC, "ar_YE.utf8");

1✔

997

        assert_se(strverscmp_improved("1٠١٢٣٤٥٦٧٨٩", "1") == 0);

1✔

999

        (void) setlocale(LC_NUMERIC, "th_TH.utf8");

1✔

1000

        assert_se(strverscmp_improved("1๐๑๒๓๔๕๖๗๘๙", "1") == 0);

1✔

1001

1✔

1006

TEST(strverscmp_improved_rpm) {

1✔

1012

        RPMVERCMP(1.0, 1.0, 0);

1✔

1013

        RPMVERCMP(1.0, 2.0, -1);

1✔

1014

        RPMVERCMP(2.0, 1.0, 1);

1✔

1016

        RPMVERCMP(2.0.1, 2.0.1, 0);

1✔

1017

        RPMVERCMP(2.0, 2.0.1, -1);

1✔

1018

        RPMVERCMP(2.0.1, 2.0, 1);

1✔

1020

        RPMVERCMP(2.0.1a, 2.0.1a, 0);

1✔

1021

        RPMVERCMP(2.0.1a, 2.0.1, 1);

1✔

1022

        RPMVERCMP(2.0.1, 2.0.1a, -1);

1✔

1024

        RPMVERCMP(5.5p1, 5.5p1, 0);

1✔

1025

        RPMVERCMP(5.5p1, 5.5p2, -1);

1✔

1026

        RPMVERCMP(5.5p2, 5.5p1, 1);

1✔

1028

        RPMVERCMP(5.5p10, 5.5p10, 0);

1✔

1029

        RPMVERCMP(5.5p1, 5.5p10, -1);

1✔

1030

        RPMVERCMP(5.5p10, 5.5p1, 1);

1✔

1032

        RPMVERCMP(10xyz, 10.1xyz, 1);    /* Note: this is reversed from rpm's vercmp */

1✔

1033

        RPMVERCMP(10.1xyz, 10xyz, -1);   /* Note: this is reversed from rpm's vercmp */

1✔

1035

        RPMVERCMP(xyz10, xyz10, 0);

1✔

1036

        RPMVERCMP(xyz10, xyz10.1, -1);

1✔

1037

        RPMVERCMP(xyz10.1, xyz10, 1);

1✔

1039

        RPMVERCMP(xyz.4, xyz.4, 0);

1✔

1040

        RPMVERCMP(xyz.4, 8, -1);

1✔

1041

        RPMVERCMP(8, xyz.4, 1);

1✔

1042

        RPMVERCMP(xyz.4, 2, -1);

1✔

1043

        RPMVERCMP(2, xyz.4, 1);

1✔

1045

        RPMVERCMP(5.5p2, 5.6p1, -1);

1✔

1046

        RPMVERCMP(5.6p1, 5.5p2, 1);

1✔

1048

        RPMVERCMP(5.6p1, 6.5p1, -1);

1✔

1049

        RPMVERCMP(6.5p1, 5.6p1, 1);

1✔

1051

        RPMVERCMP(6.0.rc1, 6.0, 1);

1✔

1052

        RPMVERCMP(6.0, 6.0.rc1, -1);

1✔

1054

        RPMVERCMP(10b2, 10a1, 1);

1✔

1055

        RPMVERCMP(10a2, 10b2, -1);

1✔

1057

        RPMVERCMP(1.0aa, 1.0aa, 0);

1✔

1058

        RPMVERCMP(1.0a, 1.0aa, -1);

1✔

1059

        RPMVERCMP(1.0aa, 1.0a, 1);

1✔

1061

        RPMVERCMP(10.0001, 10.0001, 0);

1✔

1062

        RPMVERCMP(10.0001, 10.1, 0);

1✔

1063

        RPMVERCMP(10.1, 10.0001, 0);

1✔

1064

        RPMVERCMP(10.0001, 10.0039, -1);

1✔

1065

        RPMVERCMP(10.0039, 10.0001, 1);

1✔

1067

        RPMVERCMP(4.999.9, 5.0, -1);

1✔

1068

        RPMVERCMP(5.0, 4.999.9, 1);

1✔

1070

        RPMVERCMP(20101121, 20101121, 0);

1✔

1071

        RPMVERCMP(20101121, 20101122, -1);

1✔

1072

        RPMVERCMP(20101122, 20101121, 1);

1✔

1074

        RPMVERCMP(2_0, 2_0, 0);

1✔

1075

        RPMVERCMP(2.0, 2_0, -1);   /* Note: in rpm those compare equal */

1✔

1076

        RPMVERCMP(2_0, 2.0, 1);    /* Note: in rpm those compare equal */

1✔

1079

        RPMVERCMP(a, a, 0);

1✔

1080

        RPMVERCMP(a+, a+, 0);

1✔

1081

        RPMVERCMP(a+, a_, 0);

1✔

1082

        RPMVERCMP(a_, a+, 0);

1✔

1083

        RPMVERCMP(+a, +a, 0);

1✔

1084

        RPMVERCMP(+a, _a, 0);

1✔

1085

        RPMVERCMP(_a, +a, 0);

1✔

1086

        RPMVERCMP(+_, +_, 0);

1✔

1087

        RPMVERCMP(_+, +_, 0);

1✔

1088

        RPMVERCMP(_+, _+, 0);

1✔

1089

        RPMVERCMP(+, _, 0);

1✔

1090

        RPMVERCMP(_, +, 0);

1✔

1093

        RPMVERCMP(1.0~rc1, 1.0~rc1, 0);

1✔

1094

        RPMVERCMP(1.0~rc1, 1.0, -1);

1✔

1095

        RPMVERCMP(1.0, 1.0~rc1, 1);

1✔

1096

        RPMVERCMP(1.0~rc1, 1.0~rc2, -1);

1✔

1097

        RPMVERCMP(1.0~rc2, 1.0~rc1, 1);

1✔

1098

        RPMVERCMP(1.0~rc1~git123, 1.0~rc1~git123, 0);

1✔

1099

        RPMVERCMP(1.0~rc1~git123, 1.0~rc1, -1);

1✔

1100

        RPMVERCMP(1.0~rc1, 1.0~rc1~git123, 1);

1✔

1103

        RPMVERCMP(1.0^, 1.0^, 0);

1✔

1104

        RPMVERCMP(1.0^, 1.0, 1);

1✔

1105

        RPMVERCMP(1.0, 1.0^, -1);

1✔

1106

        RPMVERCMP(1.0^git1, 1.0^git1, 0);

1✔

1107

        RPMVERCMP(1.0^git1, 1.0, 1);

1✔

1108

        RPMVERCMP(1.0, 1.0^git1, -1);

1✔

1109

        RPMVERCMP(1.0^git1, 1.0^git2, -1);

1✔

1110

        RPMVERCMP(1.0^git2, 1.0^git1, 1);

1✔

1111

        RPMVERCMP(1.0^git1, 1.01, -1);

1✔

1112

        RPMVERCMP(1.01, 1.0^git1, 1);

1✔

1113

        RPMVERCMP(1.0^20160101, 1.0^20160101, 0);

1✔

1114

        RPMVERCMP(1.0^20160101, 1.0.1, -1);

1✔

1115

        RPMVERCMP(1.0.1, 1.0^20160101, 1);

1✔

1116

        RPMVERCMP(1.0^20160101^git1, 1.0^20160101^git1, 0);

1✔

1117

        RPMVERCMP(1.0^20160102, 1.0^20160101^git1, 1);

1✔

1118

        RPMVERCMP(1.0^20160101^git1, 1.0^20160102, -1);

1✔

1121

        RPMVERCMP(1.0~rc1^git1, 1.0~rc1^git1, 0);

1✔

1122

        RPMVERCMP(1.0~rc1^git1, 1.0~rc1, 1);

1✔

1123

        RPMVERCMP(1.0~rc1, 1.0~rc1^git1, -1);

1✔

1124

        RPMVERCMP(1.0^git1~pre, 1.0^git1~pre, 0);

1✔

1125

        RPMVERCMP(1.0^git1, 1.0^git1~pre, 1);

1✔

1126

        RPMVERCMP(1.0^git1~pre, 1.0^git1, -1);

1✔

1131

        log_info("/* RPM version comparison oddities */");

1✔

1133

        RPMVERCMP(1b.fc17, 1b.fc17, 0);

1✔

1134

        RPMVERCMP(1b.fc17, 1.fc17, 1); /* Note: this is reversed from rpm's vercmp, WAT! */

1✔

1135

        RPMVERCMP(1.fc17, 1b.fc17, -1);

1✔

1136

        RPMVERCMP(1g.fc17, 1g.fc17, 0);

1✔

1137

        RPMVERCMP(1g.fc17, 1.fc17, 1);

1✔

1138

        RPMVERCMP(1.fc17, 1g.fc17, -1);

1✔

1141

        RPMVERCMP(1.1.α, 1.1.α, 0);

1✔

1142

        RPMVERCMP(1.1.α, 1.1.β, 0);

1✔

1143

        RPMVERCMP(1.1.β, 1.1.α, 0);

1✔

1144

        RPMVERCMP(1.1.αα, 1.1.α, 0);

1✔

1145

        RPMVERCMP(1.1.α, 1.1.ββ, 0);

1✔

1146

        RPMVERCMP(1.1.ββ, 1.1.αα, 0);

1✔

1147

1✔

1149

TEST(strextendf) {

1✔

1150

        _cleanup_free_ char *p = NULL;

2✔

1152

        assert_se(strextendf(&p, "<%i>", 77) >= 0);

1✔

1153

        ASSERT_STREQ(p, "<77>");

1✔

1155

        assert_se(strextendf(&p, "<%i>", 99) >= 0);

1✔

1156

        ASSERT_STREQ(p, "<77><99>");

1✔

1158

        assert_se(strextendf(&p, "<%80i>", 88) >= 0);

1✔

1159

        ASSERT_STREQ(p, "<77><99><                                                                              88>");

1✔

1161

        assert_se(strextendf(&p, "<%08x>", 0x1234u) >= 0);

1✔

1162

        ASSERT_STREQ(p, "<77><99><                                                                              88><00001234>");

1✔

1164

        p = mfree(p);

1✔

1166

        assert_se(strextendf_with_separator(&p, ",", "<%i>", 77) >= 0);

1✔

1167

        ASSERT_STREQ(p, "<77>");

1✔

1169

        assert_se(strextendf_with_separator(&p, ",", "<%i>", 99) >= 0);

1✔

1170

        ASSERT_STREQ(p, "<77>,<99>");

1✔

1172

        assert_se(strextendf_with_separator(&p, ",", "<%80i>", 88) >= 0);

1✔

1173

        ASSERT_STREQ(p, "<77>,<99>,<                                                                              88>");

1✔

1175

        assert_se(strextendf_with_separator(&p, ",", "<%08x>", 0x1234u) >= 0);

1✔

1176

        ASSERT_STREQ(p, "<77>,<99>,<                                                                              88>,<00001234>");

1✔

1177

1✔

1179

TEST(string_replace_char) {

1✔

1180

        ASSERT_STREQ(string_replace_char(strdupa_safe(""), 'a', 'b'), "");

1✔

1181

        ASSERT_STREQ(string_replace_char(strdupa_safe("abc"), 'a', 'b'), "bbc");

1✔

1182

        ASSERT_STREQ(string_replace_char(strdupa_safe("hoge"), 'a', 'b'), "hoge");

1✔

1183

        ASSERT_STREQ(string_replace_char(strdupa_safe("aaaa"), 'a', 'b'), "bbbb");

1✔

1184

        ASSERT_STREQ(string_replace_char(strdupa_safe("aaaa"), 'a', '\t'), "\t\t\t\t");

1✔

1185

1✔

1187

TEST(strspn_from_end) {

1✔

1188

        assert_se(strspn_from_end(NULL, NULL) == 0);

1✔

1189

        assert_se(strspn_from_end("hoge", NULL) == 0);

1✔

1190

        assert_se(strspn_from_end(NULL, DIGITS) == 0);

1✔

1191

        assert_se(strspn_from_end("", DIGITS) == 0);

1✔

1192

        assert_se(strspn_from_end("hoge", DIGITS) == 0);

1✔

1193

        assert_se(strspn_from_end("1234", DIGITS) == 4);

1✔

1194

        assert_se(strspn_from_end("aaa1234", DIGITS) == 4);

1✔

1195

        assert_se(strspn_from_end("aaa1234aaa", DIGITS) == 0);

1✔

1196

        assert_se(strspn_from_end("aaa12aa34", DIGITS) == 2);

1✔

1197

1✔

1199

TEST(streq_skip_trailing_chars) {

1✔

1201

        assert_se(streq_skip_trailing_chars("foo bar", "foo bar", NULL));

1✔

1202

        assert_se(streq_skip_trailing_chars("foo", "foo", NULL));

1✔

1203

        assert_se(streq_skip_trailing_chars("foo bar      ", "foo bar", NULL));

1✔

1204

        assert_se(streq_skip_trailing_chars("foo bar", "foo bar\t\t", NULL));

1✔

1205

        assert_se(streq_skip_trailing_chars("foo bar  ", "foo bar\t\t", NULL));

1✔

1206

        assert_se(streq_skip_trailing_chars("foo\nbar", "foo\nbar", NULL));

1✔

1207

        assert_se(streq_skip_trailing_chars("\t\tfoo bar", "\t\tfoo bar", NULL));

1✔

1208

        assert_se(streq_skip_trailing_chars(" foo bar\t", " foo bar\n", NULL));

1✔

1210

        assert_se(!streq_skip_trailing_chars("foobar", "foo bar", NULL));

1✔

1211

        assert_se(!streq_skip_trailing_chars("foo\nbar", "foo\tbar", NULL));

1✔

1212

        assert_se(!streq_skip_trailing_chars("\t\nfoo bar", "\t foo bar", NULL));

1✔

1214

        assert_se(streq_skip_trailing_chars("foo bar      ", "foo bar", WHITESPACE));

1✔

1215

        assert_se(!streq_skip_trailing_chars("foo bar      ", "foo bar", NEWLINE));

1✔

1217

        assert_se(streq_skip_trailing_chars(NULL, NULL, NULL));

1✔

1218

        assert_se(streq_skip_trailing_chars("", "", NULL));

1✔

1219

        assert_se(!streq_skip_trailing_chars(NULL, "foo bar", NULL));

1✔

1220

        assert_se(!streq_skip_trailing_chars("foo", NULL, NULL));

1✔

1221

        assert_se(!streq_skip_trailing_chars("", "f", NULL));

1✔

1222

1✔

1231

TEST(make_cstring) {

1✔

1232

        static const char test1[] = "this is a test",

1✔

1241

        TEST_MAKE_CSTRING_ONE(test1, -EINVAL, MAKE_CSTRING_REFUSE_TRAILING_NUL, NULL);

1✔

1242

        TEST_MAKE_CSTRING_ONE(test1, 0, MAKE_CSTRING_ALLOW_TRAILING_NUL, "this is a test");

1✔

1243

        TEST_MAKE_CSTRING_ONE(test1, 0, MAKE_CSTRING_REQUIRE_TRAILING_NUL, "this is a test");

1✔

1245

        TEST_MAKE_CSTRING_ONE(test2, -EINVAL, MAKE_CSTRING_REFUSE_TRAILING_NUL, NULL);

1✔

1246

        TEST_MAKE_CSTRING_ONE(test2, 0, MAKE_CSTRING_ALLOW_TRAILING_NUL, "");

1✔

1247

        TEST_MAKE_CSTRING_ONE(test2, 0, MAKE_CSTRING_REQUIRE_TRAILING_NUL, "");

1✔

1249

        TEST_MAKE_CSTRING_ONE(test3, -EINVAL, MAKE_CSTRING_REFUSE_TRAILING_NUL, NULL);

1✔

1250

        TEST_MAKE_CSTRING_ONE(test3, 0, MAKE_CSTRING_ALLOW_TRAILING_NUL, "a");

1✔

1251

        TEST_MAKE_CSTRING_ONE(test3, 0, MAKE_CSTRING_REQUIRE_TRAILING_NUL, "a");

1✔

1253

        TEST_MAKE_CSTRING_ONE(test4, -EINVAL, MAKE_CSTRING_REFUSE_TRAILING_NUL, NULL);

1✔

1254

        TEST_MAKE_CSTRING_ONE(test4, -EINVAL, MAKE_CSTRING_ALLOW_TRAILING_NUL, NULL);

1✔

1255

        TEST_MAKE_CSTRING_ONE(test4, -EINVAL, MAKE_CSTRING_REQUIRE_TRAILING_NUL, NULL);

1✔

1257

        TEST_MAKE_CSTRING_ONE(test5, -EINVAL, MAKE_CSTRING_REFUSE_TRAILING_NUL, NULL);

1✔

1258

        TEST_MAKE_CSTRING_ONE(test5, -EINVAL, MAKE_CSTRING_ALLOW_TRAILING_NUL, NULL);

1✔

1259

        TEST_MAKE_CSTRING_ONE(test5, -EINVAL, MAKE_CSTRING_REQUIRE_TRAILING_NUL, NULL);

1✔

1261

        TEST_MAKE_CSTRING_ONE(test6, 0, MAKE_CSTRING_REFUSE_TRAILING_NUL, "");

1✔

1262

        TEST_MAKE_CSTRING_ONE(test6, 0, MAKE_CSTRING_ALLOW_TRAILING_NUL, "");

1✔

1263

        TEST_MAKE_CSTRING_ONE(test6, -EINVAL, MAKE_CSTRING_REQUIRE_TRAILING_NUL, NULL);

1✔

1265

        TEST_MAKE_CSTRING_ONE(test7, 0, MAKE_CSTRING_REFUSE_TRAILING_NUL, "x");

1✔

1266

        TEST_MAKE_CSTRING_ONE(test7, 0, MAKE_CSTRING_ALLOW_TRAILING_NUL, "x");

1✔

1267

        TEST_MAKE_CSTRING_ONE(test7, -EINVAL, MAKE_CSTRING_REQUIRE_TRAILING_NUL, NULL);

1✔

1269

        TEST_MAKE_CSTRING_ONE(test8, 0, MAKE_CSTRING_REFUSE_TRAILING_NUL, "xyz");

1✔

1270

        TEST_MAKE_CSTRING_ONE(test8, 0, MAKE_CSTRING_ALLOW_TRAILING_NUL, "xyz");

1✔

1271

        TEST_MAKE_CSTRING_ONE(test8, -EINVAL, MAKE_CSTRING_REQUIRE_TRAILING_NUL, NULL);

1✔

1272

1✔

1274

TEST(find_line_startswith) {

1✔

1275

        static const char text[] =

1✔

1284

        static const char emptystring[] = "";

1✔

1286

        assert_se(find_line_startswith(text, "") == text);

1✔

1287

        assert_se(find_line_startswith(text, "f") == text+1);

1✔

1288

        assert_se(find_line_startswith(text, "foobar") == text+6);

1✔

1289

        assert_se(!find_line_startswith(text, "foobarx"));

1✔

1290

        assert_se(!find_line_startswith(text, "oobar"));

1✔

1291

        assert_se(find_line_startswith(text, "t") == text + 8);

1✔

1292

        assert_se(find_line_startswith(text, "th") == text + 9);

1✔

1293

        assert_se(find_line_startswith(text, "this") == text + 11);

1✔

1294

        assert_se(find_line_startswith(text, "foobarf") == text + 54);

1✔

1295

        assert_se(find_line_startswith(text, "more\n") == text + 41);

1✔

1296

        assert_se(find_line_startswith(text, "\n") == text + 42);

1✔

1297

        assert_se(find_line_startswith(text, "iff") == text + 63);

1✔

1299

        assert_se(find_line_startswith(emptystring, "") == emptystring);

1✔

1300

        assert_se(!find_line_startswith(emptystring, "x"));

1✔

1301

1✔

1303

TEST(strstrafter) {

1✔

1304

        static const char buffer[] = "abcdefghijklmnopqrstuvwxyz";

1✔

1306

        assert_se(!strstrafter(NULL, NULL));

1✔

1307

        assert_se(!strstrafter("", NULL));

1✔

1308

        assert_se(!strstrafter(NULL, ""));

1✔

1309

        ASSERT_STREQ(strstrafter("", ""), "");

1✔

1311

        assert_se(strstrafter(buffer, "a") == buffer + 1);

1✔

1312

        assert_se(strstrafter(buffer, "") == buffer);

1✔

1313

        assert_se(strstrafter(buffer, "ab") == buffer + 2);

1✔

1314

        assert_se(strstrafter(buffer, "cde") == buffer + 5);

1✔

1315

        assert_se(strstrafter(buffer, "xyz") == strchr(buffer, 0));

1✔

1316

        assert_se(strstrafter(buffer, buffer) == strchr(buffer, 0));

1✔

1317

        assert_se(!strstrafter(buffer, "-"));

1✔

1318

1✔

1320

TEST(version_is_valid) {

1✔

1321

        assert_se(!version_is_valid(NULL));

1✔

1322

        assert_se(!version_is_valid(""));

1✔

1323

        assert_se(version_is_valid("0"));

1✔

1324

        assert_se(version_is_valid("5"));

1✔

1325

        assert_se(version_is_valid("999999"));

1✔

1326

        assert_se(version_is_valid("999999.5"));

1✔

1327

        assert_se(version_is_valid("6.2.12-300.fc38.x86_64"));

1✔

1328

1✔

1330

TEST(strextendn) {

1✔

1331

        _cleanup_free_ char *x = NULL;

2✔

1333

        ASSERT_STREQ(strextendn(&x, NULL, 0), "");

1✔

1334

        x = mfree(x);

1✔

1336

        ASSERT_STREQ(strextendn(&x, "", 0), "");

1✔

1337

        x = mfree(x);

1✔

1339

        ASSERT_STREQ(strextendn(&x, "xxx", 3), "xxx");

1✔

1340

        ASSERT_STREQ(strextendn(&x, "xxx", 3), "xxxxxx");

1✔

1341

        ASSERT_STREQ(strextendn(&x, "...", 1), "xxxxxx.");

1✔

1342

        ASSERT_STREQ(strextendn(&x, "...", 2), "xxxxxx...");

1✔

1343

        ASSERT_STREQ(strextendn(&x, "...", 3), "xxxxxx......");

1✔

1344

        ASSERT_STREQ(strextendn(&x, "...", 4), "xxxxxx.........");

1✔

1345

        x = mfree(x);

1✔

1346

1✔

1348

TEST(strprepend) {

1✔

1349

        _cleanup_free_ char *x = NULL;

2✔

1351

        ASSERT_STREQ(strprepend(&x, NULL), "");

1✔

1352

        x = mfree(x);

1✔

1354

        ASSERT_STREQ(strprepend(&x, ""), "");

1✔

1356

        ASSERT_STREQ(strprepend(&x, "xxx"), "xxx");

1✔

1357

        ASSERT_STREQ(strprepend(&x, "bar"), "barxxx");

1✔

1358

        ASSERT_STREQ(strprepend(&x, "foo"), "foobarxxx");

1✔

1359

1✔

1361

TEST(strlevenshtein) {

1✔

1362

        assert_se(strlevenshtein(NULL, NULL) == 0);

1✔

1363

        assert_se(strlevenshtein("", "") == 0);

1✔

1364

        assert_se(strlevenshtein("", NULL) == 0);

1✔

1365

        assert_se(strlevenshtein(NULL, "") == 0);

1✔

1367

        assert_se(strlevenshtein("a", "a") == 0);

1✔

1368

        assert_se(strlevenshtein("a", "b") == 1);

1✔

1369

        assert_se(strlevenshtein("b", "a") == 1);

1✔

1370

        assert_se(strlevenshtein("a", "") == 1);

1✔

1371

        assert_se(strlevenshtein("", "a") == 1);

1✔

1373

        assert_se(strlevenshtein("xxx", "xxx") == 0);

1✔

1374

        assert_se(strlevenshtein("xxx", "yyy") == 3);

1✔

1375

        assert_se(strlevenshtein("yyy", "xxx") == 3);

1✔

1376

        assert_se(strlevenshtein("xx", "xxx") == 1);

1✔

1377

        assert_se(strlevenshtein("xxx", "xx") == 1);

1✔

1378

        assert_se(strlevenshtein("x", "xxx") == 2);

1✔

1379

        assert_se(strlevenshtein("xxx", "x") == 2);

1✔

1381

        assert_se(strlevenshtein("sitting", "kitten") == 3);

1✔

1382

        assert_se(strlevenshtein("sunday", "saturday") == 3);

1✔

1383

1✔

1385

TEST(strrstr) {

1✔

1386

        assert_se(!strrstr(NULL, NULL));

1✔

1387

        assert_se(!strrstr("foo", NULL));

1✔

1388

        assert_se(!strrstr(NULL, "foo"));

1✔

1390

        const char *p = "foo";

1✔

1391

        assert_se(strrstr(p, "foo") == p);

1✔

1392

        assert_se(strrstr(p, "fo") == p);

1✔

1393

        assert_se(strrstr(p, "f") == p);

1✔

1394

        assert_se(strrstr(p, "oo") == p + 1);

1✔

1395

        assert_se(strrstr(p, "o") == p + 2);

1✔

1396

        assert_se(strrstr(p, "") == p + strlen(p));

1✔

1397

        assert_se(!strrstr(p, "bar"));

1✔

1399

        p = "xoxoxox";

1✔

1400

        assert_se(strrstr(p, "") == p + strlen(p));

1✔

1401

        assert_se(strrstr(p, "x") == p + 6);

1✔

1402

        assert_se(strrstr(p, "ox") == p + 5);

1✔

1403

        assert_se(strrstr(p, "xo") == p + 4);

1✔

1404

        assert_se(strrstr(p, "xox") == p + 4);

1✔

1405

        assert_se(!strrstr(p, "xx"));

1✔

1406

1✔

1408

TEST(str_common_prefix) {

1✔

1409

        ASSERT_EQ(str_common_prefix("", ""), SIZE_MAX);

1✔

1410

        ASSERT_EQ(str_common_prefix("a", "a"), SIZE_MAX);

1✔

1411

        ASSERT_EQ(str_common_prefix("aa", "aa"), SIZE_MAX);

1✔

1412

        ASSERT_EQ(str_common_prefix("aa", "bb"), 0U);

1✔

1413

        ASSERT_EQ(str_common_prefix("bb", "aa"), 0U);

1✔

1414

        ASSERT_EQ(str_common_prefix("aa", "ab"), 1U);

1✔

1415

        ASSERT_EQ(str_common_prefix("ab", "aa"), 1U);

1✔

1416

        ASSERT_EQ(str_common_prefix("systemd-resolved", "systemd-networkd"), 8U);

1✔

1417

        ASSERT_EQ(str_common_prefix("systemd-", "systemd-networkd"), 8U);

1✔

1418

        ASSERT_EQ(str_common_prefix("systemd-networkd", "systemd-"), 8U);

1✔

1419

        ASSERT_EQ(str_common_prefix("syst", "systemd-networkd"), 4U);

1✔

1420

        ASSERT_EQ(str_common_prefix("systemd-networkd", "syst"), 4U);

1✔

1421

        ASSERT_EQ(str_common_prefix("s", "systemd-networkd"), 1U);

1✔

1422

        ASSERT_EQ(str_common_prefix("systemd-networkd", "s"), 1U);

1✔

1423

        ASSERT_EQ(str_common_prefix("", "systemd-networkd"), 0U);

1✔

1424

        ASSERT_EQ(str_common_prefix("systemd-networkd", ""), 0U);

1✔

1425

1✔

1427

DEFINE_TEST_MAIN(LOG_DEBUG);

1✔

systemd / systemd / 15175033720

Source File
Press 'n' to go to next uncovered line, 'b' for previous

systemd / systemd / 15175033720

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous