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

12

TEST(xsprintf) {

1✔

13

        char buf[5];

1✔

15

        xsprintf(buf, "asdf");

1✔

16

        xsprintf(buf, "%4s", "a");

1✔

17

        xsprintf(buf, "%-4s", "a");

1✔

18

        xsprintf(buf, "%04d", 1);

1✔

20

        ASSERT_SIGNAL(xsprintf(buf, "asdfe"), SIGABRT);

1✔

21

        ASSERT_SIGNAL(xsprintf(buf, "asdfefghdhdhdhdhd"), SIGABRT);

1✔

22

        ASSERT_SIGNAL(xsprintf(buf, "%5s", "a"), SIGABRT);

1✔

23

1✔

25

TEST(string_erase) {

1✔

26

        char *x;

1✔

27

        x = strdupa_safe("");

1✔

28

        ASSERT_STREQ(string_erase(x), "");

1✔

30

        x = strdupa_safe("1");

1✔

31

        ASSERT_STREQ(string_erase(x), "");

1✔

33

        x = strdupa_safe("123456789");

1✔

34

        ASSERT_STREQ(string_erase(x), "");

1✔

36

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

1✔

37

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

1✔

38

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

1✔

39

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

1✔

40

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

1✔

41

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

1✔

42

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

1✔

43

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

1✔

44

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

1✔

45

1✔

47

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

25✔

48

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

54✔

51

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

25✔

52

        ASSERT_STREQ(*t, expected);

25✔

53

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

25✔

54

25✔

56

TEST(free_and_strndup) {

1✔

57

        static const struct test_case {

1✔

92

        _cleanup_free_ char *t = NULL;

2✔

93

        const char *prev_expected = t;

1✔

95

        FOREACH_ELEMENT(c, cases) {

26✔

96

                test_free_and_strndup_one(&t,

25✔

97

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

25✔

98

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

25✔

99

                prev_expected = t;

25✔

101

1✔

103

TEST(strdup_to_full) {

1✔

104

        _cleanup_free_ char *dst;

2✔

106

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

1✔

107

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

1✔

109

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

1✔

110

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

1✔

111

        ASSERT_STREQ(dst, "");

1✔

112

        dst = mfree(dst);

1✔

114

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

1✔

115

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

1✔

116

        ASSERT_STREQ(dst, "x");

1✔

117

1✔

119

TEST(strdup_to) {

1✔

120

        _cleanup_free_ char *dst;

2✔

122

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

1✔

124

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

1✔

125

        ASSERT_STREQ(dst, "");

1✔

126

        dst = mfree(dst);

1✔

128

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

1✔

129

        ASSERT_STREQ(dst, "x");

1✔

130

1✔

132

TEST(ascii_strcasecmp_n) {

1✔

133

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

1✔

134

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

1✔

135

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

1✔

136

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

1✔

137

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

1✔

138

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

1✔

139

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

1✔

140

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

1✔

141

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

1✔

142

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

1✔

143

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

1✔

144

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

1✔

145

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

1✔

146

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

1✔

147

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

1✔

148

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

1✔

149

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

1✔

151

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

1✔

152

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

1✔

153

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

1✔

154

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

1✔

155

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

1✔

156

1✔

158

TEST(ascii_strcasecmp_nn) {

1✔

159

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

1✔

160

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

1✔

161

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

1✔

162

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

1✔

164

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

1✔

165

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

1✔

166

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

1✔

167

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

1✔

168

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

1✔

170

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

1✔

171

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

1✔

172

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

1✔

173

1✔

175

TEST(cellescape) {

1✔

176

        char buf[40];

1✔

178

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

1✔

179

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

1✔

180

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

1✔

182

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

1✔

183

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

1✔

184

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

1✔

185

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

1✔

187

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

1✔

188

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

1✔

189

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

1✔

190

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

1✔

191

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

1✔

193

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

1✔

194

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

1✔

195

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

1✔

196

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

1✔

197

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

1✔

198

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

1✔

200

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

1✔

201

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

1✔

202

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

1✔

203

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

1✔

204

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

1✔

205

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

1✔

206

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

1✔

208

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

1✔

209

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

1✔

210

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

1✔

211

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

1✔

212

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

1✔

214

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

1✔

215

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

1✔

216

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

1✔

217

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

1✔

218

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

1✔

220

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

1✔

221

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

1✔

222

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

1✔

223

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

1✔

224

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

1✔

226

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

1✔

227

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

1✔

228

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

1✔

229

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

1✔

230

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

1✔

232

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

1✔

233

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

1✔

234

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

1✔

235

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

1✔

236

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

1✔

237

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

1✔

238

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

1✔

240

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

1✔

241

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

1✔

242

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

1✔

244

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

1✔

245

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

1✔

247

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

1✔

248

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

1✔

249

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

1✔

250

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

1✔

252

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

1✔

253

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

1✔

254

1✔

256

TEST(streq_ptr) {

1✔

257

        assert_se(streq_ptr(NULL, NULL));

1✔

258

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

1✔

259

1✔

261

TEST(strstrip) {

1✔

262

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

1✔

264

        ret = strstrip(input);

1✔

265

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

1✔

266

1✔

268

TEST(strextend) {

1✔

269

        _cleanup_free_ char *str = NULL;

2✔

271

        assert_se(strextend(&str, NULL));

1✔

272

        ASSERT_STREQ(str, "");

1✔

273

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

1✔

274

        ASSERT_STREQ(str, "0123");

1✔

275

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

1✔

276

        ASSERT_STREQ(str, "0123456789");

1✔

278

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

1✔

279

        ASSERT_STREQ(str, "0123456789more");

1✔

281

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

1✔

282

        ASSERT_STREQ(str, "0123456789moreMOREHUCH");

1✔

283

1✔

285

TEST(strextend_with_separator) {

1✔

286

        _cleanup_free_ char *str = NULL;

2✔

288

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

1✔

289

        ASSERT_STREQ(str, "");

1✔

290

        str = mfree(str);

1✔

292

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

1✔

293

        ASSERT_STREQ(str, "");

1✔

294

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

1✔

295

        ASSERT_STREQ(str, "");

1✔

296

        str = mfree(str);

1✔

298

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

1✔

299

        ASSERT_STREQ(str, "axyzbbxyzccc");

1✔

300

        str = mfree(str);

1✔

302

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

1✔

303

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

1✔

304

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

1✔

305

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

1✔

307

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

1✔

308

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

1✔

309

1✔

311

TEST(strrep) {

1✔

313

        char *onea, *threea;

1✔

315

        one = strrep("waldo", 1);

1✔

316

        three = strrep("waldo", 3);

1✔

317

        zero = strrep("waldo", 0);

1✔

319

        ASSERT_STREQ(one, "waldo");

1✔

320

        ASSERT_STREQ(three, "waldowaldowaldo");

1✔

321

        ASSERT_STREQ(zero, "");

1✔

323

        onea = strrepa("waldo", 1);

2✔

324

        threea = strrepa("waldo", 3);

4✔

326

        ASSERT_STREQ(onea, "waldo");

1✔

327

        ASSERT_STREQ(threea, "waldowaldowaldo");

1✔

328

1✔

330

TEST(string_has_cc) {

1✔

331

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

1✔

332

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

1✔

333

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

1✔

334

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

1✔

335

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

1✔

336

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

1✔

337

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

1✔

339

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

1✔

340

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

1✔

341

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

1✔

342

1✔

344

TEST(ascii_strlower) {

1✔

345

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

1✔

346

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

1✔

347

1✔

349

TEST(strshorten) {

1✔

350

        char s[] = "foobar";

1✔

352

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

1✔

353

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

1✔

354

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

1✔

355

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

1✔

356

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

1✔

357

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

1✔

358

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

1✔

359

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

1✔

360

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

1✔

361

1✔

363

TEST(strjoina) {

1✔

364

        char *actual;

1✔

366

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

7✔

367

        ASSERT_STREQ(actual, "foobar");

1✔

369

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

7✔

370

        ASSERT_STREQ(actual, "foobarbaz");

1✔

372

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

9✔

373

        ASSERT_STREQ(actual, "foobarbaz");

1✔

375

        actual = strjoina("foo");

3✔

376

        ASSERT_STREQ(actual, "foo");

1✔

378

        actual = strjoina(NULL);

1✔

379

        ASSERT_STREQ(actual, "");

1✔

381

        actual = strjoina(NULL, "foo");

1✔

382

        ASSERT_STREQ(actual, "");

1✔

384

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

3✔

385

        ASSERT_STREQ(actual, "foo");

1✔

387

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

9✔

388

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

1✔

390

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

5✔

391

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

1✔

392

1✔

394

TEST(strjoin) {

1✔

395

        char *actual;

1✔

397

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

1✔

398

        ASSERT_STREQ(actual, "foobar");

1✔

399

        free(actual);

1✔

401

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

1✔

402

        ASSERT_STREQ(actual, "foobarbaz");

1✔

403

        free(actual);

1✔

405

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

1✔

406

        ASSERT_STREQ(actual, "foobarbaz");

1✔

407

        free(actual);

1✔

409

        actual = strjoin("foo", NULL);

1✔

410

        ASSERT_STREQ(actual, "foo");

1✔

411

        free(actual);

1✔

413

        actual = strjoin(NULL, NULL);

1✔

414

        ASSERT_STREQ(actual, "");

1✔

415

        free(actual);

1✔

417

        actual = strjoin(NULL, "foo");

1✔

418

        ASSERT_STREQ(actual, "");

1✔

419

        free(actual);

1✔

421

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

1✔

422

        ASSERT_STREQ(actual, "foo");

1✔

423

        free(actual);

1✔

425

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

1✔

426

        ASSERT_STREQ(actual, "foobar");

1✔

427

        free(actual);

1✔

428

1✔

430

TEST(strcmp_ptr) {

1✔

431

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

1✔

432

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

1✔

433

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

1✔

434

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

1✔

435

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

1✔

436

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

1✔

437

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

1✔

438

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

1✔

439

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

1✔

440

1✔

442

TEST(foreach_word) {

1✔

443

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

1✔

444

        const char * const expected[] = {

1✔

452

        size_t i = 0;

1✔

453

        int r;

1✔

454

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

1✔

455

                _cleanup_free_ char *word = NULL;

5✔

457

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

6✔

458

                if (r == 0) {

6✔

459

                        assert_se(i == ELEMENTSOF(expected));

1✔

460

                        break;

1✔

462

                assert_se(r > 0);

5✔

464

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

5✔

466

1✔

468

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

3✔

469

        size_t i = 0;

3✔

470

        int r;

3✔

472

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

3✔

473

        for (;;) {

29✔

474

                _cleanup_free_ char *word = NULL;

13✔

476

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

16✔

477

                if (r == 0) {

16✔

478

                        assert_se(!trailing);

1✔

480

                } else if (r < 0) {

15✔

481

                        assert_se(trailing);

2✔

485

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

13✔

486

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

13✔

488

        ASSERT_NULL(expected[i]);

3✔

489

3✔

491

TEST(foreach_word_quoted) {

1✔

492

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

1✔

493

              STRV_MAKE("test",

1✔

507

        check("test \"xxx",

1✔

508

              STRV_MAKE("test"),

1✔

511

        check("test\\",

1✔

512

              STRV_EMPTY,

1✔

514

1✔

516

TEST(endswith) {

1✔

517

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

1✔

518

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

1✔

519

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

1✔

520

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

1✔

522

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

1✔

523

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

1✔

524

1✔

526

TEST(endswith_no_case) {

1✔

527

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

1✔

528

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

1✔

529

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

1✔

530

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

1✔

532

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

1✔

533

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

1✔

534

1✔

536

TEST(delete_chars) {

1✔

537

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

1✔

539

        s = delete_chars(input, WHITESPACE);

1✔

540

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

1✔

541

        assert_se(s == input);

1✔

542

1✔

544

TEST(delete_trailing_chars) {

1✔

545

        char *s,

1✔

546

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

1✔

547

                input2[] = "kkkkthiskkkiskkkaktestkkk",

1✔

548

                input3[] = "abcdef";

1✔

550

        s = delete_trailing_chars(input1, WHITESPACE);

1✔

551

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

1✔

552

        assert_se(s == input1);

1✔

554

        s = delete_trailing_chars(input2, "kt");

1✔

555

        ASSERT_STREQ(s, "kkkkthiskkkiskkkaktes");

1✔

556

        assert_se(s == input2);

1✔

558

        s = delete_trailing_chars(input3, WHITESPACE);

1✔

559

        ASSERT_STREQ(s, "abcdef");

1✔

560

        assert_se(s == input3);

1✔

562

        s = delete_trailing_chars(input3, "fe");

1✔

563

        ASSERT_STREQ(s, "abcd");

1✔

564

        assert_se(s == input3);

1✔

565

1✔

567

TEST(delete_trailing_slashes) {

1✔

568

        char s1[] = "foobar//",

1✔

569

             s2[] = "foobar/",

1✔

570

             s3[] = "foobar",

1✔

571

             s4[] = "";

1✔

573

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

1✔

574

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

1✔

575

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

1✔

576

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

1✔

577

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

1✔

578

1✔

580

TEST(skip_leading_chars) {

1✔

581

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

1✔

582

                input2[] = "kkkkthiskkkiskkkaktestkkk",

1✔

583

                input3[] = "abcdef";

1✔

585

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

1✔

586

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

1✔

587

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

1✔

588

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

1✔

589

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

1✔

590

1✔

592

TEST(in_charset) {

1✔

593

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

1✔

594

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

1✔

595

1✔

597

TEST(split_pair) {

1✔

600

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

1✔

601

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

1✔

602

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

1✔

603

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

1✔

604

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

1✔

605

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

1✔

606

        ASSERT_STREQ(a, "foo");

1✔

607

        ASSERT_STREQ(b, "bar");

1✔

608

        a = mfree(a);

1✔

609

        b = mfree(b);

1✔

610

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

1✔

611

        ASSERT_STREQ(a, "");

1✔

612

        ASSERT_STREQ(b, "");

1✔

613

        a = mfree(a);

1✔

614

        b = mfree(b);

1✔

615

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

1✔

616

        ASSERT_STREQ(a, "");

1✔

617

        ASSERT_STREQ(b, "=");

1✔

618

1✔

620

TEST(first_word) {

1✔

621

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

1✔

622

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

1✔

623

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

1✔

624

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

1✔

625

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

1✔

626

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

1✔

627

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

1✔

629

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

1✔

630

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

1✔

631

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

1✔

632

1✔

634

TEST(strlen_ptr) {

1✔

635

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

1✔

636

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

1✔

637

        assert_se(strlen_ptr(NULL) == 0);

1✔

638

1✔

640

TEST(memory_startswith) {

1✔

641

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

1✔

642

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

1✔

643

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

1✔

644

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

1✔

645

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

1✔

646

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

1✔

647

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

1✔

648

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

1✔

649

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

1✔

650

1✔

652

TEST(memory_startswith_no_case) {

1✔

653

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

1✔

654

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

1✔

655

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

1✔

656

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

1✔

657

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

1✔

658

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

1✔

659

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

1✔

660

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

1✔

661

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

1✔

662

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

1✔

663

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

1✔

664

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

1✔

665

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

1✔

666

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

1✔

667

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

1✔

669

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

1✔

670

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

1✔

671

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

1✔

672

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

1✔

673

1✔

675

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

48✔

676

        _cleanup_free_ char *b = NULL;

96✔

677

        int k;

48✔

679

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

48✔

680

        ASSERT_STREQ(b, output);

48✔

681

        assert_se(!!k == truncation);

48✔

682

48✔

684

TEST(string_truncate_lines) {

1✔

685

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

1✔

686

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

1✔

687

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

1✔

688

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

1✔

690

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

1✔

691

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

1✔

692

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

1✔

693

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

1✔

695

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

1✔

696

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

1✔

697

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

1✔

698

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

1✔

700

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

1✔

701

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

1✔

702

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

1✔

703

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

1✔

705

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

1✔

706

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

1✔

707

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

1✔

708

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

1✔

710

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

1✔

711

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

1✔

712

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

1✔

713

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

1✔

715

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

1✔

716

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

1✔

717

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

1✔

718

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

1✔

720

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

1✔

721

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

1✔

722

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

1✔

723

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

1✔

725

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

1✔

726

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

1✔

727

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

1✔

728

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

1✔

730

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

1✔

731

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

1✔

732

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

1✔

733

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

1✔

735

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

1✔

736

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

1✔

737

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

1✔

738

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

1✔

740

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

1✔

741

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

1✔

742

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

1✔

743

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

1✔

744

1✔

746

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

52✔

747

        _cleanup_free_ char *b = NULL;

104✔

748

        int k;

52✔

750

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

52✔

751

        ASSERT_STREQ(b ?: input, output);

52✔

752

        assert_se(!!k == more);

52✔

753

52✔

755

TEST(string_extract_line) {

1✔

756

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

1✔

757

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

1✔

758

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

1✔

759

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

1✔

761

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

1✔

762

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

1✔

763

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

1✔

764

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

1✔

766

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

1✔

767

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

1✔

768

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

1✔

769

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

1✔

771

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

1✔

772

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

1✔

773

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

1✔

774

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

1✔

776

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

1✔

777

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

1✔

778

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

1✔

779

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

1✔

781

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

1✔

782

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

1✔

783

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

1✔

784

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

1✔

786

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

1✔

787

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

1✔

788

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

1✔

789

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

1✔

791

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

1✔

792

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

1✔

793

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

1✔

794

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

1✔

796

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

1✔

797

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

1✔

798

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

1✔

799

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

1✔

801

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

1✔

802

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

1✔

803

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

1✔

804

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

1✔

806

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

1✔

807

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

1✔

808

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

1✔

809

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

1✔

811

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

1✔

812

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

1✔

813

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

1✔

814

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

1✔

816

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

1✔

817

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

1✔

818

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

1✔

819

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

1✔

820

1✔

822

TEST(string_contains_word_strv) {

1✔

823

        const char *w;

1✔

825

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

1✔

827

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

1✔

828

        ASSERT_STREQ(w, "a");

1✔

830

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

1✔

831

        ASSERT_NULL(w);

1✔

833

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

1✔

834

        ASSERT_STREQ(w, "a");

1✔

836

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

1✔

837

        ASSERT_STREQ(w, "b");

1✔

839

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

1✔

840

        ASSERT_STREQ(w, "b");

1✔

842

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

1✔

843

        ASSERT_NULL(w);

1✔

845

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

1✔

846

        ASSERT_STREQ(w, "");

1✔

847

1✔

849

TEST(string_contains_word) {

1✔

850

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

1✔

851

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

1✔

852

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

1✔

853

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

1✔

854

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

1✔

855

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

1✔

856

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

1✔

857

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

1✔

858

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

1✔

859

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

1✔

860

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

1✔

861

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

1✔

863

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

1✔

864

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

1✔

865

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

1✔

866

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

1✔

867

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

1✔

868

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

1✔

869

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

1✔

870

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

1✔

871

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

1✔

872

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

1✔

873

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

1✔

874

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

1✔

876

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

1✔

877

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

1✔

878

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

1✔

879

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

1✔

880

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

1✔

881

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

1✔

883

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

1✔

884

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

1✔

885

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

1✔

886

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

1✔

887

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

1✔

888

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

1✔

889

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

1✔

890

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

1✔

891

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

1✔

892

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

1✔

893

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

1✔

894

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

1✔

895

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

1✔

896

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

1✔

897

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

1✔

898

1✔

900

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

401✔

901

        int r = strverscmp_improved(a, b);

401✔

903

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

874✔

908

        assert_se(r == expected);

401✔

909

401✔

911

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

298✔

912

        test_strverscmp_improved_one(older, newer, -1);

298✔

914

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

298✔

915

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

298✔

916

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

298✔

917

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

298✔

918

298✔

920

TEST(strverscmp_improved) {

1✔

921

        static const char * const versions[] = {

1✔

949

        STRV_FOREACH(p, versions)

25✔

950

                STRV_FOREACH(q, p + 1)

300✔

951

                        test_strverscmp_improved_newer(*p, *q);

276✔

953

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

1✔

954

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

1✔

955

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

1✔

956

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

1✔

957

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

1✔

958

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

1✔

959

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

1✔

960

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

1✔

961

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

1✔

964

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

1✔

965

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

1✔

966

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

1✔

967

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

1✔

968

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

1✔

971

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

1✔

972

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

1✔

973

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

1✔

976

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

1✔

977

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

1✔

978

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

1✔

981

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

1✔

982

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

1✔

985

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

1✔

988

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

1✔

989

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

1✔

990

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

1✔

991

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

1✔

992

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

1✔

993

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

1✔

994

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

1✔

997

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

1✔

998

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

1✔

999

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

1✔

1000

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

1✔

1001

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

1✔

1002

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

1✔

1003

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

1✔

1004

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

1✔

1005

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

1✔

1006

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

1✔

1007

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

1✔

1008

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

1✔

1011

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

1✔

1012

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

1✔

1014

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

1✔

1015

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

1✔

1016

1✔

1021

TEST(strverscmp_improved_rpm) {

1✔

1027

        RPMVERCMP(1.0, 1.0, 0);

1✔

1028

        RPMVERCMP(1.0, 2.0, -1);

1✔

1029

        RPMVERCMP(2.0, 1.0, 1);

1✔

1031

        RPMVERCMP(2.0.1, 2.0.1, 0);

1✔

1032

        RPMVERCMP(2.0, 2.0.1, -1);

1✔

1033

        RPMVERCMP(2.0.1, 2.0, 1);

1✔

1035

        RPMVERCMP(2.0.1a, 2.0.1a, 0);

1✔

1036

        RPMVERCMP(2.0.1a, 2.0.1, 1);

1✔

1037

        RPMVERCMP(2.0.1, 2.0.1a, -1);

1✔

1039

        RPMVERCMP(5.5p1, 5.5p1, 0);

1✔

1040

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

1✔

1041

        RPMVERCMP(5.5p2, 5.5p1, 1);

1✔

1043

        RPMVERCMP(5.5p10, 5.5p10, 0);

1✔

1044

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

1✔

1045

        RPMVERCMP(5.5p10, 5.5p1, 1);

1✔

1047

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

1✔

1048

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

1✔

1050

        RPMVERCMP(xyz10, xyz10, 0);

1✔

1051

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

1✔

1052

        RPMVERCMP(xyz10.1, xyz10, 1);

1✔

1054

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

1✔

1055

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

1✔

1056

        RPMVERCMP(8, xyz.4, 1);

1✔

1057

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

1✔

1058

        RPMVERCMP(2, xyz.4, 1);

1✔

1060

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

1✔

1061

        RPMVERCMP(5.6p1, 5.5p2, 1);

1✔

1063

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

1✔

1064

        RPMVERCMP(6.5p1, 5.6p1, 1);

1✔

1066

        RPMVERCMP(6.0.rc1, 6.0, 1);

1✔

1067

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

1✔

1069

        RPMVERCMP(10b2, 10a1, 1);

1✔

1070

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

1✔

1072

        RPMVERCMP(1.0aa, 1.0aa, 0);

1✔

1073

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

1✔

1074

        RPMVERCMP(1.0aa, 1.0a, 1);

1✔

1076

        RPMVERCMP(10.0001, 10.0001, 0);

1✔

1077

        RPMVERCMP(10.0001, 10.1, 0);

1✔

1078

        RPMVERCMP(10.1, 10.0001, 0);

1✔

1079

        RPMVERCMP(10.0001, 10.0039, -1);

1✔

1080

        RPMVERCMP(10.0039, 10.0001, 1);

1✔

1082

        RPMVERCMP(4.999.9, 5.0, -1);

1✔

1083

        RPMVERCMP(5.0, 4.999.9, 1);

1✔

1085

        RPMVERCMP(20101121, 20101121, 0);

1✔

1086

        RPMVERCMP(20101121, 20101122, -1);

1✔

1087

        RPMVERCMP(20101122, 20101121, 1);

1✔

1089

        RPMVERCMP(2_0, 2_0, 0);

1✔

1090

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

1✔

1091

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

1✔

1094

        RPMVERCMP(a, a, 0);

1✔

1095

        RPMVERCMP(a+, a+, 0);

1✔

1096

        RPMVERCMP(a+, a_, 0);

1✔

1097

        RPMVERCMP(a_, a+, 0);

1✔

1098

        RPMVERCMP(+a, +a, 0);

1✔

1099

        RPMVERCMP(+a, _a, 0);

1✔

1100

        RPMVERCMP(_a, +a, 0);

1✔

1101

        RPMVERCMP(+_, +_, 0);

1✔

1102

        RPMVERCMP(_+, +_, 0);

1✔

1103

        RPMVERCMP(_+, _+, 0);

1✔

1104

        RPMVERCMP(+, _, 0);

1✔

1105

        RPMVERCMP(_, +, 0);

1✔

1108

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

1✔

1109

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

1✔

1110

        RPMVERCMP(1.0, 1.0~rc1, 1);

1✔

1111

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

1✔

1112

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

1✔

1113

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

1✔

1114

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

1✔

1115

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

1✔

1118

        RPMVERCMP(1.0^, 1.0^, 0);

1✔

1119

        RPMVERCMP(1.0^, 1.0, 1);

1✔

1120

        RPMVERCMP(1.0, 1.0^, -1);

1✔

1121

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

1✔

1122

        RPMVERCMP(1.0^git1, 1.0, 1);

1✔

1123

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

1✔

1124

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

1✔

1125

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

1✔

1126

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

1✔

1127

        RPMVERCMP(1.01, 1.0^git1, 1);

1✔

1128

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

1✔

1129

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

1✔

1130

        RPMVERCMP(1.0.1, 1.0^20160101, 1);

1✔

1131

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

1✔

1132

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

1✔

1133

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

1✔

1136

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

1✔

1137

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

1✔

1138

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

1✔

1139

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

1✔

1140

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

1✔

1141

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

1✔

1146

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

1✔

1148

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

1✔

1149

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

1✔

1150

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

1✔

1151

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

1✔

1152

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

1✔

1153

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

1✔

1156

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

1✔

1157

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

1✔

1158

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

1✔

1159

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

1✔

1160

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

1✔

1161

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

1✔

1162

1✔

1164

TEST(strextendf) {

1✔

1165

        _cleanup_free_ char *p = NULL;

2✔

1167

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

1✔

1168

        ASSERT_STREQ(p, "<77>");

1✔

1170

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

1✔

1171

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

1✔

1173

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

1✔

1174

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

1✔

1176

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

1✔

1177

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

1✔

1179

        p = mfree(p);

1✔

1181

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

1✔

1182

        ASSERT_STREQ(p, "<77>");

1✔

1184

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

1✔

1185

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

1✔

1187

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

1✔

1188

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

1✔

1190

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

1✔

1191

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

1✔

1192

1✔

1194

TEST(string_replace_char) {

1✔

1195

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

1✔

1196

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

1✔

1197

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

1✔

1198

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

1✔

1199

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

1✔

1200

1✔

1202

TEST(strspn_from_end) {

1✔

1203

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

1✔

1204

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

1✔

1205

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

1✔

1206

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

1✔

1207

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

1✔

1208

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

1✔

1209

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

1✔

1210

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

1✔

1211

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

1✔

1212

1✔

1214

TEST(streq_skip_trailing_chars) {

1✔

1216

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

1✔

1217

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

1✔

1218

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

1✔

1219

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

1✔

1220

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

1✔

1221

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

1✔

1222

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

1✔

1223

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

1✔

1225

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

1✔

1226

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

1✔

1227

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

1✔

1229

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

1✔

1230

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

1✔

1232

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

1✔

1233

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

1✔

1234

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

1✔

1235

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

1✔

1236

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

1✔

1237

1✔

1246

TEST(make_cstring) {

1✔

1247

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

1✔

1256

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

1✔

1257

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

1✔

1258

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

1✔

1260

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

1✔

1261

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

1✔

1262

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

1✔

1264

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

1✔

1265

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

1✔

1266

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

1✔

1268

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

1✔

1269

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

1✔

1270

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

1✔

1272

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

1✔

1273

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

1✔

1274

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

1✔

1276

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

1✔

1277

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

1✔

1278

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

1✔

1280

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

1✔

1281

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

1✔

1282

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

1✔

1284

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

1✔

1285

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

1✔

1286

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

1✔

1287

1✔

1289

TEST(find_line_startswith) {

1✔

1290

        static const char text[] =

1✔

1299

        static const char emptystring[] = "";

1✔

1301

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

1✔

1302

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

1✔

1303

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

1✔

1304

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

1✔

1305

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

1✔

1306

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

1✔

1307

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

1✔

1308

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

1✔

1309

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

1✔

1310

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

1✔

1311

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

1✔

1312

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

1✔

1314

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

1✔

1315

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

1✔

1316

1✔

1318

TEST(strstrafter) {

1✔

1319

        static const char buffer[] = "abcdefghijklmnopqrstuvwxyz";

1✔

1321

        assert_se(!strstrafter(NULL, NULL));

1✔

1322

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

1✔

1323

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

1✔

1324

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

1✔

1326

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

1✔

1327

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

1✔

1328

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

1✔

1329

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

1✔

1330

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

1✔

1331

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

1✔

1332

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

1✔

1333

1✔

1335

TEST(version_is_valid) {

1✔

1336

        assert_se(!version_is_valid(NULL));

1✔

1337

        assert_se(!version_is_valid(""));

1✔

1338

        assert_se(version_is_valid("0"));

1✔

1339

        assert_se(version_is_valid("5"));

1✔

1340

        assert_se(version_is_valid("999999"));

1✔

1341

        assert_se(version_is_valid("999999.5"));

1✔

1342

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

1✔

1343

1✔

1345

TEST(strextendn) {

1✔

1346

        _cleanup_free_ char *x = NULL;

2✔

1348

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

1✔

1349

        x = mfree(x);

1✔

1351

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

1✔

1352

        x = mfree(x);

1✔

1354

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

1✔

1355

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

1✔

1356

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

1✔

1357

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

1✔

1358

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

1✔

1359

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

1✔

1360

        x = mfree(x);

1✔

1361

1✔

1363

TEST(strprepend) {

1✔

1364

        _cleanup_free_ char *x = NULL;

2✔

1366

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

1✔

1367

        x = mfree(x);

1✔

1369

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

1✔

1371

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

2✔

1372

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

2✔

1373

        ASSERT_STREQ(strprepend(&x, "foo", "4711"), "foo4711barxxx");

2✔

1374

        x = mfree(x);

1✔

1376

        ASSERT_STREQ(strprepend_with_separator(&x, "...", NULL), "");

1✔

1378

        ASSERT_STREQ(strprepend_with_separator(&x, "xyz", "a", "bb", "ccc"), "axyzbbxyzccc");

2✔

1379

        x = mfree(x);

1✔

1381

        ASSERT_STREQ(strprepend_with_separator(&x, ",", "start", "", "1", "234"), "start,,1,234");

1✔

1382

        ASSERT_STREQ(strprepend_with_separator(&x, ";", "more", "5", "678"), "more;5;678;start,,1,234");

2✔

1383

1✔

1385

TEST(strlevenshtein) {

1✔

1386

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

1✔

1387

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

1✔

1388

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

1✔

1389

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

1✔

1391

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

1✔

1392

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

1✔

1393

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

1✔

1394

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

1✔

1395

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

1✔

1397

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

1✔

1398

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

1✔

1399

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

1✔

1400

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

1✔

1401

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

1✔

1402

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

1✔

1403

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

1✔

1405

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

1✔

1406

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

1✔

1407

1✔

1409

TEST(strrstr) {

1✔

1410

        assert_se(!strrstr(NULL, NULL));

1✔

1411

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

1✔

1412

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

1✔

1414

        const char *p = "foo";

1✔

1415

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

1✔

1416

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

1✔

1417

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

1✔

1418

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

1✔

1419

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

1✔

1420

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

1✔

1421

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

1✔

1423

        p = "xoxoxox";

1✔

1424

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

1✔

1425

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

1✔

1426

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

1✔

1427

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

1✔

1428

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

1✔

1429

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

1✔

1430

1✔

1432

TEST(str_common_prefix) {

1✔

1433

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

1✔

1434

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

1✔

1435

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

1✔

1436

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

1✔

1437

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

1✔

1438

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

1✔

1439

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

1✔

1440

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

1✔

1441

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

1✔

1442

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

1✔

1443

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

1✔

1444

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

1✔

1445

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

1✔

1446

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

1✔

1447

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

1✔

1448

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

1✔

1449

1✔

1451

DEFINE_TEST_MAIN(LOG_DEBUG);

1✔

systemd / systemd / 16280725298

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

systemd / systemd / 16280725298

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