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

12

TEST(ellipsize_mem_ansi_short) {

1✔

13

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

1✔

14

        assert_se(a);

1✔

16

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

1✔

17

        assert_se(b);

1✔

19

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

1✔

20

        assert_se(c);

1✔

21

1✔

23

TEST(xsprintf) {

1✔

24

        char buf[5];

1✔

26

        xsprintf(buf, "asdf");

1✔

27

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

1✔

28

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

1✔

29

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

1✔

31

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

1✔

32

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

1✔

33

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

1✔

34

1✔

36

TEST(string_erase) {

1✔

37

        char *x;

1✔

38

        x = strdupa_safe("");

1✔

39

        ASSERT_STREQ(string_erase(x), "");

1✔

41

        x = strdupa_safe("1");

1✔

42

        ASSERT_STREQ(string_erase(x), "");

1✔

44

        x = strdupa_safe("123456789");

1✔

45

        ASSERT_STREQ(string_erase(x), "");

1✔

47

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

1✔

48

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

1✔

49

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

1✔

50

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

1✔

51

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

1✔

52

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

1✔

53

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

1✔

54

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

1✔

55

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

1✔

56

1✔

58

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

25✔

59

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

54✔

62

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

25✔

63

        ASSERT_STREQ(*t, expected);

25✔

64

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

25✔

65

25✔

67

TEST(free_and_strndup) {

1✔

68

        static const struct test_case {

1✔

103

        _cleanup_free_ char *t = NULL;

2✔

104

        const char *prev_expected = t;

1✔

106

        FOREACH_ELEMENT(c, cases) {

26✔

107

                test_free_and_strndup_one(&t,

25✔

108

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

25✔

109

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

25✔

110

                prev_expected = t;

25✔

112

1✔

114

TEST(strdup_to_full) {

1✔

115

        _cleanup_free_ char *dst;

2✔

117

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

1✔

118

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

1✔

120

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

1✔

121

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

1✔

122

        ASSERT_STREQ(dst, "");

1✔

123

        dst = mfree(dst);

1✔

125

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

1✔

126

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

1✔

127

        ASSERT_STREQ(dst, "x");

1✔

128

1✔

130

TEST(strdup_to) {

1✔

131

        _cleanup_free_ char *dst;

2✔

133

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

1✔

135

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

1✔

136

        ASSERT_STREQ(dst, "");

1✔

137

        dst = mfree(dst);

1✔

139

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

1✔

140

        ASSERT_STREQ(dst, "x");

1✔

141

1✔

143

TEST(ascii_strcasecmp_n) {

1✔

144

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

1✔

145

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

1✔

146

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

1✔

147

        assert_se(ascii_strcasecmp_n("", "a", 2) < 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", "a", 1) == 0);

1✔

151

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

1✔

152

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

1✔

153

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

1✔

154

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

1✔

155

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

1✔

156

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

1✔

157

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

1✔

158

        assert_se(ascii_strcasecmp_n("xxxxXxxxx", "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✔

162

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

1✔

163

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

1✔

164

        assert_se(ascii_strcasecmp_n("xxxxyxxxx", "xxxxXxxxx", 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

1✔

169

TEST(ascii_strcasecmp_nn) {

1✔

170

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

1✔

171

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

1✔

172

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

1✔

173

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

1✔

175

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

1✔

176

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

1✔

177

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

1✔

178

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

1✔

179

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

1✔

181

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

1✔

182

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

1✔

183

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

1✔

184

1✔

186

TEST(cellescape) {

1✔

187

        char buf[40];

1✔

189

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

1✔

190

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

1✔

191

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

1✔

193

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

1✔

194

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

1✔

195

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

1✔

196

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

1✔

198

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

1✔

199

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

1✔

200

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

1✔

201

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

1✔

202

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

1✔

204

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

1✔

205

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

1✔

206

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

1✔

207

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

1✔

208

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

1✔

209

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

1✔

211

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

1✔

212

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

1✔

213

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

1✔

214

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

1✔

215

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

1✔

216

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

1✔

217

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

1✔

219

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

1✔

220

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

1✔

221

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

1✔

222

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

1✔

223

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

1✔

225

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

1✔

226

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

1✔

227

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

1✔

228

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

1✔

229

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

1✔

231

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

1✔

232

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

1✔

233

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

1✔

234

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

1✔

235

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

1✔

237

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

1✔

238

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

1✔

239

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

1✔

240

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

1✔

241

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

1✔

243

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

1✔

244

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

1✔

245

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

1✔

246

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

1✔

247

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

1✔

248

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

1✔

249

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

1✔

251

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

1✔

252

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

1✔

253

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

1✔

255

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

1✔

256

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

1✔

258

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

1✔

259

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

1✔

260

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

1✔

261

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

1✔

263

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

1✔

264

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

1✔

265

1✔

267

TEST(streq_ptr) {

1✔

268

        assert_se(streq_ptr(NULL, NULL));

1✔

269

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

1✔

270

1✔

272

TEST(strstrip) {

1✔

273

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

1✔

275

        ret = strstrip(input);

1✔

276

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

1✔

277

1✔

279

TEST(strextend) {

1✔

280

        _cleanup_free_ char *str = NULL;

2✔

282

        assert_se(strextend(&str, NULL));

1✔

283

        ASSERT_STREQ(str, "");

1✔

284

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

1✔

285

        ASSERT_STREQ(str, "0123");

1✔

286

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

1✔

287

        ASSERT_STREQ(str, "0123456789");

1✔

289

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

1✔

290

        ASSERT_STREQ(str, "0123456789more");

1✔

292

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

1✔

293

        ASSERT_STREQ(str, "0123456789moreMOREHUCH");

1✔

294

1✔

296

TEST(strextend_with_separator) {

1✔

297

        _cleanup_free_ char *str = NULL;

2✔

299

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

1✔

300

        ASSERT_STREQ(str, "");

1✔

301

        str = mfree(str);

1✔

303

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

1✔

304

        ASSERT_STREQ(str, "");

1✔

305

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

1✔

306

        ASSERT_STREQ(str, "");

1✔

307

        str = mfree(str);

1✔

309

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

1✔

310

        ASSERT_STREQ(str, "axyzbbxyzccc");

1✔

311

        str = mfree(str);

1✔

313

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

1✔

314

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

1✔

315

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

1✔

316

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

1✔

318

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

1✔

319

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

1✔

320

1✔

322

TEST(strrep) {

1✔

324

        char *onea, *threea;

1✔

326

        one = strrep("waldo", 1);

1✔

327

        three = strrep("waldo", 3);

1✔

328

        zero = strrep("waldo", 0);

1✔

330

        ASSERT_STREQ(one, "waldo");

1✔

331

        ASSERT_STREQ(three, "waldowaldowaldo");

1✔

332

        ASSERT_STREQ(zero, "");

1✔

334

        onea = strrepa("waldo", 1);

2✔

335

        threea = strrepa("waldo", 3);

4✔

337

        ASSERT_STREQ(onea, "waldo");

1✔

338

        ASSERT_STREQ(threea, "waldowaldowaldo");

1✔

340

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

1✔

341

1✔

343

TEST(string_has_cc) {

1✔

344

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

1✔

345

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

1✔

346

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

1✔

347

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

1✔

348

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

1✔

349

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

1✔

350

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

1✔

352

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

1✔

353

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

1✔

354

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

1✔

355

1✔

357

TEST(ascii_strlower) {

1✔

358

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

1✔

359

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

1✔

360

1✔

362

TEST(strshorten) {

1✔

363

        char s[] = "foobar";

1✔

365

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

1✔

366

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

1✔

367

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

1✔

368

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

1✔

369

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

1✔

370

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

1✔

371

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

1✔

372

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

1✔

373

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

1✔

374

1✔

376

TEST(strjoina) {

1✔

377

        char *actual;

1✔

379

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

7✔

380

        ASSERT_STREQ(actual, "foobar");

1✔

382

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

7✔

383

        ASSERT_STREQ(actual, "foobarbaz");

1✔

385

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

9✔

386

        ASSERT_STREQ(actual, "foobarbaz");

1✔

388

        actual = strjoina("foo");

3✔

389

        ASSERT_STREQ(actual, "foo");

1✔

391

        actual = strjoina(NULL);

1✔

392

        ASSERT_STREQ(actual, "");

1✔

394

        actual = strjoina(NULL, "foo");

1✔

395

        ASSERT_STREQ(actual, "");

1✔

397

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

3✔

398

        ASSERT_STREQ(actual, "foo");

1✔

400

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

9✔

401

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

1✔

403

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

5✔

404

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

1✔

405

1✔

407

TEST(strjoin) {

1✔

408

        char *actual;

1✔

410

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

1✔

411

        ASSERT_STREQ(actual, "foobar");

1✔

412

        free(actual);

1✔

414

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

1✔

415

        ASSERT_STREQ(actual, "foobarbaz");

1✔

416

        free(actual);

1✔

418

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

1✔

419

        ASSERT_STREQ(actual, "foobarbaz");

1✔

420

        free(actual);

1✔

422

        actual = strjoin("foo", NULL);

1✔

423

        ASSERT_STREQ(actual, "foo");

1✔

424

        free(actual);

1✔

426

        actual = strjoin(NULL, NULL);

1✔

427

        ASSERT_STREQ(actual, "");

1✔

428

        free(actual);

1✔

430

        actual = strjoin(NULL, "foo");

1✔

431

        ASSERT_STREQ(actual, "");

1✔

432

        free(actual);

1✔

434

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

1✔

435

        ASSERT_STREQ(actual, "foo");

1✔

436

        free(actual);

1✔

438

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

1✔

439

        ASSERT_STREQ(actual, "foobar");

1✔

440

        free(actual);

1✔

441

1✔

443

TEST(strcmp_ptr) {

1✔

444

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

1✔

445

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

1✔

446

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

1✔

447

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

1✔

448

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

1✔

449

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

1✔

450

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

1✔

451

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

1✔

452

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

1✔

453

1✔

455

TEST(foreach_word) {

1✔

456

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

1✔

457

        const char * const expected[] = {

1✔

465

        size_t i = 0;

1✔

466

        int r;

1✔

467

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

1✔

468

                _cleanup_free_ char *word = NULL;

5✔

470

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

6✔

471

                if (r == 0) {

6✔

472

                        assert_se(i == ELEMENTSOF(expected));

1✔

473

                        break;

1✔

475

                assert_se(r > 0);

5✔

477

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

5✔

479

1✔

481

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

3✔

482

        size_t i = 0;

3✔

483

        int r;

3✔

485

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

3✔

486

        for (;;) {

29✔

487

                _cleanup_free_ char *word = NULL;

13✔

489

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

16✔

490

                if (r == 0) {

16✔

491

                        assert_se(!trailing);

1✔

493

                } else if (r < 0) {

15✔

494

                        assert_se(trailing);

2✔

498

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

13✔

499

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

13✔

501

        ASSERT_NULL(expected[i]);

3✔

502

3✔

504

TEST(foreach_word_quoted) {

1✔

505

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

1✔

506

              STRV_MAKE("test",

1✔

520

        check("test \"xxx",

1✔

521

              STRV_MAKE("test"),

1✔

524

        check("test\\",

1✔

527

1✔

529

TEST(endswith) {

1✔

530

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

1✔

531

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

1✔

532

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

1✔

533

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

1✔

535

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

1✔

536

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

1✔

537

1✔

539

TEST(endswith_no_case) {

1✔

540

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

1✔

541

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

1✔

542

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

1✔

543

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

1✔

545

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

1✔

546

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

1✔

547

1✔

549

TEST(strrstr_no_case) {

1✔

550

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

1✔

551

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

1✔

552

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

1✔

553

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

1✔

554

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

1✔

555

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

1✔

556

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

1✔

557

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

1✔

558

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

1✔

559

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

1✔

560

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

1✔

561

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

1✔

562

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

1✔

563

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

1✔

564

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

1✔

566

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

1✔

567

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

1✔

568

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

1✔

569

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

1✔

570

1✔

572

TEST(delete_chars) {

1✔

573

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

1✔

575

        s = delete_chars(input, WHITESPACE);

1✔

576

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

1✔

577

        assert_se(s == input);

1✔

578

1✔

580

TEST(delete_trailing_chars) {

1✔

581

        char *s,

1✔

582

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

1✔

583

                input2[] = "kkkkthiskkkiskkkaktestkkk",

1✔

584

                input3[] = "abcdef";

1✔

586

        s = delete_trailing_chars(input1, WHITESPACE);

1✔

587

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

1✔

588

        assert_se(s == input1);

1✔

590

        s = delete_trailing_chars(input2, "kt");

1✔

591

        ASSERT_STREQ(s, "kkkkthiskkkiskkkaktes");

1✔

592

        assert_se(s == input2);

1✔

594

        s = delete_trailing_chars(input3, WHITESPACE);

1✔

595

        ASSERT_STREQ(s, "abcdef");

1✔

596

        assert_se(s == input3);

1✔

598

        s = delete_trailing_chars(input3, "fe");

1✔

599

        ASSERT_STREQ(s, "abcd");

1✔

600

        assert_se(s == input3);

1✔

601

1✔

603

TEST(delete_trailing_slashes) {

1✔

604

        char s1[] = "foobar//",

1✔

605

             s2[] = "foobar/",

1✔

606

             s3[] = "foobar",

1✔

607

             s4[] = "";

1✔

609

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

1✔

610

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

1✔

611

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

1✔

612

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

1✔

613

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

1✔

614

1✔

616

TEST(skip_leading_chars) {

1✔

617

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

1✔

618

                input2[] = "kkkkthiskkkiskkkaktestkkk",

1✔

619

                input3[] = "abcdef";

1✔

621

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

1✔

622

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

1✔

623

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

1✔

624

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

1✔

625

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

1✔

626

1✔

628

TEST(in_charset) {

1✔

629

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

1✔

630

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

1✔

631

1✔

633

TEST(split_pair) {

1✔

636

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

1✔

637

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

1✔

638

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

1✔

639

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

1✔

640

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

1✔

641

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

1✔

642

        ASSERT_STREQ(a, "foo");

1✔

643

        ASSERT_STREQ(b, "bar");

1✔

644

        a = mfree(a);

1✔

645

        b = mfree(b);

1✔

646

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

1✔

647

        ASSERT_STREQ(a, "");

1✔

648

        ASSERT_STREQ(b, "");

1✔

649

        a = mfree(a);

1✔

650

        b = mfree(b);

1✔

651

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

1✔

652

        ASSERT_STREQ(a, "");

1✔

653

        ASSERT_STREQ(b, "=");

1✔

654

        a = mfree(a);

1✔

655

        b = mfree(b);

1✔

658

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

1✔

659

        ASSERT_NULL(a);

1✔

660

        ASSERT_STREQ(b, "bar");

1✔

661

        b = mfree(b);

1✔

662

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

1✔

663

        ASSERT_STREQ(a, "foo");

1✔

664

        ASSERT_NULL(b);

1✔

665

        a = mfree(a);

1✔

666

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

1✔

667

        ASSERT_NULL(a);

1✔

668

        ASSERT_NULL(b);

1✔

670

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

1✔

671

1✔

673

TEST(empty_to_null) {

1✔

674

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

1✔

675

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

1✔

676

        const char p[] = "asdf";

1✔

677

        char q[] = "asdf";

1✔

682

        ASSERT_NULL(empty_to_null(NULL));

1✔

683

        ASSERT_NULL(empty_to_null(n));

1✔

684

        ASSERT_NULL(empty_to_null(e));

1✔

685

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

1✔

686

        ASSERT_NULL(empty_to_null(s + 4));

1✔

687

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

1✔

688

        ASSERT_NULL(empty_to_null(t + 4));

1✔

689

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

1✔

690

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

1✔

691

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

1✔

692

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

1✔

693

1✔

695

TEST(first_word) {

1✔

696

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

1✔

697

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

1✔

698

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

1✔

699

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

1✔

700

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

1✔

701

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

1✔

702

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

1✔

704

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

1✔

705

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

1✔

706

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

1✔

707

1✔

709

TEST(strlen_ptr) {

1✔

710

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

1✔

711

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

1✔

712

        assert_se(strlen_ptr(NULL) == 0);

1✔

713

1✔

715

TEST(memory_startswith) {

1✔

716

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

1✔

717

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

1✔

718

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

1✔

719

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

1✔

720

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

1✔

721

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

1✔

722

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

1✔

723

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

1✔

724

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

1✔

725

1✔

727

TEST(memory_startswith_no_case) {

1✔

728

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

1✔

729

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

1✔

730

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

1✔

731

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

1✔

732

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

1✔

733

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

1✔

734

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

1✔

735

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

1✔

736

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

1✔

737

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

1✔

738

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

1✔

739

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

1✔

740

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

1✔

741

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

1✔

742

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

1✔

744

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

1✔

745

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

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

1✔

750

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

48✔

751

        _cleanup_free_ char *b = NULL;

96✔

752

        int k;

48✔

754

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

48✔

755

        ASSERT_STREQ(b, output);

48✔

756

        assert_se(!!k == truncation);

48✔

757

48✔

759

TEST(string_truncate_lines) {

1✔

760

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

1✔

761

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

1✔

762

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

1✔

763

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

1✔

765

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

1✔

766

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

1✔

767

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

1✔

768

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

1✔

770

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

1✔

771

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

1✔

772

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

1✔

773

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

1✔

775

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

1✔

776

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

1✔

777

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

1✔

778

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

1✔

780

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

1✔

781

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

1✔

782

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

1✔

783

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

1✔

785

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

1✔

786

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

1✔

787

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

1✔

788

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

1✔

790

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

1✔

791

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

1✔

792

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

1✔

793

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

1✔

795

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

1✔

796

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

1✔

797

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

1✔

798

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

1✔

800

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

1✔

801

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

1✔

802

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

1✔

803

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

1✔

805

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

1✔

806

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

1✔

807

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

1✔

808

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

1✔

810

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

1✔

811

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

1✔

812

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

1✔

813

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

1✔

815

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

1✔

816

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

1✔

817

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

1✔

818

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

1✔

819

1✔

821

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

52✔

822

        _cleanup_free_ char *b = NULL;

104✔

823

        int k;

52✔

825

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

52✔

826

        ASSERT_STREQ(b ?: input, output);

52✔

827

        assert_se(!!k == more);

52✔

828

52✔

830

TEST(string_extract_line) {

1✔

831

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

1✔

832

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

1✔

833

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

1✔

834

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

1✔

836

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

1✔

837

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

1✔

838

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

1✔

839

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

1✔

841

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

1✔

842

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

1✔

843

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

1✔

844

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

1✔

846

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

1✔

847

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

1✔

848

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

1✔

849

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

1✔

851

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

1✔

852

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

1✔

853

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

1✔

854

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

1✔

856

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

1✔

857

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

1✔

858

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

1✔

859

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

1✔

861

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

1✔

862

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

1✔

863

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

1✔

864

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

1✔

866

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

1✔

867

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

1✔

868

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

1✔

869

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

1✔

871

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

1✔

872

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

1✔

873

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

1✔

874

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

1✔

876

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

1✔

877

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

1✔

878

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

1✔

879

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

1✔

881

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

1✔

882

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

1✔

883

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

1✔

884

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

1✔

886

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

1✔

887

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

1✔

888

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

1✔

889

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

1✔

891

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

1✔

892

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

1✔

893

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

1✔

894

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

1✔

895

1✔

897

TEST(string_contains_word_strv) {

1✔

898

        const char *w;

1✔

900

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

1✔

902

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

1✔

903

        ASSERT_STREQ(w, "a");

1✔

905

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

1✔

906

        ASSERT_NULL(w);

1✔

908

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

1✔

909

        ASSERT_STREQ(w, "a");

1✔

911

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

1✔

912

        ASSERT_STREQ(w, "b");

1✔

914

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

1✔

915

        ASSERT_STREQ(w, "b");

1✔

917

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

1✔

918

        ASSERT_NULL(w);

1✔

920

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

1✔

921

        ASSERT_STREQ(w, "");

1✔

922

1✔

924

TEST(string_contains_word) {

1✔

925

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

1✔

926

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

1✔

927

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

1✔

928

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

1✔

929

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

1✔

930

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

1✔

931

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

1✔

932

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

1✔

933

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

1✔

934

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

1✔

935

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

1✔

936

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

1✔

938

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

1✔

939

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

1✔

940

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

1✔

941

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

1✔

942

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

1✔

943

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

1✔

944

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

1✔

945

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

1✔

946

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

1✔

947

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

1✔

948

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

1✔

949

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

1✔

951

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

1✔

952

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

1✔

953

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

1✔

954

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

1✔

955

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

1✔

956

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

1✔

958

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

1✔

959

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

1✔

960

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

1✔

961

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

1✔

962

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

1✔

963

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

1✔

964

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

1✔

965

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

1✔

966

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

1✔

967

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

1✔

968

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

1✔

969

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

1✔

970

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

1✔

971

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

1✔

972

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

1✔

973

1✔

975

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

401✔

976

        int r = strverscmp_improved(a, b);

401✔

978

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

874✔

983

        assert_se(r == expected);

401✔

984

401✔

986

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

298✔

987

        test_strverscmp_improved_one(older, newer, -1);

298✔

989

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

298✔

990

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

298✔

991

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

298✔

992

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

298✔

993

298✔

995

TEST(strverscmp_improved) {

1✔

996

        static const char * const versions[] = {

1✔

1024

        STRV_FOREACH(p, versions)

25✔

1025

                STRV_FOREACH(q, p + 1)

300✔

1026

                        test_strverscmp_improved_newer(*p, *q);

276✔

1028

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

1✔

1029

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

1✔

1030

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

1✔

1031

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

1✔

1032

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

1✔

1033

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

1✔

1034

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

1✔

1035

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

1✔

1036

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

1✔

1039

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

1✔

1040

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

1✔

1041

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

1✔

1042

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

1✔

1043

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

1✔

1046

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

1✔

1047

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

1✔

1048

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

1✔

1051

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

1✔

1052

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

1✔

1053

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

1✔

1056

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

1✔

1057

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

1✔

1060

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

1✔

1063

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

1✔

1064

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

1✔

1065

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

1✔

1066

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

1✔

1067

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

1✔

1068

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

1✔

1069

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

1✔

1072

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

1✔

1073

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

1✔

1074

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

1✔

1075

        assert_se(strverscmp_improved("_0_", "0") == 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);

1✔

1079

        assert_se(strverscmp_improved("_", "") == 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✔

1086

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

1✔

1087

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

1✔

1089

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

1✔

1090

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

1✔

1091

1✔

1096

TEST(strverscmp_improved_rpm) {

1✔

1102

        RPMVERCMP(1.0, 1.0, 0);

1✔

1103

        RPMVERCMP(1.0, 2.0, -1);

1✔

1104

        RPMVERCMP(2.0, 1.0, 1);

1✔

1106

        RPMVERCMP(2.0.1, 2.0.1, 0);

1✔

1107

        RPMVERCMP(2.0, 2.0.1, -1);

1✔

1108

        RPMVERCMP(2.0.1, 2.0, 1);

1✔

1110

        RPMVERCMP(2.0.1a, 2.0.1a, 0);

1✔

1111

        RPMVERCMP(2.0.1a, 2.0.1, 1);

1✔

1112

        RPMVERCMP(2.0.1, 2.0.1a, -1);

1✔

1114

        RPMVERCMP(5.5p1, 5.5p1, 0);

1✔

1115

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

1✔

1116

        RPMVERCMP(5.5p2, 5.5p1, 1);

1✔

1118

        RPMVERCMP(5.5p10, 5.5p10, 0);

1✔

1119

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

1✔

1120

        RPMVERCMP(5.5p10, 5.5p1, 1);

1✔

1122

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

1✔

1123

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

1✔

1125

        RPMVERCMP(xyz10, xyz10, 0);

1✔

1126

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

1✔

1127

        RPMVERCMP(xyz10.1, xyz10, 1);

1✔

1129

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

1✔

1130

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

1✔

1131

        RPMVERCMP(8, xyz.4, 1);

1✔

1132

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

1✔

1133

        RPMVERCMP(2, xyz.4, 1);

1✔

1135

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

1✔

1136

        RPMVERCMP(5.6p1, 5.5p2, 1);

1✔

1138

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

1✔

1139

        RPMVERCMP(6.5p1, 5.6p1, 1);

1✔

1141

        RPMVERCMP(6.0.rc1, 6.0, 1);

1✔

1142

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

1✔

1144

        RPMVERCMP(10b2, 10a1, 1);

1✔

1145

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

1✔

1147

        RPMVERCMP(1.0aa, 1.0aa, 0);

1✔

1148

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

1✔

1149

        RPMVERCMP(1.0aa, 1.0a, 1);

1✔

1151

        RPMVERCMP(10.0001, 10.0001, 0);

1✔

1152

        RPMVERCMP(10.0001, 10.1, 0);

1✔

1153

        RPMVERCMP(10.1, 10.0001, 0);

1✔

1154

        RPMVERCMP(10.0001, 10.0039, -1);

1✔

1155

        RPMVERCMP(10.0039, 10.0001, 1);

1✔

1157

        RPMVERCMP(4.999.9, 5.0, -1);

1✔

1158

        RPMVERCMP(5.0, 4.999.9, 1);

1✔

1160

        RPMVERCMP(20101121, 20101121, 0);

1✔

1161

        RPMVERCMP(20101121, 20101122, -1);

1✔

1162

        RPMVERCMP(20101122, 20101121, 1);

1✔

1164

        RPMVERCMP(2_0, 2_0, 0);

1✔

1165

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

1✔

1166

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

1✔

1169

        RPMVERCMP(a, a, 0);

1✔

1170

        RPMVERCMP(a+, a+, 0);

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(+_, +_, 0);

1✔

1177

        RPMVERCMP(_+, +_, 0);

1✔

1178

        RPMVERCMP(_+, _+, 0);

1✔

1179

        RPMVERCMP(+, _, 0);

1✔

1180

        RPMVERCMP(_, +, 0);

1✔

1183

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

1✔

1184

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

1✔

1185

        RPMVERCMP(1.0, 1.0~rc1, 1);

1✔

1186

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

1✔

1187

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

1✔

1188

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

1✔

1189

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

1✔

1190

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

1✔

1193

        RPMVERCMP(1.0^, 1.0^, 0);

1✔

1194

        RPMVERCMP(1.0^, 1.0, 1);

1✔

1195

        RPMVERCMP(1.0, 1.0^, -1);

1✔

1196

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

1✔

1197

        RPMVERCMP(1.0^git1, 1.0, 1);

1✔

1198

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

1✔

1199

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

1✔

1200

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

1✔

1201

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

1✔

1202

        RPMVERCMP(1.01, 1.0^git1, 1);

1✔

1203

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

1✔

1204

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

1✔

1205

        RPMVERCMP(1.0.1, 1.0^20160101, 1);

1✔

1206

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

1✔

1207

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

1✔

1208

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

1✔

1211

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

1✔

1212

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

1✔

1213

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

1✔

1214

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

1✔

1215

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

1✔

1216

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

1✔

1221

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

1✔

1223

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

1✔

1224

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

1✔

1225

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

1✔

1226

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

1✔

1227

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

1✔

1228

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

1✔

1231

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

1✔

1232

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

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

1✔

1239

TEST(strextendf) {

1✔

1240

        _cleanup_free_ char *p = NULL;

2✔

1242

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

1✔

1243

        ASSERT_STREQ(p, "<77>");

1✔

1245

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

1✔

1246

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

1✔

1248

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

1✔

1249

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

1✔

1251

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

1✔

1252

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

1✔

1254

        p = mfree(p);

1✔

1256

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

1✔

1257

        ASSERT_STREQ(p, "<77>");

1✔

1259

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

1✔

1260

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

1✔

1262

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

1✔

1263

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

1✔

1265

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

1✔

1266

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

1✔

1267

1✔

1269

TEST(string_replace_char) {

1✔

1270

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

1✔

1271

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

1✔

1272

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

1✔

1273

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

1✔

1274

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

1✔

1275

1✔

1277

TEST(strspn_from_end) {

1✔

1278

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

1✔

1279

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

1✔

1280

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

1✔

1281

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

1✔

1282

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

1✔

1283

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

1✔

1284

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

1✔

1285

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

1✔

1286

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

1✔

1287

1✔

1289

TEST(streq_skip_trailing_chars) {

1✔

1291

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

1✔

1292

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

1✔

1293

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

1✔

1294

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

1✔

1295

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

1✔

1296

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

1✔

1297

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

1✔

1298

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

1✔

1300

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

1✔

1301

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

1✔

1302

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

1✔

1304

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

1✔

1305

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

1✔

1307

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

1✔

1308

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

1✔

1309

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

1✔

1310

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

1✔

1311

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

1✔

1312

1✔

1321

TEST(make_cstring) {

1✔

1322

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

1✔

1331

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

1✔

1332

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

1✔

1333

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

1✔

1335

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

1✔

1336

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

1✔

1337

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

1✔

1339

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

1✔

1340

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

1✔

1341

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

1✔

1343

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

1✔

1344

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

1✔

1345

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

1✔

1347

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

1✔

1348

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

1✔

1349

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

1✔

1351

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

1✔

1352

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

1✔

1353

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

1✔

1355

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

1✔

1356

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

1✔

1357

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

1✔

1359

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

1✔

1360

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

1✔

1361

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

1✔

1362

1✔

1364

TEST(find_line_startswith) {

1✔

1365

        static const char text[] =

1✔

1374

        static const char emptystring[] = "";

1✔

1376

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

1✔

1377

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

1✔

1378

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

1✔

1379

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

1✔

1380

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

1✔

1381

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

1✔

1382

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

1✔

1383

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

1✔

1384

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

1✔

1385

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

1✔

1386

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

1✔

1387

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

1✔

1389

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

1✔

1390

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

1✔

1391

1✔

1393

TEST(strstrafter) {

1✔

1394

        static const char buffer[] = "abcdefghijklmnopqrstuvwxyz";

1✔

1396

        assert_se(!strstrafter(NULL, NULL));

1✔

1397

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

1✔

1398

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

1✔

1399

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

1✔

1401

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

1✔

1402

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

1✔

1403

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

1✔

1404

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

1✔

1405

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

1✔

1406

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

1✔

1407

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

1✔

1408

1✔

1410

TEST(version_is_valid) {

1✔

1411

        assert_se(!version_is_valid(NULL));

1✔

1412

        assert_se(!version_is_valid(""));

1✔

1413

        assert_se(version_is_valid("0"));

1✔

1414

        assert_se(version_is_valid("5"));

1✔

1415

        assert_se(version_is_valid("999999"));

1✔

1416

        assert_se(version_is_valid("999999.5"));

1✔

1417

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

1✔

1418

1✔

1420

TEST(strextendn) {

1✔

1421

        _cleanup_free_ char *x = NULL;

2✔

1423

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

1✔

1424

        x = mfree(x);

1✔

1426

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

1✔

1427

        x = mfree(x);

1✔

1429

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

1✔

1430

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

1✔

1431

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

1✔

1432

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

1✔

1433

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

1✔

1434

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

1✔

1435

        x = mfree(x);

1✔

1436

1✔

1438

TEST(strprepend) {

1✔

1439

        _cleanup_free_ char *x = NULL;

2✔

1441

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

1✔

1442

        x = mfree(x);

1✔

1444

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

1✔

1446

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

2✔

1447

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

2✔

1448

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

2✔

1449

        x = mfree(x);

1✔

1451

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

1✔

1453

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

2✔

1454

        x = mfree(x);

1✔

1456

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

1✔

1457

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

2✔

1458

1✔

1460

TEST(strlevenshtein) {

1✔

1461

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

1✔

1462

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

1✔

1463

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

1✔

1464

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

1✔

1466

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

1✔

1467

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

1✔

1468

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

1✔

1469

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

1✔

1470

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

1✔

1472

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

1✔

1473

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

1✔

1474

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

1✔

1475

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

1✔

1476

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

1✔

1477

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

1✔

1478

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

1✔

1480

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

1✔

1481

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

1✔

1482

1✔

1484

TEST(strrstr) {

1✔

1485

        assert_se(!strrstr(NULL, NULL));

1✔

1486

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

1✔

1487

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

1✔

1489

        const char *p = "foo";

1✔

1490

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

1✔

1491

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

1✔

1492

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

1✔

1493

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

1✔

1494

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

1✔

1495

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

1✔

1496

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

1✔

1498

        p = "xoxoxox";

1✔

1499

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

1✔

1500

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

1✔

1501

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

1✔

1502

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

1✔

1503

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

1✔

1504

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

1✔

1505

1✔

1507

TEST(str_common_prefix) {

1✔

1508

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

1✔

1509

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

1✔

1510

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

1✔

1511

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

1✔

1512

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

1✔

1513

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

1✔

1514

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

1✔

1515

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

1✔

1516

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

1✔

1517

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

1✔

1518

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

1✔

1519

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

1✔

1520

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

1✔

1521

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

1✔

1522

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

1✔

1523

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

1✔

1524

1✔

1526

TEST(string_is_safe) {

1✔

1528

        ASSERT_FALSE(string_is_safe(NULL, 0));

1✔

1529

        ASSERT_FALSE(string_is_safe(NULL, STRING_ALLOW_EMPTY));

1✔

1530

        ASSERT_FALSE(string_is_safe(NULL, STRING_ASCII));

1✔

1531

        ASSERT_FALSE(string_is_safe(NULL, STRING_ALLOW_BACKSLASHES));

1✔

1532

        ASSERT_FALSE(string_is_safe(NULL, STRING_ALLOW_QUOTES));

1✔

1533

        ASSERT_FALSE(string_is_safe(NULL, STRING_ALLOW_GLOBS));

1✔

1534

        ASSERT_FALSE(string_is_safe(NULL, STRING_FILENAME));

1✔

1538

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

1✔

1539

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

1✔

1540

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

1✔

1541

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

1✔

1543

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

1✔

1544

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

1✔

1545

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

1✔

1546

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

1✔

1547

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

1✔

1548

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

1✔

1549

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

1✔

1550

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

1✔

1551

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

1✔

1552

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

1✔

1553

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

1✔

1554

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

1✔

1555

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

1✔

1556

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

1✔

1559

        ASSERT_TRUE(string_is_safe("", STRING_ALLOW_EMPTY));

1✔

1560

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

1✔

1561

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

1✔

1562

        ASSERT_FALSE(string_is_safe(NULL, STRING_ALLOW_EMPTY));

1✔

1566

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

1✔

1567

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

1✔

1568

        ASSERT_FALSE(string_is_safe("", STRING_ASCII));

1✔

1569

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

1✔

1570

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

1✔

1571

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

1✔

1572

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

1✔

1573

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

1✔

1574

        ASSERT_FALSE(string_is_safe("a\\b", STRING_ASCII));

1✔

1575

        ASSERT_FALSE(string_is_safe("a\"b", STRING_ASCII));

1✔

1576

        ASSERT_FALSE(string_is_safe("a*b", STRING_ASCII));

1✔

1579

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

1✔

1580

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

1✔

1581

        ASSERT_TRUE(string_is_safe("\n", STRING_ALLOW_NEWLINES));

1✔

1582

        ASSERT_TRUE(string_is_safe("a\nb", STRING_ALLOW_NEWLINES));

1✔

1583

        ASSERT_TRUE(string_is_safe("foo\n", STRING_ALLOW_NEWLINES));

1✔

1584

        ASSERT_TRUE(string_is_safe("\nfoo", STRING_ALLOW_NEWLINES));

1✔

1585

        ASSERT_TRUE(string_is_safe("foo\nbar", STRING_ALLOW_NEWLINES));

1✔

1586

        ASSERT_FALSE(string_is_safe("foo\\nbar", STRING_ALLOW_NEWLINES)); /* literal backslash, not newline, rejected */

1✔

1587

        ASSERT_FALSE(string_is_safe("\"", STRING_ALLOW_NEWLINES));        /* quotes still rejected */

1✔

1588

        ASSERT_FALSE(string_is_safe("*", STRING_ALLOW_NEWLINES));         /* globs still rejected */

1✔

1591

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

1✔

1592

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

1✔

1593

        ASSERT_TRUE(string_is_safe("\\", STRING_ALLOW_BACKSLASHES));

1✔

1594

        ASSERT_TRUE(string_is_safe("a\\b", STRING_ALLOW_BACKSLASHES));

1✔

1595

        ASSERT_TRUE(string_is_safe("foo\\", STRING_ALLOW_BACKSLASHES));

1✔

1596

        ASSERT_TRUE(string_is_safe("\\foo", STRING_ALLOW_BACKSLASHES));

1✔

1597

        ASSERT_TRUE(string_is_safe("foo\\nbar", STRING_ALLOW_BACKSLASHES)); /* literal backslash, not newline */

1✔

1598

        ASSERT_FALSE(string_is_safe("foo\nbar", STRING_ALLOW_BACKSLASHES)); /* newline still rejected */

1✔

1599

        ASSERT_FALSE(string_is_safe("\"", STRING_ALLOW_BACKSLASHES));       /* quotes still rejected */

1✔

1600

        ASSERT_FALSE(string_is_safe("*", STRING_ALLOW_BACKSLASHES));        /* globs still rejected */

1✔

1603

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

1✔

1604

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

1✔

1605

        ASSERT_TRUE(string_is_safe("\"", STRING_ALLOW_QUOTES));

1✔

1606

        ASSERT_TRUE(string_is_safe("'", STRING_ALLOW_QUOTES));

1✔

1607

        ASSERT_TRUE(string_is_safe("hello\"world", STRING_ALLOW_QUOTES));

1✔

1608

        ASSERT_TRUE(string_is_safe("it's", STRING_ALLOW_QUOTES));

1✔

1609

        ASSERT_FALSE(string_is_safe("a\nb", STRING_ALLOW_QUOTES));          /* newline still rejected */

1✔

1610

        ASSERT_FALSE(string_is_safe("a\\b", STRING_ALLOW_QUOTES));          /* backslashes still rejected */

1✔

1611

        ASSERT_FALSE(string_is_safe("*", STRING_ALLOW_QUOTES));             /* globs still rejected */

1✔

1614

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

1✔

1615

        ASSERT_TRUE(string_is_safe("ab]c", STRING_ALLOW_GLOBS));            /* ']' is not in GLOB_CHARS anyway */

1✔

1616

        ASSERT_TRUE(string_is_safe("*", STRING_ALLOW_GLOBS));

1✔

1617

        ASSERT_TRUE(string_is_safe("?", STRING_ALLOW_GLOBS));

1✔

1618

        ASSERT_TRUE(string_is_safe("[", STRING_ALLOW_GLOBS));

1✔

1619

        ASSERT_TRUE(string_is_safe("foo*bar", STRING_ALLOW_GLOBS));

1✔

1620

        ASSERT_TRUE(string_is_safe("foo?bar", STRING_ALLOW_GLOBS));

1✔

1621

        ASSERT_TRUE(string_is_safe("foo[bar", STRING_ALLOW_GLOBS));

1✔

1622

        ASSERT_FALSE(string_is_safe("foo\nbar", STRING_ALLOW_GLOBS));       /* newline still rejected */

1✔

1623

        ASSERT_FALSE(string_is_safe("\"", STRING_ALLOW_GLOBS));             /* quotes still rejected */

1✔

1624

        ASSERT_FALSE(string_is_safe("a\\b", STRING_ALLOW_GLOBS));           /* backslashes still rejected */

1✔

1627

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

1✔

1628

        ASSERT_TRUE(string_is_safe("hello.txt", STRING_FILENAME));

1✔

1629

        ASSERT_TRUE(string_is_safe("...", STRING_FILENAME));

1✔

1630

        ASSERT_TRUE(string_is_safe(".hidden", STRING_FILENAME));

1✔

1631

        ASSERT_FALSE(string_is_safe("", STRING_FILENAME));

1✔

1632

        ASSERT_FALSE(string_is_safe(".", STRING_FILENAME));

1✔

1633

        ASSERT_FALSE(string_is_safe("..", STRING_FILENAME));

1✔

1634

        ASSERT_FALSE(string_is_safe("/", STRING_FILENAME));

1✔

1635

        ASSERT_FALSE(string_is_safe("/foo", STRING_FILENAME));

1✔

1636

        ASSERT_FALSE(string_is_safe("foo/bar", STRING_FILENAME));

1✔

1639

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

1✔

1640

        ASSERT_TRUE(string_is_safe("foo-bar_baz", STRING_DISALLOW_WHITESPACE));

1✔

1641

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

1✔

1642

        ASSERT_TRUE(string_is_safe("hello world", 0));                       /* space accepted by default */

1✔

1643

        ASSERT_FALSE(string_is_safe("hello world", STRING_DISALLOW_WHITESPACE)); /* but not with the flag */

1✔

1644

        ASSERT_FALSE(string_is_safe(" ", STRING_DISALLOW_WHITESPACE));

1✔

1645

        ASSERT_FALSE(string_is_safe("foo ", STRING_DISALLOW_WHITESPACE));

1✔

1646

        ASSERT_FALSE(string_is_safe(" foo", STRING_DISALLOW_WHITESPACE));

1✔

1647

        ASSERT_FALSE(string_is_safe("a\tb", STRING_DISALLOW_WHITESPACE));

1✔

1648

        ASSERT_FALSE(string_is_safe("a\rb", STRING_DISALLOW_WHITESPACE));

1✔

1650

        ASSERT_TRUE(string_is_safe("a\nb", STRING_ALLOW_NEWLINES));

1✔

1651

        ASSERT_FALSE(string_is_safe("a\nb", STRING_ALLOW_NEWLINES | STRING_DISALLOW_WHITESPACE));

1✔

1654

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

1✔

1655

        ASSERT_TRUE(string_is_safe("hello.txt", STRING_FILENAME_PART));

1✔

1656

        ASSERT_TRUE(string_is_safe("...", STRING_FILENAME_PART));

1✔

1657

        ASSERT_TRUE(string_is_safe(".hidden", STRING_FILENAME_PART));

1✔

1658

        ASSERT_TRUE(string_is_safe(".", STRING_FILENAME_PART));             /* accepted, unlike STRING_FILENAME */

1✔

1659

        ASSERT_TRUE(string_is_safe("..", STRING_FILENAME_PART));            /* accepted, unlike STRING_FILENAME */

1✔

1660

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

1✔

1661

        ASSERT_TRUE(string_is_safe("", STRING_FILENAME_PART | STRING_ALLOW_EMPTY)); /* ... unless explicitly allowed */

1✔

1662

        ASSERT_FALSE(string_is_safe("/", STRING_FILENAME_PART));

1✔

1663

        ASSERT_FALSE(string_is_safe("/foo", STRING_FILENAME_PART));

1✔

1664

        ASSERT_FALSE(string_is_safe("foo/bar", STRING_FILENAME_PART));

1✔

1665

        ASSERT_FALSE(string_is_safe("foo/", STRING_FILENAME_PART));

1✔

1668

        ASSERT_TRUE(string_is_safe("", STRING_ALLOW_EMPTY | STRING_ASCII));

1✔

1669

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

1✔

1670

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

1✔

1672

        ASSERT_TRUE(string_is_safe("ab\"cd", STRING_ALLOW_QUOTES | STRING_ALLOW_GLOBS));

1✔

1673

        ASSERT_TRUE(string_is_safe("ab*cd", STRING_ALLOW_QUOTES | STRING_ALLOW_GLOBS));

1✔

1674

        ASSERT_TRUE(string_is_safe("ab'*cd", STRING_ALLOW_QUOTES | STRING_ALLOW_GLOBS));

1✔

1675

        ASSERT_FALSE(string_is_safe("ab\\cd", STRING_ALLOW_QUOTES | STRING_ALLOW_GLOBS)); /* backslash still rejected */

1✔

1677

        ASSERT_TRUE(string_is_safe("hello.txt", STRING_FILENAME));

1✔

1678

        ASSERT_FALSE(string_is_safe("", STRING_FILENAME));

1✔

1679

        ASSERT_FALSE(string_is_safe("foo/bar", STRING_FILENAME));

1✔

1681

        ASSERT_TRUE(string_is_safe("foo?bar", STRING_ASCII | STRING_ALLOW_GLOBS));

1✔

1682

        ASSERT_FALSE(string_is_safe("foo\"bar", STRING_ASCII | STRING_ALLOW_GLOBS));      /* quotes still rejected */

1✔

1683

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

1✔

1685

        ASSERT_TRUE(string_is_safe("foo\\bar", STRING_ALLOW_BACKSLASHES));

1✔

1686

        ASSERT_FALSE(string_is_safe("foo\"bar", STRING_ALLOW_BACKSLASHES));               /* quotes still rejected */

1✔

1687

        ASSERT_FALSE(string_is_safe("foo*bar", STRING_ALLOW_BACKSLASHES));                /* globs still rejected */

1✔

1688

        ASSERT_TRUE(string_is_safe("foo\\\"bar", STRING_ALLOW_BACKSLASHES | STRING_ALLOW_QUOTES));

1✔

1689

        ASSERT_TRUE(string_is_safe("foo\\bar", STRING_ALLOW_BACKSLASHES | STRING_ALLOW_QUOTES));

1✔

1690

        ASSERT_TRUE(string_is_safe("foo\"bar", STRING_ALLOW_BACKSLASHES | STRING_ALLOW_QUOTES));

1✔

1693

        StringSafeFlags all =

1✔

1701

        ASSERT_TRUE(string_is_safe("hello.txt", all));

1✔

1702

        ASSERT_TRUE(string_is_safe("foo-bar_baz.conf", all));

1✔

1703

        ASSERT_TRUE(string_is_safe("a", all));

1✔

1704

        ASSERT_TRUE(string_is_safe("foo\nbar", all));            /* newline allowed */

1✔

1705

        ASSERT_TRUE(string_is_safe("foo\\bar", all));            /* backslash allowed */

1✔

1706

        ASSERT_TRUE(string_is_safe("foo\"bar", all));            /* quote allowed */

1✔

1707

        ASSERT_TRUE(string_is_safe("foo'bar", all));             /* quote allowed */

1✔

1708

        ASSERT_TRUE(string_is_safe("foo*bar", all));             /* glob allowed */

1✔

1709

        ASSERT_TRUE(string_is_safe("foo?bar", all));             /* glob allowed */

1✔

1710

        ASSERT_TRUE(string_is_safe("foo[bar", all));             /* glob allowed */

1✔

1711

        ASSERT_FALSE(string_is_safe("", all));                   /* fails STRING_FILENAME */

1✔

1712

        ASSERT_FALSE(string_is_safe("über", all));               /* fails STRING_ASCII */

1✔

1713

        ASSERT_FALSE(string_is_safe("foo/bar", all));            /* fails STRING_FILENAME */

1✔

1714

        ASSERT_FALSE(string_is_safe(".", all));                  /* fails STRING_FILENAME */

1✔

1715

        ASSERT_FALSE(string_is_safe("..", all));                 /* fails STRING_FILENAME */

1✔

1716

        ASSERT_FALSE(string_is_safe("foo\x01""bar", all));       /* fails baseline control-char check */

1✔

1717

        ASSERT_FALSE(string_is_safe(NULL, all));

1✔

1718

1✔

1720

DEFINE_TEST_MAIN(LOG_DEBUG);

1✔

systemd / systemd / 28272947092

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

systemd / systemd / 28272947092

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