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

14

TEST(ellipsize_mem_ansi_short) {

1✔

15

        _cleanup_free_ char *a = ellipsize_mem("X\x1b[m", 4, 1, 50);

1✔

16

        assert_se(a);

1✔

18

        _cleanup_free_ char *b = ellipsize_mem(" \x1b[A", 4, 1, 0);

1✔

19

        assert_se(b);

1✔

21

        _cleanup_free_ char *c = ellipsize_mem("\x1b[m", 3, 1, 50);

1✔

22

        assert_se(c);

1✔

23

1✔

25

TEST(xsprintf) {

1✔

26

        char buf[5];

1✔

28

        xsprintf(buf, "asdf");

1✔

29

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

1✔

30

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

1✔

31

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

1✔

33

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

1✔

34

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

1✔

35

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

1✔

36

1✔

38

TEST(string_erase) {

1✔

39

        char *x;

1✔

40

        x = strdupa_safe("");

1✔

41

        ASSERT_STREQ(string_erase(x), "");

1✔

43

        x = strdupa_safe("1");

1✔

44

        ASSERT_STREQ(string_erase(x), "");

1✔

46

        x = strdupa_safe("123456789");

1✔

47

        ASSERT_STREQ(string_erase(x), "");

1✔

49

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

1✔

50

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

1✔

51

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

1✔

52

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

1✔

53

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

1✔

54

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

1✔

55

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

1✔

56

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

1✔

57

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

1✔

58

1✔

60

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

25✔

61

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

54✔

64

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

25✔

65

        ASSERT_STREQ(*t, expected);

25✔

66

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

25✔

67

25✔

69

TEST(free_and_strndup) {

1✔

70

        static const struct test_case {

1✔

105

        _cleanup_free_ char *t = NULL;

2✔

106

        const char *prev_expected = t;

1✔

108

        FOREACH_ELEMENT(c, cases) {

26✔

109

                test_free_and_strndup_one(&t,

25✔

110

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

25✔

111

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

25✔

112

                prev_expected = t;

25✔

114

1✔

116

TEST(strdup_to_full) {

1✔

117

        _cleanup_free_ char *dst;

2✔

119

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

1✔

120

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

1✔

122

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

1✔

123

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

1✔

124

        ASSERT_STREQ(dst, "");

1✔

125

        dst = mfree(dst);

1✔

127

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

1✔

128

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

1✔

129

        ASSERT_STREQ(dst, "x");

1✔

130

1✔

132

TEST(strdup_to) {

1✔

133

        _cleanup_free_ char *dst;

2✔

135

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

1✔

137

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

1✔

138

        ASSERT_STREQ(dst, "");

1✔

139

        dst = mfree(dst);

1✔

141

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

1✔

142

        ASSERT_STREQ(dst, "x");

1✔

143

1✔

145

TEST(ascii_strcasecmp_n) {

1✔

146

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

1✔

147

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

1✔

148

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

1✔

149

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

1✔

150

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

1✔

151

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

1✔

152

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

1✔

153

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

1✔

154

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

1✔

155

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

1✔

156

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

1✔

157

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

1✔

158

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

1✔

159

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

1✔

160

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

1✔

161

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

1✔

162

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

1✔

164

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

1✔

165

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

1✔

166

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

1✔

167

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

1✔

168

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

1✔

169

1✔

171

TEST(ascii_strcasecmp_nn) {

1✔

172

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

1✔

173

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

1✔

174

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

1✔

175

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

1✔

177

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

1✔

178

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

1✔

179

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

1✔

180

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

1✔

181

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

1✔

183

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

1✔

184

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

1✔

185

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

1✔

186

1✔

188

TEST(cellescape) {

1✔

189

        char buf[40];

1✔

191

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

1✔

192

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

1✔

193

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

1✔

195

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

1✔

196

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

1✔

197

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

1✔

198

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

1✔

200

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

1✔

201

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

1✔

202

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

1✔

203

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

1✔

204

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

1✔

206

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

1✔

207

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

1✔

208

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

1✔

209

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

1✔

210

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

1✔

211

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

1✔

213

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

1✔

214

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

1✔

215

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

1✔

216

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

1✔

217

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

1✔

218

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

1✔

219

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

1✔

221

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

1✔

222

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

1✔

223

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

1✔

224

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

1✔

225

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

1✔

227

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

1✔

228

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

1✔

229

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

1✔

230

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

1✔

231

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

1✔

233

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

1✔

234

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

1✔

235

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

1✔

236

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

1✔

237

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

1✔

239

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

1✔

240

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

1✔

241

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

1✔

242

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

1✔

243

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

1✔

245

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

1✔

246

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

1✔

247

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

1✔

248

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

1✔

249

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

1✔

250

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

1✔

251

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

1✔

253

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

1✔

254

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

1✔

255

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

1✔

257

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

1✔

258

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

1✔

260

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

1✔

261

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

1✔

262

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

1✔

263

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

1✔

265

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

1✔

266

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

1✔

267

1✔

269

TEST(streq_ptr) {

1✔

270

        assert_se(streq_ptr(NULL, NULL));

1✔

271

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

1✔

272

1✔

274

TEST(strstrip) {

1✔

275

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

1✔

277

        ret = strstrip(input);

1✔

278

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

1✔

279

1✔

281

TEST(strextend) {

1✔

282

        _cleanup_free_ char *str = NULL;

2✔

284

        assert_se(strextend(&str, NULL));

1✔

285

        ASSERT_STREQ(str, "");

1✔

286

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

1✔

287

        ASSERT_STREQ(str, "0123");

1✔

288

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

1✔

289

        ASSERT_STREQ(str, "0123456789");

1✔

291

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

1✔

292

        ASSERT_STREQ(str, "0123456789more");

1✔

294

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

1✔

295

        ASSERT_STREQ(str, "0123456789moreMOREHUCH");

1✔

296

1✔

298

TEST(strextend_with_separator) {

1✔

299

        _cleanup_free_ char *str = NULL;

2✔

301

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

1✔

302

        ASSERT_STREQ(str, "");

1✔

303

        str = mfree(str);

1✔

305

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

1✔

306

        ASSERT_STREQ(str, "");

1✔

307

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

1✔

308

        ASSERT_STREQ(str, "");

1✔

309

        str = mfree(str);

1✔

311

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

1✔

312

        ASSERT_STREQ(str, "axyzbbxyzccc");

1✔

313

        str = mfree(str);

1✔

315

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

1✔

316

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

1✔

317

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

1✔

318

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

1✔

320

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

1✔

321

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

1✔

322

1✔

324

TEST(strrep) {

1✔

326

        char *onea, *threea;

1✔

328

        one = strrep("waldo", 1);

1✔

329

        three = strrep("waldo", 3);

1✔

330

        zero = strrep("waldo", 0);

1✔

332

        ASSERT_STREQ(one, "waldo");

1✔

333

        ASSERT_STREQ(three, "waldowaldowaldo");

1✔

334

        ASSERT_STREQ(zero, "");

1✔

336

        onea = strrepa("waldo", 1);

2✔

337

        threea = strrepa("waldo", 3);

4✔

339

        ASSERT_STREQ(onea, "waldo");

1✔

340

        ASSERT_STREQ(threea, "waldowaldowaldo");

1✔

342

        ASSERT_NULL(strrep("waldo", SIZE_MAX - 1));

1✔

343

1✔

345

TEST(string_has_cc) {

1✔

346

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

1✔

347

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

1✔

348

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

1✔

349

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

1✔

350

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

1✔

351

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

1✔

352

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

1✔

354

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

1✔

355

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

1✔

356

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

1✔

357

1✔

359

TEST(ascii_strlower) {

1✔

360

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

1✔

361

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

1✔

362

1✔

364

TEST(strshorten) {

1✔

365

        char s[] = "foobar";

1✔

367

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

1✔

368

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

1✔

369

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

1✔

370

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

1✔

371

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

1✔

372

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

1✔

373

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

1✔

374

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

1✔

375

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

1✔

376

1✔

378

TEST(strjoina) {

1✔

379

        char *actual;

1✔

381

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

7✔

382

        ASSERT_STREQ(actual, "foobar");

1✔

384

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

7✔

385

        ASSERT_STREQ(actual, "foobarbaz");

1✔

387

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

9✔

388

        ASSERT_STREQ(actual, "foobarbaz");

1✔

390

        actual = strjoina("foo");

3✔

391

        ASSERT_STREQ(actual, "foo");

1✔

393

        actual = strjoina(NULL);

1✔

394

        ASSERT_STREQ(actual, "");

1✔

396

        actual = strjoina(NULL, "foo");

1✔

397

        ASSERT_STREQ(actual, "");

1✔

399

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

3✔

400

        ASSERT_STREQ(actual, "foo");

1✔

402

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

9✔

403

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

1✔

405

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

5✔

406

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

1✔

407

1✔

409

TEST(strjoin) {

1✔

410

        char *actual;

1✔

412

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

1✔

413

        ASSERT_STREQ(actual, "foobar");

1✔

414

        free(actual);

1✔

416

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

1✔

417

        ASSERT_STREQ(actual, "foobarbaz");

1✔

418

        free(actual);

1✔

420

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

1✔

421

        ASSERT_STREQ(actual, "foobarbaz");

1✔

422

        free(actual);

1✔

424

        actual = strjoin("foo", NULL);

1✔

425

        ASSERT_STREQ(actual, "foo");

1✔

426

        free(actual);

1✔

428

        actual = strjoin(NULL, NULL);

1✔

429

        ASSERT_STREQ(actual, "");

1✔

430

        free(actual);

1✔

432

        actual = strjoin(NULL, "foo");

1✔

433

        ASSERT_STREQ(actual, "");

1✔

434

        free(actual);

1✔

436

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

1✔

437

        ASSERT_STREQ(actual, "foo");

1✔

438

        free(actual);

1✔

440

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

1✔

441

        ASSERT_STREQ(actual, "foobar");

1✔

442

        free(actual);

1✔

443

1✔

445

TEST(strcmp_ptr) {

1✔

446

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

1✔

447

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

1✔

448

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

1✔

449

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

1✔

450

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

1✔

451

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

1✔

452

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

1✔

453

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

1✔

454

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

1✔

455

1✔

457

TEST(foreach_word) {

1✔

458

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

1✔

459

        const char * const expected[] = {

1✔

467

        size_t i = 0;

1✔

468

        int r;

1✔

469

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

1✔

470

                _cleanup_free_ char *word = NULL;

5✔

472

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

6✔

473

                if (r == 0) {

6✔

474

                        assert_se(i == ELEMENTSOF(expected));

1✔

475

                        break;

1✔

477

                assert_se(r > 0);

5✔

479

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

5✔

481

1✔

483

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

3✔

484

        size_t i = 0;

3✔

485

        int r;

3✔

487

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

3✔

488

        for (;;) {

29✔

489

                _cleanup_free_ char *word = NULL;

13✔

491

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

16✔

492

                if (r == 0) {

16✔

493

                        assert_se(!trailing);

1✔

495

                } else if (r < 0) {

15✔

496

                        assert_se(trailing);

2✔

500

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

13✔

501

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

13✔

503

        ASSERT_NULL(expected[i]);

3✔

504

3✔

506

TEST(foreach_word_quoted) {

1✔

507

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

1✔

508

              STRV_MAKE("test",

1✔

522

        check("test \"xxx",

1✔

523

              STRV_MAKE("test"),

1✔

526

        check("test\\",

1✔

529

1✔

531

TEST(endswith) {

1✔

532

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

1✔

533

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

1✔

534

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

1✔

535

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

1✔

537

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

1✔

538

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

1✔

539

1✔

541

TEST(endswith_no_case) {

1✔

542

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

1✔

543

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

1✔

544

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

1✔

545

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

1✔

547

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

1✔

548

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

1✔

549

1✔

551

TEST(strrstr_no_case) {

1✔

552

        ASSERT_STREQ(strrstr_no_case("fooBARfoobar", "bar"), "bar");

1✔

553

        ASSERT_STREQ(strrstr_no_case("fooBARfoobar", "BAR"), "bar");

1✔

554

        ASSERT_STREQ(strrstr_no_case("fooBARfoobar", "bAR"), "bar");

1✔

555

        ASSERT_STREQ(strrstr_no_case("fooBARfoobar", "FOO"), "foobar");

1✔

556

        ASSERT_STREQ(strrstr_no_case("fooBARfoobar", "foo"), "foobar");

1✔

557

        ASSERT_STREQ(strrstr_no_case("fooBARfoobar", "FoO"), "foobar");

1✔

558

        ASSERT_STREQ(strrstr_no_case("aXaXa", "x"), "Xa");

1✔

559

        ASSERT_STREQ(strrstr_no_case("aXaXa", "X"), "Xa");

1✔

560

        ASSERT_STREQ(strrstr_no_case("xHello", "hello"), "Hello");

1✔

561

        ASSERT_STREQ(strrstr_no_case("Hello", "l"), "lo");

1✔

562

        ASSERT_STREQ(strrstr_no_case("Hello", ""), "");

1✔

563

        ASSERT_STREQ(strrstr_no_case("", ""), "");

1✔

564

        ASSERT_STREQ(strrstr_no_case("FOO", "foo"), "FOO");

1✔

565

        ASSERT_STREQ(strrstr_no_case("hello", "hello"), "hello");

1✔

566

        ASSERT_STREQ(strrstr_no_case("X", "x"), "X");

1✔

568

        ASSERT_NULL(strrstr_no_case("hello", "xyz"));

1✔

569

        ASSERT_NULL(strrstr_no_case("", "x"));

1✔

570

        ASSERT_NULL(strrstr_no_case(NULL, "x"));

1✔

571

        ASSERT_NULL(strrstr_no_case("x", NULL));

1✔

572

1✔

574

TEST(delete_chars) {

1✔

575

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

1✔

577

        s = delete_chars(input, WHITESPACE);

1✔

578

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

1✔

579

        assert_se(s == input);

1✔

580

1✔

582

TEST(delete_trailing_chars) {

1✔

583

        char *s,

1✔

584

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

1✔

585

                input2[] = "kkkkthiskkkiskkkaktestkkk",

1✔

586

                input3[] = "abcdef";

1✔

588

        s = delete_trailing_chars(input1, WHITESPACE);

1✔

589

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

1✔

590

        assert_se(s == input1);

1✔

592

        s = delete_trailing_chars(input2, "kt");

1✔

593

        ASSERT_STREQ(s, "kkkkthiskkkiskkkaktes");

1✔

594

        assert_se(s == input2);

1✔

596

        s = delete_trailing_chars(input3, WHITESPACE);

1✔

597

        ASSERT_STREQ(s, "abcdef");

1✔

598

        assert_se(s == input3);

1✔

600

        s = delete_trailing_chars(input3, "fe");

1✔

601

        ASSERT_STREQ(s, "abcd");

1✔

602

        assert_se(s == input3);

1✔

603

1✔

605

TEST(delete_trailing_slashes) {

1✔

606

        char s1[] = "foobar//",

1✔

607

             s2[] = "foobar/",

1✔

608

             s3[] = "foobar",

1✔

609

             s4[] = "";

1✔

611

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

1✔

612

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

1✔

613

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

1✔

614

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

1✔

615

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

1✔

616

1✔

618

TEST(skip_leading_chars) {

1✔

619

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

1✔

620

                input2[] = "kkkkthiskkkiskkkaktestkkk",

1✔

621

                input3[] = "abcdef";

1✔

623

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

1✔

624

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

1✔

625

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

1✔

626

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

1✔

627

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

1✔

628

1✔

630

TEST(in_charset) {

1✔

631

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

1✔

632

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

1✔

633

1✔

635

TEST(split_pair) {

1✔

638

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

1✔

639

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

1✔

640

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

1✔

641

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

1✔

642

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

1✔

643

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

1✔

644

        ASSERT_STREQ(a, "foo");

1✔

645

        ASSERT_STREQ(b, "bar");

1✔

646

        a = mfree(a);

1✔

647

        b = mfree(b);

1✔

648

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

1✔

649

        ASSERT_STREQ(a, "");

1✔

650

        ASSERT_STREQ(b, "");

1✔

651

        a = mfree(a);

1✔

652

        b = mfree(b);

1✔

653

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

1✔

654

        ASSERT_STREQ(a, "");

1✔

655

        ASSERT_STREQ(b, "=");

1✔

656

        a = mfree(a);

1✔

657

        b = mfree(b);

1✔

660

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

1✔

661

        ASSERT_NULL(a);

1✔

662

        ASSERT_STREQ(b, "bar");

1✔

663

        b = mfree(b);

1✔

664

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

1✔

665

        ASSERT_STREQ(a, "foo");

1✔

666

        ASSERT_NULL(b);

1✔

667

        a = mfree(a);

1✔

668

        ASSERT_OK(split_pair("foo=bar", "=", NULL, NULL));

1✔

669

        ASSERT_NULL(a);

1✔

670

        ASSERT_NULL(b);

1✔

672

        ASSERT_ERROR(split_pair("foo", "=", NULL, NULL), EINVAL);

1✔

673

1✔

675

TEST(empty_to_null) {

1✔

676

        const char *s = "asdf", *n = NULL, *e = "";

1✔

677

        char *t = (char*) "asdf";

1✔

678

        const char p[] = "asdf";

1✔

679

        char q[] = "asdf";

1✔

684

        ASSERT_NULL(empty_to_null(NULL));

1✔

685

        ASSERT_NULL(empty_to_null(n));

1✔

686

        ASSERT_NULL(empty_to_null(e));

1✔

687

        ASSERT_STREQ(empty_to_null(s), "asdf");

1✔

688

        ASSERT_NULL(empty_to_null(s + 4));

1✔

689

        ASSERT_STREQ(empty_to_null(t), "asdf");

1✔

690

        ASSERT_NULL(empty_to_null(t + 4));

1✔

691

        ASSERT_STREQ(empty_to_null(&p[0]), "asdf");

1✔

692

        ASSERT_NULL(empty_to_null(&p[0] + 4));

1✔

693

        ASSERT_STREQ(empty_to_null(&q[0]), "asdf");

1✔

694

        ASSERT_NULL(empty_to_null(&q[0] + 4));

1✔

695

1✔

697

TEST(first_word) {

1✔

698

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

1✔

699

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

1✔

700

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

1✔

701

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

1✔

702

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

1✔

703

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

1✔

704

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

1✔

706

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

1✔

707

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

1✔

708

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

1✔

709

1✔

711

TEST(strlen_ptr) {

1✔

712

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

1✔

713

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

1✔

714

        assert_se(strlen_ptr(NULL) == 0);

1✔

715

1✔

717

TEST(memory_startswith) {

1✔

718

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

1✔

719

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

1✔

720

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

1✔

721

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

1✔

722

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

1✔

723

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

1✔

724

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

1✔

725

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

1✔

726

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

1✔

727

1✔

729

TEST(memory_startswith_no_case) {

1✔

730

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

1✔

731

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

1✔

732

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

1✔

733

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

1✔

734

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

1✔

735

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

1✔

736

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

1✔

737

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

1✔

738

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

1✔

739

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

1✔

740

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

1✔

741

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

1✔

742

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

1✔

743

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

1✔

744

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

1✔

746

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

1✔

747

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

1✔

748

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

1✔

749

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

1✔

750

1✔

752

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

48✔

753

        _cleanup_free_ char *b = NULL;

96✔

754

        int k;

48✔

756

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

48✔

757

        ASSERT_STREQ(b, output);

48✔

758

        assert_se(!!k == truncation);

48✔

759

48✔

761

TEST(string_truncate_lines) {

1✔

762

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

1✔

763

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

1✔

764

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

1✔

765

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

1✔

767

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

1✔

768

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

1✔

769

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

1✔

770

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

1✔

772

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

1✔

773

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

1✔

774

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

1✔

775

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

1✔

777

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

1✔

778

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

1✔

779

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

1✔

780

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

1✔

782

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

1✔

783

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

1✔

784

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

1✔

785

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

1✔

787

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

1✔

788

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

1✔

789

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

1✔

790

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

1✔

792

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

1✔

793

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

1✔

794

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

1✔

795

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

1✔

797

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

1✔

798

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

1✔

799

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

1✔

800

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

1✔

802

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

1✔

803

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

1✔

804

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

1✔

805

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

1✔

807

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

1✔

808

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

1✔

809

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

1✔

810

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

1✔

812

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

1✔

813

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

1✔

814

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

1✔

815

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

1✔

817

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

1✔

818

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

1✔

819

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

1✔

820

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

1✔

821

1✔

823

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

52✔

824

        _cleanup_free_ char *b = NULL;

104✔

825

        int k;

52✔

827

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

52✔

828

        ASSERT_STREQ(b ?: input, output);

52✔

829

        assert_se(!!k == more);

52✔

830

52✔

832

TEST(string_extract_line) {

1✔

833

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

1✔

834

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

1✔

835

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

1✔

836

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

1✔

838

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

1✔

839

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

1✔

840

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

1✔

841

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

1✔

843

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

1✔

844

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

1✔

845

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

1✔

846

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

1✔

848

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

1✔

849

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

1✔

850

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

1✔

851

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

1✔

853

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

1✔

854

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

1✔

855

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

1✔

856

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

1✔

858

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

1✔

859

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

1✔

860

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

1✔

861

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

1✔

863

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

1✔

864

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

1✔

865

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

1✔

866

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

1✔

868

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

1✔

869

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

1✔

870

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

1✔

871

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

1✔

873

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

1✔

874

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

1✔

875

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

1✔

876

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

1✔

878

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

1✔

879

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

1✔

880

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

1✔

881

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

1✔

883

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

1✔

884

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

1✔

885

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

1✔

886

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

1✔

888

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

1✔

889

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

1✔

890

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

1✔

891

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

1✔

893

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

1✔

894

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

1✔

895

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

1✔

896

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

1✔

897

1✔

899

TEST(string_contains_word_strv) {

1✔

900

        const char *w;

1✔

902

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

1✔

904

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

1✔

905

        ASSERT_STREQ(w, "a");

1✔

907

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

1✔

908

        ASSERT_NULL(w);

1✔

910

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

1✔

911

        ASSERT_STREQ(w, "a");

1✔

913

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

1✔

914

        ASSERT_STREQ(w, "b");

1✔

916

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

1✔

917

        ASSERT_STREQ(w, "b");

1✔

919

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

1✔

920

        ASSERT_NULL(w);

1✔

922

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

1✔

923

        ASSERT_STREQ(w, "");

1✔

924

1✔

926

TEST(string_contains_word) {

1✔

927

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

1✔

928

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

1✔

929

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

1✔

930

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

1✔

931

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

1✔

932

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

1✔

933

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

1✔

934

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

1✔

935

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

1✔

936

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

1✔

937

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

1✔

938

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

1✔

940

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

1✔

941

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

1✔

942

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

1✔

943

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

1✔

944

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

1✔

945

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

1✔

946

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

1✔

947

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

1✔

948

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

1✔

949

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

1✔

950

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

1✔

951

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

1✔

953

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

1✔

954

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

1✔

955

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

1✔

956

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

1✔

957

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

1✔

958

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

1✔

960

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

1✔

961

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

1✔

962

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

1✔

963

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

1✔

964

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

1✔

965

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

1✔

966

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

1✔

967

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

1✔

968

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

1✔

969

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

1✔

970

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

1✔

971

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

1✔

972

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

1✔

973

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

1✔

974

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

1✔

975

1✔

977

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

401✔

978

        int r = strverscmp_improved(a, b);

401✔

980

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

874✔

985

        assert_se(r == expected);

401✔

986

401✔

988

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

298✔

989

        test_strverscmp_improved_one(older, newer, -1);

298✔

991

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

298✔

992

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

298✔

993

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

298✔

994

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

298✔

995

298✔

997

TEST(strverscmp_improved) {

1✔

998

        static const char * const versions[] = {

1✔

1026

        STRV_FOREACH(p, versions)

25✔

1027

                STRV_FOREACH(q, p + 1)

300✔

1028

                        test_strverscmp_improved_newer(*p, *q);

276✔

1030

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

1✔

1031

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

1✔

1032

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

1✔

1033

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

1✔

1034

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

1✔

1035

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

1✔

1036

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

1✔

1037

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

1✔

1038

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

1✔

1041

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

1✔

1042

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

1✔

1043

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

1✔

1044

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

1✔

1045

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

1✔

1048

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

1✔

1049

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

1✔

1050

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

1✔

1053

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

1✔

1054

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

1✔

1055

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

1✔

1058

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

1✔

1059

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

1✔

1062

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

1✔

1065

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

1✔

1066

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

1✔

1067

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

1✔

1068

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

1✔

1069

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

1✔

1070

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

1✔

1071

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

1✔

1074

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

1✔

1075

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

1✔

1076

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

1✔

1077

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

1✔

1078

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

1✔

1079

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

1✔

1080

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

1✔

1081

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

1✔

1082

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

1✔

1083

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

1✔

1084

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

1✔

1085

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

1✔

1088

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

1✔

1089

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

1✔

1091

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

1✔

1092

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

1✔

1093

1✔

1098

TEST(strverscmp_improved_rpm) {

1✔

1104

        RPMVERCMP(1.0, 1.0, 0);

1✔

1105

        RPMVERCMP(1.0, 2.0, -1);

1✔

1106

        RPMVERCMP(2.0, 1.0, 1);

1✔

1108

        RPMVERCMP(2.0.1, 2.0.1, 0);

1✔

1109

        RPMVERCMP(2.0, 2.0.1, -1);

1✔

1110

        RPMVERCMP(2.0.1, 2.0, 1);

1✔

1112

        RPMVERCMP(2.0.1a, 2.0.1a, 0);

1✔

1113

        RPMVERCMP(2.0.1a, 2.0.1, 1);

1✔

1114

        RPMVERCMP(2.0.1, 2.0.1a, -1);

1✔

1116

        RPMVERCMP(5.5p1, 5.5p1, 0);

1✔

1117

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

1✔

1118

        RPMVERCMP(5.5p2, 5.5p1, 1);

1✔

1120

        RPMVERCMP(5.5p10, 5.5p10, 0);

1✔

1121

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

1✔

1122

        RPMVERCMP(5.5p10, 5.5p1, 1);

1✔

1124

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

1✔

1125

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

1✔

1127

        RPMVERCMP(xyz10, xyz10, 0);

1✔

1128

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

1✔

1129

        RPMVERCMP(xyz10.1, xyz10, 1);

1✔

1131

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

1✔

1132

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

1✔

1133

        RPMVERCMP(8, xyz.4, 1);

1✔

1134

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

1✔

1135

        RPMVERCMP(2, xyz.4, 1);

1✔

1137

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

1✔

1138

        RPMVERCMP(5.6p1, 5.5p2, 1);

1✔

1140

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

1✔

1141

        RPMVERCMP(6.5p1, 5.6p1, 1);

1✔

1143

        RPMVERCMP(6.0.rc1, 6.0, 1);

1✔

1144

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

1✔

1146

        RPMVERCMP(10b2, 10a1, 1);

1✔

1147

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

1✔

1149

        RPMVERCMP(1.0aa, 1.0aa, 0);

1✔

1150

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

1✔

1151

        RPMVERCMP(1.0aa, 1.0a, 1);

1✔

1153

        RPMVERCMP(10.0001, 10.0001, 0);

1✔

1154

        RPMVERCMP(10.0001, 10.1, 0);

1✔

1155

        RPMVERCMP(10.1, 10.0001, 0);

1✔

1156

        RPMVERCMP(10.0001, 10.0039, -1);

1✔

1157

        RPMVERCMP(10.0039, 10.0001, 1);

1✔

1159

        RPMVERCMP(4.999.9, 5.0, -1);

1✔

1160

        RPMVERCMP(5.0, 4.999.9, 1);

1✔

1162

        RPMVERCMP(20101121, 20101121, 0);

1✔

1163

        RPMVERCMP(20101121, 20101122, -1);

1✔

1164

        RPMVERCMP(20101122, 20101121, 1);

1✔

1166

        RPMVERCMP(2_0, 2_0, 0);

1✔

1167

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

1✔

1168

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

1✔

1171

        RPMVERCMP(a, a, 0);

1✔

1172

        RPMVERCMP(a+, a+, 0);

1✔

1173

        RPMVERCMP(a+, a_, 0);

1✔

1174

        RPMVERCMP(a_, a+, 0);

1✔

1175

        RPMVERCMP(+a, +a, 0);

1✔

1176

        RPMVERCMP(+a, _a, 0);

1✔

1177

        RPMVERCMP(_a, +a, 0);

1✔

1178

        RPMVERCMP(+_, +_, 0);

1✔

1179

        RPMVERCMP(_+, +_, 0);

1✔

1180

        RPMVERCMP(_+, _+, 0);

1✔

1181

        RPMVERCMP(+, _, 0);

1✔

1182

        RPMVERCMP(_, +, 0);

1✔

1185

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

1✔

1186

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

1✔

1187

        RPMVERCMP(1.0, 1.0~rc1, 1);

1✔

1188

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

1✔

1189

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

1✔

1190

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

1✔

1191

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

1✔

1192

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

1✔

1195

        RPMVERCMP(1.0^, 1.0^, 0);

1✔

1196

        RPMVERCMP(1.0^, 1.0, 1);

1✔

1197

        RPMVERCMP(1.0, 1.0^, -1);

1✔

1198

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

1✔

1199

        RPMVERCMP(1.0^git1, 1.0, 1);

1✔

1200

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

1✔

1201

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

1✔

1202

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

1✔

1203

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

1✔

1204

        RPMVERCMP(1.01, 1.0^git1, 1);

1✔

1205

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

1✔

1206

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

1✔

1207

        RPMVERCMP(1.0.1, 1.0^20160101, 1);

1✔

1208

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

1✔

1209

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

1✔

1210

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

1✔

1213

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

1✔

1214

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

1✔

1215

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

1✔

1216

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

1✔

1217

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

1✔

1218

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

1✔

1223

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

1✔

1225

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

1✔

1226

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

1✔

1227

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

1✔

1228

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

1✔

1229

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

1✔

1230

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

1✔

1233

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

1✔

1234

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

1✔

1235

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

1✔

1236

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

1✔

1237

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

1✔

1238

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

1✔

1239

1✔

1241

TEST(strextendf) {

1✔

1242

        _cleanup_free_ char *p = NULL;

2✔

1244

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

1✔

1245

        ASSERT_STREQ(p, "<77>");

1✔

1247

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

1✔

1248

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

1✔

1250

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

1✔

1251

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

1✔

1253

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

1✔

1254

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

1✔

1256

        p = mfree(p);

1✔

1258

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

1✔

1259

        ASSERT_STREQ(p, "<77>");

1✔

1261

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

1✔

1262

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

1✔

1264

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

1✔

1265

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

1✔

1267

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

1✔

1268

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

1✔

1269

1✔

1271

TEST(string_replace_char) {

1✔

1272

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

1✔

1273

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

1✔

1274

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

1✔

1275

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

1✔

1276

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

1✔

1277

1✔

1279

TEST(strspn_from_end) {

1✔

1280

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

1✔

1281

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

1✔

1282

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

1✔

1283

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

1✔

1284

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

1✔

1285

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

1✔

1286

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

1✔

1287

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

1✔

1288

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

1✔

1289

1✔

1291

TEST(streq_skip_trailing_chars) {

1✔

1293

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

1✔

1294

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

1✔

1295

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

1✔

1296

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

1✔

1297

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

1✔

1298

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

1✔

1299

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

1✔

1300

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

1✔

1302

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

1✔

1303

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

1✔

1304

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

1✔

1306

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

1✔

1307

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

1✔

1309

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

1✔

1310

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

1✔

1311

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

1✔

1312

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

1✔

1313

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

1✔

1314

1✔

1323

TEST(make_cstring) {

1✔

1324

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

1✔

1333

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

1✔

1334

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

1✔

1335

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

1✔

1337

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

1✔

1338

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

1✔

1339

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

1✔

1341

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

1✔

1342

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

1✔

1343

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

1✔

1345

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

1✔

1346

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

1✔

1347

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

1✔

1349

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

1✔

1350

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

1✔

1351

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

1✔

1353

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

1✔

1354

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

1✔

1355

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

1✔

1357

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

1✔

1358

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

1✔

1359

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

1✔

1361

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

1✔

1362

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

1✔

1363

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

1✔

1364

1✔

1366

TEST(find_line_startswith) {

1✔

1367

        static const char text[] =

1✔

1376

        static const char emptystring[] = "";

1✔

1378

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

1✔

1379

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

1✔

1380

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

1✔

1381

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

1✔

1382

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

1✔

1383

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

1✔

1384

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

1✔

1385

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

1✔

1386

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

1✔

1387

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

1✔

1388

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

1✔

1389

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

1✔

1391

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

1✔

1392

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

1✔

1393

1✔

1395

TEST(strstrafter) {

1✔

1396

        static const char buffer[] = "abcdefghijklmnopqrstuvwxyz";

1✔

1398

        assert_se(!strstrafter(NULL, NULL));

1✔

1399

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

1✔

1400

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

1✔

1401

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

1✔

1403

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

1✔

1404

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

1✔

1405

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

1✔

1406

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

1✔

1407

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

1✔

1408

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

1✔

1409

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

1✔

1410

1✔

1412

TEST(version_is_valid) {

1✔

1413

        ASSERT_FALSE(version_is_valid(NULL, /* flags= */ 0));

1✔

1414

        ASSERT_FALSE(version_is_valid("", /* flags= */ 0));

1✔

1415

        ASSERT_TRUE(version_is_valid("0", /* flags= */ 0));

1✔

1416

        ASSERT_TRUE(version_is_valid("5", /* flags= */ 0));

1✔

1417

        ASSERT_TRUE(version_is_valid("999999", /* flags= */ 0));

1✔

1418

        ASSERT_TRUE(version_is_valid("999999.5", /* flags= */ 0));

1✔

1419

        ASSERT_TRUE(version_is_valid("6.2.12-300.fc38.x86_64", VERSION_ALLOW_UNDERSCORE));

1✔

1420

        ASSERT_TRUE(version_is_valid("6.2.12-300.fc38.x86_64", VERSION_ALLOW_UNDERSCORE|VERSION_ALLOW_PLUS));

1✔

1421

        ASSERT_FALSE(version_is_valid("6.2.12-300.fc38.x86_64", VERSION_ALLOW_PLUS));

1✔

1422

        ASSERT_FALSE(version_is_valid("6.2.12-300.fc38.x86_64", /* flags= */ 0));

1✔

1424

        struct utsname u;

1✔

1425

        ASSERT_OK_ERRNO(uname(&u));

1✔

1426

        ASSERT_TRUE(version_is_valid(u.release, VERSION_ALLOW_UNDERSCORE|VERSION_ALLOW_PLUS));

1✔

1428

        ASSERT_TRUE(version_is_valid(GIT_VERSION, VERSION_ALLOW_UNDERSCORE|VERSION_ALLOW_PLUS));

1✔

1429

        ASSERT_TRUE(version_is_valid(PROJECT_VERSION_STR, /* flags= */ 0));

1✔

1432

        ASSERT_TRUE(version_is_valid("", VERSION_ALLOW_EMPTY));

1✔

1433

        ASSERT_TRUE(version_is_valid("", VERSION_ALLOW_EMPTY|VERSION_ALLOW_UNDERSCORE|VERSION_ALLOW_PLUS));

1✔

1434

        ASSERT_FALSE(version_is_valid("", VERSION_ALLOW_UNDERSCORE|VERSION_ALLOW_PLUS));

1✔

1435

        ASSERT_FALSE(version_is_valid(NULL, VERSION_ALLOW_EMPTY));

1✔

1436

        ASSERT_FALSE(version_is_valid(NULL, VERSION_ALLOW_EMPTY|VERSION_ALLOW_UNDERSCORE|VERSION_ALLOW_PLUS));

1✔

1439

        ASSERT_TRUE(version_is_valid("1.2~rc1^5", /* flags= */ 0));

1✔

1440

        ASSERT_TRUE(version_is_valid("1.2~rc1^5", VERSION_ALLOW_EMPTY|VERSION_ALLOW_UNDERSCORE|VERSION_ALLOW_PLUS));

1✔

1443

        ASSERT_FALSE(version_is_valid("1_2", /* flags= */ 0));

1✔

1444

        ASSERT_TRUE(version_is_valid("1_2", VERSION_ALLOW_UNDERSCORE));

1✔

1445

        ASSERT_FALSE(version_is_valid("1_2", VERSION_ALLOW_PLUS));

1✔

1446

        ASSERT_FALSE(version_is_valid("1_2", VERSION_ALLOW_EMPTY));

1✔

1447

        ASSERT_FALSE(version_is_valid("1+2", /* flags= */ 0));

1✔

1448

        ASSERT_TRUE(version_is_valid("1+2", VERSION_ALLOW_PLUS));

1✔

1449

        ASSERT_FALSE(version_is_valid("1+2", VERSION_ALLOW_UNDERSCORE));

1✔

1450

        ASSERT_FALSE(version_is_valid("1+2", VERSION_ALLOW_EMPTY));

1✔

1451

        ASSERT_FALSE(version_is_valid("1_2+3", VERSION_ALLOW_UNDERSCORE));

1✔

1452

        ASSERT_FALSE(version_is_valid("1_2+3", VERSION_ALLOW_PLUS));

1✔

1453

        ASSERT_TRUE(version_is_valid("1_2+3", VERSION_ALLOW_UNDERSCORE|VERSION_ALLOW_PLUS));

1✔

1456

        ASSERT_FALSE(version_is_valid("1 2", VERSION_ALLOW_EMPTY|VERSION_ALLOW_UNDERSCORE|VERSION_ALLOW_PLUS));

1✔

1457

        ASSERT_FALSE(version_is_valid("1/2", VERSION_ALLOW_EMPTY|VERSION_ALLOW_UNDERSCORE|VERSION_ALLOW_PLUS));

1✔

1458

        ASSERT_FALSE(version_is_valid("1=2", VERSION_ALLOW_EMPTY|VERSION_ALLOW_UNDERSCORE|VERSION_ALLOW_PLUS));

1✔

1459

        ASSERT_FALSE(version_is_valid("1\n2", VERSION_ALLOW_EMPTY|VERSION_ALLOW_UNDERSCORE|VERSION_ALLOW_PLUS));

1✔

1460

        ASSERT_FALSE(version_is_valid("©", VERSION_ALLOW_EMPTY|VERSION_ALLOW_UNDERSCORE|VERSION_ALLOW_PLUS));

1✔

1463

        ASSERT_TRUE(version_is_valid(".", /* flags= */ 0));

1✔

1464

        ASSERT_TRUE(version_is_valid("..", /* flags= */ 0));

1✔

1467

        _cleanup_free_ char *x = strrep("0", NAME_MAX);

1✔

1468

        ASSERT_NOT_NULL(x);

1✔

1469

        ASSERT_TRUE(version_is_valid(x, /* flags= */ 0));

1✔

1470

        _cleanup_free_ char *y = strrep("0", NAME_MAX+1);

1✔

1471

        ASSERT_NOT_NULL(y);

1✔

1472

        ASSERT_FALSE(version_is_valid(y, /* flags= */ 0));

1✔

1473

        ASSERT_FALSE(version_is_valid(y, VERSION_ALLOW_EMPTY|VERSION_ALLOW_UNDERSCORE|VERSION_ALLOW_PLUS));

1✔

1474

1✔

1476

TEST(strextendn) {

1✔

1477

        _cleanup_free_ char *x = NULL;

2✔

1479

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

1✔

1480

        x = mfree(x);

1✔

1482

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

1✔

1483

        x = mfree(x);

1✔

1485

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

1✔

1486

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

1✔

1487

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

1✔

1488

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

1✔

1489

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

1✔

1490

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

1✔

1491

        x = mfree(x);

1✔

1492

1✔

1494

TEST(strprepend) {

1✔

1495

        _cleanup_free_ char *x = NULL;

2✔

1497

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

1✔

1498

        x = mfree(x);

1✔

1500

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

1✔

1502

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

2✔

1503

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

2✔

1504

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

2✔

1505

        x = mfree(x);

1✔

1507

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

1✔

1509

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

2✔

1510

        x = mfree(x);

1✔

1512

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

1✔

1513

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

2✔

1514

1✔

1516

TEST(strlevenshtein) {

1✔

1517

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

1✔

1518

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

1✔

1519

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

1✔

1520

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

1✔

1522

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

1✔

1523

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

1✔

1524

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

1✔

1525

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

1✔

1526

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

1✔

1528

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

1✔

1529

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

1✔

1530

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

1✔

1531

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

1✔

1532

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

1✔

1533

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

1✔

1534

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

1✔

1536

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

1✔

1537

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

1✔

1538

1✔

1540

TEST(strrstr) {

1✔

1541

        assert_se(!strrstr(NULL, NULL));

1✔

1542

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

1✔

1543

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

1✔

1545

        const char *p = "foo";

1✔

1546

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

1✔

1547

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

1✔

1548

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

1✔

1549

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

1✔

1550

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

1✔

1551

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

1✔

1552

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

1✔

1554

        p = "xoxoxox";

1✔

1555

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

1✔

1556

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

1✔

1557

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

1✔

1558

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

1✔

1559

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

1✔

1560

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

1✔

1561

1✔

1563

TEST(str_common_prefix) {

1✔

1564

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

1✔

1565

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

1✔

1566

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

1✔

1567

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

1✔

1568

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

1✔

1569

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

1✔

1570

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

1✔

1571

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

1✔

1572

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

1✔

1573

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

1✔

1574

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

1✔

1575

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

1✔

1576

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

1✔

1577

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

1✔

1578

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

1✔

1579

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

1✔

1580

1✔

1582

TEST(string_is_safe) {

1✔

1584

        ASSERT_FALSE(string_is_safe(NULL, 0));

1✔

1585

        ASSERT_FALSE(string_is_safe(NULL, STRING_ALLOW_EMPTY));

1✔

1586

        ASSERT_FALSE(string_is_safe(NULL, STRING_ASCII));

1✔

1587

        ASSERT_FALSE(string_is_safe(NULL, STRING_ALLOW_BACKSLASHES));

1✔

1588

        ASSERT_FALSE(string_is_safe(NULL, STRING_ALLOW_QUOTES));

1✔

1589

        ASSERT_FALSE(string_is_safe(NULL, STRING_ALLOW_GLOBS));

1✔

1590

        ASSERT_FALSE(string_is_safe(NULL, STRING_FILENAME));

1✔

1594

        ASSERT_TRUE(string_is_safe("hello", 0));

1✔

1595

        ASSERT_TRUE(string_is_safe("hello world", 0));

1✔

1596

        ASSERT_TRUE(string_is_safe("über", 0));             /* valid UTF-8 allowed */

1✔

1597

        ASSERT_TRUE(string_is_safe("ünïcödé", 0));

1✔

1599

        ASSERT_FALSE(string_is_safe("", 0));                /* empty rejected by default */

1✔

1600

        ASSERT_FALSE(string_is_safe("a\\b", 0));            /* backslash rejected by default */

1✔

1601

        ASSERT_FALSE(string_is_safe("\"", 0));              /* double quote rejected by default */

1✔

1602

        ASSERT_FALSE(string_is_safe("'", 0));               /* single quote rejected by default */

1✔

1603

        ASSERT_FALSE(string_is_safe("*", 0));               /* glob rejected by default */

1✔

1604

        ASSERT_FALSE(string_is_safe("?", 0));               /* glob rejected by default */

1✔

1605

        ASSERT_FALSE(string_is_safe("[", 0));               /* glob rejected by default */

1✔

1606

        ASSERT_FALSE(string_is_safe("abc\x01", 0));         /* control char */

1✔

1607

        ASSERT_FALSE(string_is_safe("\t", 0));

1✔

1608

        ASSERT_FALSE(string_is_safe("\n", 0));

1✔

1609

        ASSERT_FALSE(string_is_safe("abc\x1f", 0));

1✔

1610

        ASSERT_FALSE(string_is_safe("abc\x7f", 0));         /* DEL */

1✔

1611

        ASSERT_FALSE(string_is_safe("ab\xc3\x28", 0));      /* invalid UTF-8 continuation */

1✔

1612

        ASSERT_FALSE(string_is_safe("\xff", 0));            /* not valid UTF-8 */

1✔

1615

        ASSERT_TRUE(string_is_safe("", STRING_ALLOW_EMPTY));

1✔

1616

        ASSERT_TRUE(string_is_safe("x", STRING_ALLOW_EMPTY));

1✔

1617

        ASSERT_TRUE(string_is_safe("hello", STRING_ALLOW_EMPTY));

1✔

1618

        ASSERT_FALSE(string_is_safe(NULL, STRING_ALLOW_EMPTY));

1✔

1622

        ASSERT_TRUE(string_is_safe("hello", STRING_ASCII));

1✔

1623

        ASSERT_TRUE(string_is_safe("hello world 123!@#$%^&()", STRING_ASCII));

1✔

1624

        ASSERT_FALSE(string_is_safe("", STRING_ASCII));

1✔

1625

        ASSERT_FALSE(string_is_safe("über", STRING_ASCII));

1✔

1626

        ASSERT_FALSE(string_is_safe("\x80", STRING_ASCII));

1✔

1627

        ASSERT_FALSE(string_is_safe("\xff", STRING_ASCII));

1✔

1628

        ASSERT_FALSE(string_is_safe("abc\x01", STRING_ASCII));

1✔

1629

        ASSERT_FALSE(string_is_safe("abc\x7f", STRING_ASCII));

1✔

1630

        ASSERT_FALSE(string_is_safe("a\\b", STRING_ASCII));

1✔

1631

        ASSERT_FALSE(string_is_safe("a\"b", STRING_ASCII));

1✔

1632

        ASSERT_FALSE(string_is_safe("a*b", STRING_ASCII));

1✔

1635

        ASSERT_TRUE(string_is_safe("hello", STRING_ALLOW_NEWLINES));

1✔

1636

        ASSERT_TRUE(string_is_safe("hello world", STRING_ALLOW_NEWLINES));

1✔

1637

        ASSERT_TRUE(string_is_safe("\n", STRING_ALLOW_NEWLINES));

1✔

1638

        ASSERT_TRUE(string_is_safe("a\nb", STRING_ALLOW_NEWLINES));

1✔

1639

        ASSERT_TRUE(string_is_safe("foo\n", STRING_ALLOW_NEWLINES));

1✔

1640

        ASSERT_TRUE(string_is_safe("\nfoo", STRING_ALLOW_NEWLINES));

1✔

1641

        ASSERT_TRUE(string_is_safe("foo\nbar", STRING_ALLOW_NEWLINES));

1✔

1642

        ASSERT_FALSE(string_is_safe("foo\\nbar", STRING_ALLOW_NEWLINES)); /* literal backslash, not newline, rejected */

1✔

1643

        ASSERT_FALSE(string_is_safe("\"", STRING_ALLOW_NEWLINES));        /* quotes still rejected */

1✔

1644

        ASSERT_FALSE(string_is_safe("*", STRING_ALLOW_NEWLINES));         /* globs still rejected */

1✔

1647

        ASSERT_TRUE(string_is_safe("hello", STRING_ALLOW_BACKSLASHES));

1✔

1648

        ASSERT_TRUE(string_is_safe("hello world", STRING_ALLOW_BACKSLASHES));

1✔

1649

        ASSERT_TRUE(string_is_safe("\\", STRING_ALLOW_BACKSLASHES));

1✔

1650

        ASSERT_TRUE(string_is_safe("a\\b", STRING_ALLOW_BACKSLASHES));

1✔

1651

        ASSERT_TRUE(string_is_safe("foo\\", STRING_ALLOW_BACKSLASHES));

1✔

1652

        ASSERT_TRUE(string_is_safe("\\foo", STRING_ALLOW_BACKSLASHES));

1✔

1653

        ASSERT_TRUE(string_is_safe("foo\\nbar", STRING_ALLOW_BACKSLASHES)); /* literal backslash, not newline */

1✔

1654

        ASSERT_FALSE(string_is_safe("foo\nbar", STRING_ALLOW_BACKSLASHES)); /* newline still rejected */

1✔

1655

        ASSERT_FALSE(string_is_safe("\"", STRING_ALLOW_BACKSLASHES));       /* quotes still rejected */

1✔

1656

        ASSERT_FALSE(string_is_safe("*", STRING_ALLOW_BACKSLASHES));        /* globs still rejected */

1✔

1659

        ASSERT_TRUE(string_is_safe("hello", STRING_ALLOW_QUOTES));

1✔

1660

        ASSERT_TRUE(string_is_safe("hello world", STRING_ALLOW_QUOTES));

1✔

1661

        ASSERT_TRUE(string_is_safe("\"", STRING_ALLOW_QUOTES));

1✔

1662

        ASSERT_TRUE(string_is_safe("'", STRING_ALLOW_QUOTES));

1✔

1663

        ASSERT_TRUE(string_is_safe("hello\"world", STRING_ALLOW_QUOTES));

1✔

1664

        ASSERT_TRUE(string_is_safe("it's", STRING_ALLOW_QUOTES));

1✔

1665

        ASSERT_FALSE(string_is_safe("a\nb", STRING_ALLOW_QUOTES));          /* newline still rejected */

1✔

1666

        ASSERT_FALSE(string_is_safe("a\\b", STRING_ALLOW_QUOTES));          /* backslashes still rejected */

1✔

1667

        ASSERT_FALSE(string_is_safe("*", STRING_ALLOW_QUOTES));             /* globs still rejected */

1✔

1670

        ASSERT_TRUE(string_is_safe("hello", STRING_ALLOW_GLOBS));

1✔

1671

        ASSERT_TRUE(string_is_safe("ab]c", STRING_ALLOW_GLOBS));            /* ']' is not in GLOB_CHARS anyway */

1✔

1672

        ASSERT_TRUE(string_is_safe("*", STRING_ALLOW_GLOBS));

1✔

1673

        ASSERT_TRUE(string_is_safe("?", STRING_ALLOW_GLOBS));

1✔

1674

        ASSERT_TRUE(string_is_safe("[", STRING_ALLOW_GLOBS));

1✔

1675

        ASSERT_TRUE(string_is_safe("foo*bar", STRING_ALLOW_GLOBS));

1✔

1676

        ASSERT_TRUE(string_is_safe("foo?bar", STRING_ALLOW_GLOBS));

1✔

1677

        ASSERT_TRUE(string_is_safe("foo[bar", STRING_ALLOW_GLOBS));

1✔

1678

        ASSERT_FALSE(string_is_safe("foo\nbar", STRING_ALLOW_GLOBS));       /* newline still rejected */

1✔

1679

        ASSERT_FALSE(string_is_safe("\"", STRING_ALLOW_GLOBS));             /* quotes still rejected */

1✔

1680

        ASSERT_FALSE(string_is_safe("a\\b", STRING_ALLOW_GLOBS));           /* backslashes still rejected */

1✔

1683

        ASSERT_TRUE(string_is_safe("hello", STRING_FILENAME));

1✔

1684

        ASSERT_TRUE(string_is_safe("hello.txt", STRING_FILENAME));

1✔

1685

        ASSERT_TRUE(string_is_safe("...", STRING_FILENAME));

1✔

1686

        ASSERT_TRUE(string_is_safe(".hidden", STRING_FILENAME));

1✔

1687

        ASSERT_FALSE(string_is_safe("", STRING_FILENAME));

1✔

1688

        ASSERT_FALSE(string_is_safe(".", STRING_FILENAME));

1✔

1689

        ASSERT_FALSE(string_is_safe("..", STRING_FILENAME));

1✔

1690

        ASSERT_FALSE(string_is_safe("/", STRING_FILENAME));

1✔

1691

        ASSERT_FALSE(string_is_safe("/foo", STRING_FILENAME));

1✔

1692

        ASSERT_FALSE(string_is_safe("foo/bar", STRING_FILENAME));

1✔

1695

        ASSERT_TRUE(string_is_safe("hello", STRING_DISALLOW_WHITESPACE));

1✔

1696

        ASSERT_TRUE(string_is_safe("foo-bar_baz", STRING_DISALLOW_WHITESPACE));

1✔

1697

        ASSERT_TRUE(string_is_safe("über", STRING_DISALLOW_WHITESPACE));     /* valid UTF-8 still allowed */

1✔

1698

        ASSERT_TRUE(string_is_safe("hello world", 0));                       /* space accepted by default */

1✔

1699

        ASSERT_FALSE(string_is_safe("hello world", STRING_DISALLOW_WHITESPACE)); /* but not with the flag */

1✔

1700

        ASSERT_FALSE(string_is_safe(" ", STRING_DISALLOW_WHITESPACE));

1✔

1701

        ASSERT_FALSE(string_is_safe("foo ", STRING_DISALLOW_WHITESPACE));

1✔

1702

        ASSERT_FALSE(string_is_safe(" foo", STRING_DISALLOW_WHITESPACE));

1✔

1703

        ASSERT_FALSE(string_is_safe("a\tb", STRING_DISALLOW_WHITESPACE));

1✔

1704

        ASSERT_FALSE(string_is_safe("a\rb", STRING_DISALLOW_WHITESPACE));

1✔

1706

        ASSERT_TRUE(string_is_safe("a\nb", STRING_ALLOW_NEWLINES));

1✔

1707

        ASSERT_FALSE(string_is_safe("a\nb", STRING_ALLOW_NEWLINES | STRING_DISALLOW_WHITESPACE));

1✔

1710

        ASSERT_TRUE(string_is_safe("hello", STRING_FILENAME_PART));

1✔

1711

        ASSERT_TRUE(string_is_safe("hello.txt", STRING_FILENAME_PART));

1✔

1712

        ASSERT_TRUE(string_is_safe("...", STRING_FILENAME_PART));

1✔

1713

        ASSERT_TRUE(string_is_safe(".hidden", STRING_FILENAME_PART));

1✔

1714

        ASSERT_TRUE(string_is_safe(".", STRING_FILENAME_PART));             /* accepted, unlike STRING_FILENAME */

1✔

1715

        ASSERT_TRUE(string_is_safe("..", STRING_FILENAME_PART));            /* accepted, unlike STRING_FILENAME */

1✔

1716

        ASSERT_FALSE(string_is_safe("", STRING_FILENAME_PART));             /* empty still rejected by default */

1✔

1717

        ASSERT_TRUE(string_is_safe("", STRING_FILENAME_PART | STRING_ALLOW_EMPTY)); /* ... unless explicitly allowed */

1✔

1718

        ASSERT_FALSE(string_is_safe("/", STRING_FILENAME_PART));

1✔

1719

        ASSERT_FALSE(string_is_safe("/foo", STRING_FILENAME_PART));

1✔

1720

        ASSERT_FALSE(string_is_safe("foo/bar", STRING_FILENAME_PART));

1✔

1721

        ASSERT_FALSE(string_is_safe("foo/", STRING_FILENAME_PART));

1✔

1724

        ASSERT_TRUE(string_is_safe("", STRING_ALLOW_EMPTY | STRING_ASCII));

1✔

1725

        ASSERT_FALSE(string_is_safe("über", STRING_ALLOW_EMPTY | STRING_ASCII));

1✔

1726

        ASSERT_TRUE(string_is_safe("hello", STRING_ALLOW_EMPTY | STRING_ASCII));

1✔

1728

        ASSERT_TRUE(string_is_safe("ab\"cd", STRING_ALLOW_QUOTES | STRING_ALLOW_GLOBS));

1✔

1729

        ASSERT_TRUE(string_is_safe("ab*cd", STRING_ALLOW_QUOTES | STRING_ALLOW_GLOBS));

1✔

1730

        ASSERT_TRUE(string_is_safe("ab'*cd", STRING_ALLOW_QUOTES | STRING_ALLOW_GLOBS));

1✔

1731

        ASSERT_FALSE(string_is_safe("ab\\cd", STRING_ALLOW_QUOTES | STRING_ALLOW_GLOBS)); /* backslash still rejected */

1✔

1733

        ASSERT_TRUE(string_is_safe("hello.txt", STRING_FILENAME));

1✔

1734

        ASSERT_FALSE(string_is_safe("", STRING_FILENAME));

1✔

1735

        ASSERT_FALSE(string_is_safe("foo/bar", STRING_FILENAME));

1✔

1737

        ASSERT_TRUE(string_is_safe("foo?bar", STRING_ASCII | STRING_ALLOW_GLOBS));

1✔

1738

        ASSERT_FALSE(string_is_safe("foo\"bar", STRING_ASCII | STRING_ALLOW_GLOBS));      /* quotes still rejected */

1✔

1739

        ASSERT_FALSE(string_is_safe("über", STRING_ASCII | STRING_ALLOW_GLOBS));

1✔

1741

        ASSERT_TRUE(string_is_safe("foo\\bar", STRING_ALLOW_BACKSLASHES));

1✔

1742

        ASSERT_FALSE(string_is_safe("foo\"bar", STRING_ALLOW_BACKSLASHES));               /* quotes still rejected */

1✔

1743

        ASSERT_FALSE(string_is_safe("foo*bar", STRING_ALLOW_BACKSLASHES));                /* globs still rejected */

1✔

1744

        ASSERT_TRUE(string_is_safe("foo\\\"bar", STRING_ALLOW_BACKSLASHES | STRING_ALLOW_QUOTES));

1✔

1745

        ASSERT_TRUE(string_is_safe("foo\\bar", STRING_ALLOW_BACKSLASHES | STRING_ALLOW_QUOTES));

1✔

1746

        ASSERT_TRUE(string_is_safe("foo\"bar", STRING_ALLOW_BACKSLASHES | STRING_ALLOW_QUOTES));

1✔

1749

        StringSafeFlags all =

1✔

1757

        ASSERT_TRUE(string_is_safe("hello.txt", all));

1✔

1758

        ASSERT_TRUE(string_is_safe("foo-bar_baz.conf", all));

1✔

1759

        ASSERT_TRUE(string_is_safe("a", all));

1✔

1760

        ASSERT_TRUE(string_is_safe("foo\nbar", all));            /* newline allowed */

1✔

1761

        ASSERT_TRUE(string_is_safe("foo\\bar", all));            /* backslash allowed */

1✔

1762

        ASSERT_TRUE(string_is_safe("foo\"bar", all));            /* quote allowed */

1✔

1763

        ASSERT_TRUE(string_is_safe("foo'bar", all));             /* quote allowed */

1✔

1764

        ASSERT_TRUE(string_is_safe("foo*bar", all));             /* glob allowed */

1✔

1765

        ASSERT_TRUE(string_is_safe("foo?bar", all));             /* glob allowed */

1✔

1766

        ASSERT_TRUE(string_is_safe("foo[bar", all));             /* glob allowed */

1✔

1767

        ASSERT_FALSE(string_is_safe("", all));                   /* fails STRING_FILENAME */

1✔

1768

        ASSERT_FALSE(string_is_safe("über", all));               /* fails STRING_ASCII */

1✔

1769

        ASSERT_FALSE(string_is_safe("foo/bar", all));            /* fails STRING_FILENAME */

1✔

1770

        ASSERT_FALSE(string_is_safe(".", all));                  /* fails STRING_FILENAME */

1✔

1771

        ASSERT_FALSE(string_is_safe("..", all));                 /* fails STRING_FILENAME */

1✔

1772

        ASSERT_FALSE(string_is_safe("foo\x01""bar", all));       /* fails baseline control-char check */

1✔

1773

        ASSERT_FALSE(string_is_safe(NULL, all));

1✔

1774

1✔

1776

DEFINE_TEST_MAIN(LOG_DEBUG);

1✔

systemd / systemd / 29378720657

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

systemd / systemd / 29378720657

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