systemd/systemd | Build 19349812769 | src/boot/test-efi-string.c | Coveralls

11

TEST(strlen8) {

1✔

12

        ASSERT_EQ(strlen8(NULL), 0u);

1✔

13

        ASSERT_EQ(strlen8(""), 0u);

1✔

14

        ASSERT_EQ(strlen8("1"), 1u);

1✔

15

        ASSERT_EQ(strlen8("11"), 2u);

1✔

16

        ASSERT_EQ(strlen8("123456789"), 9u);

1✔

17

        ASSERT_EQ(strlen8("12\0004"), 2u);

1✔

18

1✔

20

TEST(strlen16) {

1✔

21

        ASSERT_EQ(strlen16(NULL), 0u);

1✔

22

        ASSERT_EQ(strlen16(u""), 0u);

1✔

23

        ASSERT_EQ(strlen16(u"1"), 1u);

1✔

24

        ASSERT_EQ(strlen16(u"11"), 2u);

1✔

25

        ASSERT_EQ(strlen16(u"123456789"), 9u);

1✔

26

        ASSERT_EQ(strlen16(u"12\0004"), 2u);

1✔

27

1✔

29

TEST(strnlen8) {

1✔

30

        ASSERT_EQ(strnlen8(NULL, 0), 0u);

1✔

31

        ASSERT_EQ(strnlen8(NULL, 10), 0u);

1✔

32

        ASSERT_EQ(strnlen8("", 10), 0u);

1✔

33

        ASSERT_EQ(strnlen8("1", 10), 1u);

1✔

34

        ASSERT_EQ(strnlen8("11", 1), 1u);

1✔

35

        ASSERT_EQ(strnlen8("123456789", 7), 7u);

1✔

36

        ASSERT_EQ(strnlen8("12\0004", 5), 2u);

1✔

37

1✔

39

TEST(strnlen16) {

1✔

40

        ASSERT_EQ(strnlen16(NULL, 0), 0u);

1✔

41

        ASSERT_EQ(strnlen16(NULL, 10), 0u);

1✔

42

        ASSERT_EQ(strnlen16(u"", 10), 0u);

1✔

43

        ASSERT_EQ(strnlen16(u"1", 10), 1u);

1✔

44

        ASSERT_EQ(strnlen16(u"11", 1), 1u);

1✔

45

        ASSERT_EQ(strnlen16(u"123456789", 7), 7u);

1✔

46

        ASSERT_EQ(strnlen16(u"12\0004", 5), 2u);

1✔

47

1✔

49

TEST(strsize8) {

1✔

50

        ASSERT_EQ(strsize8(NULL), 0u);

1✔

51

        ASSERT_EQ(strsize8(""), 1u);

1✔

52

        ASSERT_EQ(strsize8("1"), 2u);

1✔

53

        ASSERT_EQ(strsize8("11"), 3u);

1✔

54

        ASSERT_EQ(strsize8("123456789"), 10u);

1✔

55

        ASSERT_EQ(strsize8("12\0004"), 3u);

1✔

56

1✔

58

TEST(strsize16) {

1✔

59

        ASSERT_EQ(strsize16(NULL), 0u);

1✔

60

        ASSERT_EQ(strsize16(u""), 2u);

1✔

61

        ASSERT_EQ(strsize16(u"1"), 4u);

1✔

62

        ASSERT_EQ(strsize16(u"11"), 6u);

1✔

63

        ASSERT_EQ(strsize16(u"123456789"), 20u);

1✔

64

        ASSERT_EQ(strsize16(u"12\0004"), 6u);

1✔

65

1✔

67

TEST(strtolower8) {

1✔

68

        char s[] = "\0001234abcDEF!\0zZ";

1✔

70

        ASSERT_NULL(strtolower8(NULL));

1✔

72

        ASSERT_PTR_EQ(strtolower8(s), s);

1✔

73

        ASSERT_EQ(memcmp(s, "\0001234abcDEF!\0zZ", sizeof(s)), 0);

1✔

75

        s[0] = '#';

1✔

76

        ASSERT_PTR_EQ(strtolower8(s), s);

1✔

77

        ASSERT_EQ(memcmp(s, "#1234abcdef!\0zZ", sizeof(s)), 0);

1✔

78

1✔

80

TEST(strtolower16) {

1✔

81

        char16_t s[] = u"\0001234abcDEF!\0zZ";

1✔

83

        ASSERT_NULL(strtolower16(NULL));

1✔

85

        ASSERT_PTR_EQ(strtolower16(s), s);

1✔

86

        ASSERT_EQ(memcmp(s, u"\0001234abcDEF!\0zZ", sizeof(s)), 0);

1✔

88

        s[0] = '#';

1✔

89

        ASSERT_PTR_EQ(strtolower16(s), s);

1✔

90

        ASSERT_EQ(memcmp(s, u"#1234abcdef!\0zZ", sizeof(s)), 0);

1✔

91

1✔

93

TEST(strncmp8) {

1✔

94

        ASSERT_LT(strncmp8(NULL, "", 10), 0);

1✔

95

        ASSERT_GT(strncmp8("", NULL, 10), 0);

1✔

96

        ASSERT_EQ(strncmp8(NULL, NULL, 0), 0);

1✔

97

        ASSERT_EQ(strncmp8(NULL, NULL, 10), 0);

1✔

98

        ASSERT_EQ(strncmp8("", "", 10), 0);

1✔

99

        ASSERT_EQ(strncmp8("abc", "abc", 2), 0);

1✔

100

        ASSERT_EQ(strncmp8("aBc", "aBc", 3), 0);

1✔

101

        ASSERT_EQ(strncmp8("aBC", "aBC", 4), 0);

1✔

102

        ASSERT_EQ(strncmp8("", "a", 0), 0);

1✔

103

        ASSERT_EQ(strncmp8("b", "a", 0), 0);

1✔

104

        ASSERT_LT(strncmp8("", "a", 3), 0);

1✔

105

        ASSERT_EQ(strncmp8("=", "=", 1), 0);

1✔

106

        ASSERT_LT(strncmp8("A", "a", 1), 0);

1✔

107

        ASSERT_GT(strncmp8("a", "A", 2), 0);

1✔

108

        ASSERT_GT(strncmp8("a", "Aa", 2), 0);

1✔

109

        ASSERT_LT(strncmp8("12\00034", "12345", 4), 0);

1✔

110

        ASSERT_LT(strncmp8("12\00034", "12345", SIZE_MAX), 0);

1✔

111

        ASSERT_EQ(strncmp8("abc\0def", "abc", SIZE_MAX), 0);

1✔

112

        ASSERT_LT(strncmp8("abc\0def", "abcdef", SIZE_MAX), 0);

1✔

114

        ASSERT_EQ(strncmp8((char[]){ CHAR_MIN }, (char[]){ CHAR_MIN }, 1), 0);

1✔

115

        ASSERT_EQ(strncmp8((char[]){ CHAR_MAX }, (char[]){ CHAR_MAX }, 1), 0);

1✔

116

        ASSERT_LT(strncmp8((char[]){ CHAR_MIN }, (char[]){ CHAR_MAX }, 1), 0);

1✔

117

        ASSERT_GT(strncmp8((char[]){ CHAR_MAX }, (char[]){ CHAR_MIN }, 1), 0);

1✔

118

1✔

120

TEST(strncmp16) {

1✔

121

        ASSERT_LT(strncmp16(NULL, u"", 10), 0);

1✔

122

        ASSERT_GT(strncmp16(u"", NULL, 10), 0);

1✔

123

        ASSERT_EQ(strncmp16(NULL, NULL, 0), 0);

1✔

124

        ASSERT_EQ(strncmp16(NULL, NULL, 10), 0);

1✔

125

        ASSERT_EQ(strncmp16(u"", u"", 0), 0);

1✔

126

        ASSERT_EQ(strncmp16(u"", u"", 10), 0);

1✔

127

        ASSERT_EQ(strncmp16(u"abc", u"abc", 2), 0);

1✔

128

        ASSERT_EQ(strncmp16(u"aBc", u"aBc", 3), 0);

1✔

129

        ASSERT_EQ(strncmp16(u"aBC", u"aBC", 4), 0);

1✔

130

        ASSERT_EQ(strncmp16(u"", u"a", 0), 0);

1✔

131

        ASSERT_EQ(strncmp16(u"b", u"a", 0), 0);

1✔

132

        ASSERT_LT(strncmp16(u"", u"a", 3), 0);

1✔

133

        ASSERT_EQ(strncmp16(u"=", u"=", 1), 0);

1✔

134

        ASSERT_LT(strncmp16(u"A", u"a", 1), 0);

1✔

135

        ASSERT_GT(strncmp16(u"a", u"A", 2), 0);

1✔

136

        ASSERT_GT(strncmp16(u"a", u"Aa", 2), 0);

1✔

137

        ASSERT_LT(strncmp16(u"12\00034", u"12345", 4), 0);

1✔

138

        ASSERT_LT(strncmp16(u"12\00034", u"12345", SIZE_MAX), 0);

1✔

139

        ASSERT_EQ(strncmp16(u"abc\0def", u"abc", SIZE_MAX), 0);

1✔

140

        ASSERT_LT(strncmp16(u"abc\0def", u"abcdef", SIZE_MAX), 0);

1✔

142

        ASSERT_EQ(strncmp16((char16_t[]){ UINT16_MAX }, (char16_t[]){ UINT16_MAX }, 1), 0);

1✔

143

        ASSERT_LT(strncmp16((char16_t[]){ 0 }, (char16_t[]){ UINT16_MAX }, 1), 0);

1✔

144

        ASSERT_GT(strncmp16((char16_t[]){ UINT16_MAX }, (char16_t[]){ 0 }, 1), 0);

1✔

145

1✔

147

TEST(strncasecmp8) {

1✔

148

        ASSERT_LT(strncasecmp8(NULL, "", 10), 0);

1✔

149

        ASSERT_GT(strncasecmp8("", NULL, 10), 0);

1✔

150

        ASSERT_EQ(strncasecmp8(NULL, NULL, 0), 0);

1✔

151

        ASSERT_EQ(strncasecmp8(NULL, NULL, 10), 0);

1✔

152

        ASSERT_EQ(strncasecmp8("", "", 10), 0);

1✔

153

        ASSERT_EQ(strncasecmp8("abc", "abc", 2), 0);

1✔

154

        ASSERT_EQ(strncasecmp8("aBc", "AbC", 3), 0);

1✔

155

        ASSERT_EQ(strncasecmp8("aBC", "Abc", 4), 0);

1✔

156

        ASSERT_EQ(strncasecmp8("", "a", 0), 0);

1✔

157

        ASSERT_EQ(strncasecmp8("b", "a", 0), 0);

1✔

158

        ASSERT_LT(strncasecmp8("", "a", 3), 0);

1✔

159

        ASSERT_EQ(strncasecmp8("=", "=", 1), 0);

1✔

160

        ASSERT_EQ(strncasecmp8("A", "a", 1), 0);

1✔

161

        ASSERT_EQ(strncasecmp8("a", "A", 2), 0);

1✔

162

        ASSERT_LT(strncasecmp8("a", "Aa", 2), 0);

1✔

163

        ASSERT_LT(strncasecmp8("12\00034", "12345", 4), 0);

1✔

164

        ASSERT_LT(strncasecmp8("12\00034", "12345", SIZE_MAX), 0);

1✔

165

        ASSERT_EQ(strncasecmp8("abc\0def", "ABC", SIZE_MAX), 0);

1✔

166

        ASSERT_LT(strncasecmp8("abc\0def", "ABCDEF", SIZE_MAX), 0);

1✔

168

        ASSERT_EQ(strncasecmp8((char[]){ CHAR_MIN }, (char[]){ CHAR_MIN }, 1), 0);

1✔

169

        ASSERT_EQ(strncasecmp8((char[]){ CHAR_MAX }, (char[]){ CHAR_MAX }, 1), 0);

1✔

170

        ASSERT_LT(strncasecmp8((char[]){ CHAR_MIN }, (char[]){ CHAR_MAX }, 1), 0);

1✔

171

        ASSERT_GT(strncasecmp8((char[]){ CHAR_MAX }, (char[]){ CHAR_MIN }, 1), 0);

1✔

172

1✔

174

TEST(strncasecmp16) {

1✔

175

        ASSERT_LT(strncasecmp16(NULL, u"", 10), 0);

1✔

176

        ASSERT_GT(strncasecmp16(u"", NULL, 10), 0);

1✔

177

        ASSERT_EQ(strncasecmp16(NULL, NULL, 0), 0);

1✔

178

        ASSERT_EQ(strncasecmp16(NULL, NULL, 10), 0);

1✔

179

        ASSERT_EQ(strncasecmp16(u"", u"", 10), 0);

1✔

180

        ASSERT_EQ(strncasecmp16(u"abc", u"abc", 2), 0);

1✔

181

        ASSERT_EQ(strncasecmp16(u"aBc", u"AbC", 3), 0);

1✔

182

        ASSERT_EQ(strncasecmp16(u"aBC", u"Abc", 4), 0);

1✔

183

        ASSERT_EQ(strncasecmp16(u"", u"a", 0), 0);

1✔

184

        ASSERT_EQ(strncasecmp16(u"b", u"a", 0), 0);

1✔

185

        ASSERT_LT(strncasecmp16(u"", u"a", 3), 0);

1✔

186

        ASSERT_EQ(strncasecmp16(u"=", u"=", 1), 0);

1✔

187

        ASSERT_EQ(strncasecmp16(u"A", u"a", 1), 0);

1✔

188

        ASSERT_EQ(strncasecmp16(u"a", u"A", 2), 0);

1✔

189

        ASSERT_LT(strncasecmp16(u"a", u"Aa", 2), 0);

1✔

190

        ASSERT_LT(strncasecmp16(u"12\00034", u"12345", 4), 0);

1✔

191

        ASSERT_LT(strncasecmp16(u"12\00034", u"12345", SIZE_MAX), 0);

1✔

192

        ASSERT_EQ(strncasecmp16(u"abc\0def", u"ABC", SIZE_MAX), 0);

1✔

193

        ASSERT_LT(strncasecmp16(u"abc\0def", u"ABCDEF", SIZE_MAX), 0);

1✔

195

        ASSERT_EQ(strncasecmp16((char16_t[]){ UINT16_MAX }, (char16_t[]){ UINT16_MAX }, 1), 0);

1✔

196

        ASSERT_LT(strncasecmp16((char16_t[]){ 0 }, (char16_t[]){ UINT16_MAX }, 1), 0);

1✔

197

        ASSERT_GT(strncasecmp16((char16_t[]){ UINT16_MAX }, (char16_t[]){ 0 }, 1), 0);

1✔

198

1✔

200

TEST(strcpy8) {

1✔

201

        char buf[128];

1✔

203

        ASSERT_PTR_EQ(strcpy8(buf, "123"), buf);

1✔

204

        ASSERT_TRUE(streq8(buf, "123"));

1✔

205

        ASSERT_PTR_EQ(strcpy8(buf, ""), buf);

1✔

206

        ASSERT_TRUE(streq8(buf, ""));

1✔

207

        ASSERT_PTR_EQ(strcpy8(buf, "A"), buf);

1✔

208

        ASSERT_TRUE(streq8(buf, "A"));

1✔

209

        ASSERT_PTR_EQ(strcpy8(buf, NULL), buf);

1✔

210

        ASSERT_TRUE(streq8(buf, ""));

1✔

211

1✔

213

TEST(strcpy16) {

1✔

214

        char16_t buf[128];

1✔

216

        ASSERT_PTR_EQ(strcpy16(buf, u"123"), buf);

1✔

217

        ASSERT_TRUE(streq16(buf, u"123"));

1✔

218

        ASSERT_PTR_EQ(strcpy16(buf, u""), buf);

1✔

219

        ASSERT_TRUE(streq16(buf, u""));

1✔

220

        ASSERT_PTR_EQ(strcpy16(buf, u"A"), buf);

1✔

221

        ASSERT_TRUE(streq16(buf, u"A"));

1✔

222

        ASSERT_PTR_EQ(strcpy16(buf, NULL), buf);

1✔

223

        ASSERT_TRUE(streq16(buf, u""));

1✔

224

1✔

226

TEST(strchr8) {

1✔

227

        ASSERT_NULL(strchr8(NULL, 'a'));

1✔

228

        ASSERT_NULL(strchr8("", 'a'));

1✔

229

        ASSERT_NULL(strchr8("123", 'a'));

1✔

231

        const char str[] = "abcaBc";

1✔

232

        ASSERT_PTR_EQ(strchr8(str, 'a'), &str[0]);

1✔

233

        ASSERT_PTR_EQ(strchr8(str, 'c'), &str[2]);

1✔

234

        ASSERT_PTR_EQ(strchr8(str, 'B'), &str[4]);

1✔

236

        ASSERT_PTR_EQ(strchr8(str, 0), str + strlen8(str));

1✔

237

1✔

239

TEST(strchr16) {

1✔

240

        ASSERT_NULL(strchr16(NULL, 'a'));

1✔

241

        ASSERT_NULL(strchr16(u"", 'a'));

1✔

242

        ASSERT_NULL(strchr16(u"123", 'a'));

1✔

244

        const char16_t str[] = u"abcaBc";

1✔

245

        ASSERT_PTR_EQ(strchr16(str, 'a'), &str[0]);

1✔

246

        ASSERT_PTR_EQ(strchr16(str, 'c'), &str[2]);

1✔

247

        ASSERT_PTR_EQ(strchr16(str, 'B'), &str[4]);

1✔

249

        ASSERT_PTR_EQ(strchr16(str, 0), str + strlen16(str));

1✔

250

1✔

252

TEST(xstrndup8) {

1✔

253

        char *s = NULL;

1✔

255

        ASSERT_NULL(xstrndup8(NULL, 0));

1✔

256

        ASSERT_NULL(xstrndup8(NULL, 10));

1✔

258

        ASSERT_NOT_NULL(s = xstrndup8("", 10));

1✔

259

        ASSERT_TRUE(streq8(s, ""));

1✔

260

        free(s);

1✔

262

        ASSERT_NOT_NULL(s = xstrndup8("abc", 0));

1✔

263

        ASSERT_TRUE(streq8(s, ""));

1✔

264

        free(s);

1✔

266

        ASSERT_NOT_NULL(s = xstrndup8("ABC", 3));

1✔

267

        ASSERT_TRUE(streq8(s, "ABC"));

1✔

268

        free(s);

1✔

270

        ASSERT_NOT_NULL(s = xstrndup8("123abcDEF", 5));

1✔

271

        ASSERT_TRUE(streq8(s, "123ab"));

1✔

272

        free(s);

1✔

273

1✔

275

TEST(xstrdup8) {

1✔

276

        char *s = NULL;

1✔

278

        ASSERT_NULL(xstrdup8(NULL));

1✔

280

        ASSERT_NOT_NULL(s = xstrdup8(""));

1✔

281

        ASSERT_TRUE(streq8(s, ""));

1✔

282

        free(s);

1✔

284

        ASSERT_NOT_NULL(s = xstrdup8("1"));

1✔

285

        ASSERT_TRUE(streq8(s, "1"));

1✔

286

        free(s);

1✔

288

        ASSERT_NOT_NULL(s = xstrdup8("123abcDEF"));

1✔

289

        ASSERT_TRUE(streq8(s, "123abcDEF"));

1✔

290

        free(s);

1✔

291

1✔

293

TEST(xstrndup16) {

1✔

294

        char16_t *s = NULL;

1✔

296

        ASSERT_NULL(xstrndup16(NULL, 0));

1✔

297

        ASSERT_NULL(xstrndup16(NULL, 10));

1✔

299

        ASSERT_NOT_NULL(s = xstrndup16(u"", 10));

1✔

300

        ASSERT_TRUE(streq16(s, u""));

1✔

301

        free(s);

1✔

303

        ASSERT_NOT_NULL(s = xstrndup16(u"abc", 0));

1✔

304

        ASSERT_TRUE(streq16(s, u""));

1✔

305

        free(s);

1✔

307

        ASSERT_NOT_NULL(s = xstrndup16(u"ABC", 3));

1✔

308

        ASSERT_TRUE(streq16(s, u"ABC"));

1✔

309

        free(s);

1✔

311

        ASSERT_NOT_NULL(s = xstrndup16(u"123abcDEF", 5));

1✔

312

        ASSERT_TRUE(streq16(s, u"123ab"));

1✔

313

        free(s);

1✔

314

1✔

316

TEST(xstrdup16) {

1✔

317

        char16_t *s = NULL;

1✔

319

        ASSERT_NULL(xstrdup16(NULL));

1✔

321

        ASSERT_NOT_NULL(s = xstrdup16(u""));

1✔

322

        ASSERT_TRUE(streq16(s, u""));

1✔

323

        free(s);

1✔

325

        ASSERT_NOT_NULL(s = xstrdup16(u"1"));

1✔

326

        ASSERT_TRUE(streq16(s, u"1"));

1✔

327

        free(s);

1✔

329

        ASSERT_NOT_NULL(s = xstrdup16(u"123abcDEF"));

1✔

330

        ASSERT_TRUE(streq16(s, u"123abcDEF"));

1✔

331

        free(s);

1✔

332

1✔

334

TEST(xstrn8_to_16) {

1✔

335

        char16_t *s = NULL;

1✔

337

        ASSERT_NOT_NULL(s = xstrn8_to_16(NULL, 0));

1✔

338

        ASSERT_TRUE(streq16(s, u""));

1✔

339

        free(s);

1✔

341

        ASSERT_NOT_NULL(s = xstrn8_to_16("", 0));

1✔

342

        ASSERT_TRUE(streq16(s, u""));

1✔

343

        free(s);

1✔

345

        ASSERT_NOT_NULL(s = xstrn8_to_16("a", 0));

1✔

346

        ASSERT_TRUE(streq16(s, u""));

1✔

347

        free(s);

1✔

349

        ASSERT_NOT_NULL(s = xstrn8_to_16("", 1));

1✔

350

        ASSERT_TRUE(streq16(s, u""));

1✔

351

        free(s);

1✔

353

        ASSERT_NOT_NULL(s = xstrn8_to_16("1", 1));

1✔

354

        ASSERT_TRUE(streq16(s, u"1"));

1✔

355

        free(s);

1✔

357

        ASSERT_NOT_NULL(s = xstr8_to_16("abcxyzABCXYZ09 .,-_#*!\"§$%&/()=?`~"));

1✔

358

        ASSERT_TRUE(streq16(s, u"abcxyzABCXYZ09 .,-_#*!\"§$%&/()=?`~"));

1✔

359

        free(s);

1✔

361

        ASSERT_NOT_NULL(s = xstr8_to_16("ÿⱿ𝇉 😺"));

1✔

362

        ASSERT_TRUE(streq16(s, u"ÿⱿ "));

1✔

363

        free(s);

1✔

365

        ASSERT_NOT_NULL(s = xstrn8_to_16("¶¶", 3));

1✔

366

        ASSERT_TRUE(streq16(s, u"¶"));

1✔

367

        free(s);

1✔

368

1✔

370

TEST(xstrn16_to_ascii) {

1✔

371

        char *s;

1✔

373

        ASSERT_NOT_NULL(s = xstrn16_to_ascii(NULL, 0));

1✔

374

        ASSERT_TRUE(streq8(s, ""));

1✔

375

        free(s);

1✔

377

        ASSERT_NOT_NULL(s = xstrn16_to_ascii(u"", 0));

1✔

378

        ASSERT_TRUE(streq8(s, ""));

1✔

379

        free(s);

1✔

381

        ASSERT_NOT_NULL(s = xstrn16_to_ascii(u"a", 0));

1✔

382

        ASSERT_TRUE(streq8(s, ""));

1✔

383

        free(s);

1✔

385

        ASSERT_NOT_NULL(s = xstrn16_to_ascii(u"", 1));

1✔

386

        ASSERT_TRUE(streq8(s, ""));

1✔

387

        free(s);

1✔

389

        ASSERT_NOT_NULL(s = xstrn16_to_ascii(u"1", 1));

1✔

390

        ASSERT_TRUE(streq8(s, "1"));

1✔

391

        free(s);

1✔

393

        ASSERT_NOT_NULL(s = xstr16_to_ascii(u"abcxyzABCXYZ09 .,-_#*!\"$%&/()=?`~"));

1✔

394

        ASSERT_TRUE(streq8(s, "abcxyzABCXYZ09 .,-_#*!\"$%&/()=?`~"));

1✔

395

        free(s);

1✔

397

        ASSERT_NULL(xstr16_to_ascii(u"ÿⱿ𝇉 😺"));

1✔

398

        ASSERT_NULL(xstr16_to_ascii(u"¶¶"));

1✔

399

1✔

401

TEST(startswith8) {

1✔

402

        ASSERT_TRUE(streq8(startswith8("", ""), ""));

1✔

403

        ASSERT_TRUE(streq8(startswith8("x", ""), "x"));

1✔

404

        ASSERT_NULL(startswith8("", "x"));

1✔

405

        ASSERT_NULL(startswith8("", "xxxxxxxx"));

1✔

406

        ASSERT_TRUE(streq8(startswith8("xxx", "x"), "xx"));

1✔

407

        ASSERT_TRUE(streq8(startswith8("xxx", "xx"), "x"));

1✔

408

        ASSERT_TRUE(streq8(startswith8("xxx", "xxx"), ""));

1✔

409

        ASSERT_NULL(startswith8("xxx", "xxxx"));

1✔

410

        ASSERT_NULL(startswith8(NULL, ""));

1✔

411

1✔

433

TEST(efi_fnmatch) {

1✔

434

        TEST_FNMATCH_ONE("", "", true);

1✔

435

        TEST_FNMATCH_ONE("abc", "abc", true);

1✔

436

        TEST_FNMATCH_ONE("aBc", "abc", false);

1✔

437

        TEST_FNMATCH_ONE("b", "a", false);

1✔

438

        TEST_FNMATCH_ONE("b", "", false);

1✔

439

        TEST_FNMATCH_ONE("abc", "a", false);

1✔

440

        TEST_FNMATCH_ONE("a?c", "azc", true);

1✔

441

        TEST_FNMATCH_ONE("???", "?.9", true);

1✔

442

        TEST_FNMATCH_ONE("1?", "1", false);

1✔

443

        TEST_FNMATCH_ONE("***", "", true);

1✔

444

        TEST_FNMATCH_ONE("*", "123", true);

1✔

445

        TEST_FNMATCH_ONE("**", "abcd", true);

1✔

446

        TEST_FNMATCH_ONE("*b*", "abcd", true);

1✔

447

        TEST_FNMATCH_ONE("abc*d", "abc", false);

1✔

448

        TEST_FNMATCH_ONE("start*end", "startend", true);

1✔

449

        TEST_FNMATCH_ONE("start*end", "startendend", true);

1✔

450

        TEST_FNMATCH_ONE("start*end", "startenddne", false);

1✔

451

        TEST_FNMATCH_ONE("start*end", "startendstartend", true);

1✔

452

        TEST_FNMATCH_ONE("start*end", "starten", false);

1✔

453

        TEST_FNMATCH_ONE("*.conf", "arch.conf", true);

1✔

454

        TEST_FNMATCH_ONE("debian-*.conf", "debian-wheezy.conf", true);

1✔

455

        TEST_FNMATCH_ONE("debian-*.*", "debian-wheezy.efi", true);

1✔

456

        TEST_FNMATCH_ONE("ab*cde", "abzcd", false);

1✔

457

        TEST_FNMATCH_ONE("\\*\\a\\[", "*a[", true);

1✔

458

        TEST_FNMATCH_ONE("[abc] [abc] [abc]", "a b c", true);

1✔

459

        TEST_FNMATCH_ONE("abc]", "abc]", true);

1✔

460

        TEST_FNMATCH_ONE("[abc]", "z", false);

1✔

461

        TEST_FNMATCH_ONE("[abc", "a", false);

1✔

462

        TEST_FNMATCH_ONE("[][!] [][!] [][!]", "[ ] !", true);

1✔

463

        TEST_FNMATCH_ONE("[]-] []-]", "] -", true);

1✔

464

        TEST_FNMATCH_ONE_MAY_SKIP_LIBC("[1\\]] [1\\]]", "1 ]", true);

1✔

465

        TEST_FNMATCH_ONE("[$-\\+]", "&", true);

1✔

466

        TEST_FNMATCH_ONE("[1-3A-C] [1-3A-C]", "2 B", true);

1✔

467

        TEST_FNMATCH_ONE("[3-5] [3-5] [3-5]", "3 4 5", true);

1✔

468

        TEST_FNMATCH_ONE("[f-h] [f-h] [f-h]", "f g h", true);

1✔

469

        TEST_FNMATCH_ONE_MAY_SKIP_LIBC("[a-c-f] [a-c-f] [a-c-f] [a-c-f] [a-c-f]", "a b c - f", true);

1✔

470

        TEST_FNMATCH_ONE_MAY_SKIP_LIBC("[a-c-f]", "e", false);

1✔

471

        TEST_FNMATCH_ONE("[--0] [--0] [--0]", "- . 0", true);

1✔

472

        TEST_FNMATCH_ONE("[+--] [+--] [+--]", "+ , -", true);

1✔

473

        TEST_FNMATCH_ONE("[f-l]", "m", false);

1✔

474

        TEST_FNMATCH_ONE("[b]", "z-a", false);

1✔

475

        TEST_FNMATCH_ONE_MAY_SKIP_LIBC("[a\\-z]", "b", false);

1✔

476

        TEST_FNMATCH_ONE("?a*b[.-0]c", "/a/b/c", true);

1✔

477

        TEST_FNMATCH_ONE("debian-*-*-*.*", "debian-jessie-2018-06-17-kernel-image-5.10.0-16-amd64.efi", true);

1✔

480

        TEST_FNMATCH_ONE(

1✔

484

        TEST_FNMATCH_ONE(

1✔

488

1✔

490

TEST(parse_number8) {

1✔

491

        uint64_t u;

1✔

492

        const char *tail;

1✔

494

        ASSERT_FALSE(parse_number8(NULL, &u, NULL));

1✔

495

        ASSERT_FALSE(parse_number8("", &u, NULL));

1✔

496

        ASSERT_FALSE(parse_number8("a1", &u, NULL));

1✔

497

        ASSERT_FALSE(parse_number8("1a", &u, NULL));

1✔

498

        ASSERT_FALSE(parse_number8("-42", &u, NULL));

1✔

499

        ASSERT_FALSE(parse_number8("18446744073709551616", &u, NULL));

1✔

501

        ASSERT_TRUE(parse_number8("0", &u, NULL));

1✔

502

        ASSERT_EQ(u, 0u);

1✔

503

        ASSERT_TRUE(parse_number8("1", &u, NULL));

1✔

504

        ASSERT_EQ(u, 1u);

1✔

505

        ASSERT_TRUE(parse_number8("999", &u, NULL));

1✔

506

        ASSERT_EQ(u, 999u);

1✔

507

        ASSERT_TRUE(parse_number8("18446744073709551615", &u, NULL));

1✔

508

        ASSERT_EQ(u, UINT64_MAX);

1✔

509

        ASSERT_TRUE(parse_number8("42", &u, &tail));

1✔

510

        ASSERT_EQ(u, 42u);

1✔

511

        ASSERT_TRUE(streq8(tail, ""));

1✔

512

        ASSERT_TRUE(parse_number8("54321rest", &u, &tail));

1✔

513

        ASSERT_EQ(u, 54321u);

1✔

514

        ASSERT_TRUE(streq8(tail, "rest"));

1✔

515

1✔

517

TEST(parse_number16) {

1✔

518

        uint64_t u;

1✔

519

        const char16_t *tail;

1✔

521

        ASSERT_FALSE(parse_number16(NULL, &u, NULL));

1✔

522

        ASSERT_FALSE(parse_number16(u"", &u, NULL));

1✔

523

        ASSERT_FALSE(parse_number16(u"a1", &u, NULL));

1✔

524

        ASSERT_FALSE(parse_number16(u"1a", &u, NULL));

1✔

525

        ASSERT_FALSE(parse_number16(u"-42", &u, NULL));

1✔

526

        ASSERT_FALSE(parse_number16(u"18446744073709551616", &u, NULL));

1✔

528

        ASSERT_TRUE(parse_number16(u"0", &u, NULL));

1✔

529

        ASSERT_EQ(u, 0u);

1✔

530

        ASSERT_TRUE(parse_number16(u"1", &u, NULL));

1✔

531

        ASSERT_EQ(u, 1u);

1✔

532

        ASSERT_TRUE(parse_number16(u"999", &u, NULL));

1✔

533

        ASSERT_EQ(u, 999u);

1✔

534

        ASSERT_TRUE(parse_number16(u"18446744073709551615", &u, NULL));

1✔

535

        ASSERT_EQ(u, UINT64_MAX);

1✔

536

        ASSERT_TRUE(parse_number16(u"42", &u, &tail));

1✔

537

        ASSERT_EQ(u, 42u);

1✔

538

        ASSERT_TRUE(streq16(tail, u""));

1✔

539

        ASSERT_TRUE(parse_number16(u"54321rest", &u, &tail));

1✔

540

        ASSERT_EQ(u, 54321u);

1✔

541

        ASSERT_TRUE(streq16(tail, u"rest"));

1✔

542

1✔

544

TEST(parse_boolean) {

1✔

545

        bool b;

1✔

547

        ASSERT_FALSE(parse_boolean(NULL, &b));

1✔

548

        ASSERT_FALSE(parse_boolean("", &b));

1✔

549

        ASSERT_FALSE(parse_boolean("ja", &b));

1✔

550

        ASSERT_TRUE(parse_boolean("1", &b));

1✔

551

        ASSERT_TRUE(b);

1✔

552

        ASSERT_TRUE(parse_boolean("y", &b));

1✔

553

        ASSERT_TRUE(b);

1✔

554

        ASSERT_TRUE(parse_boolean("yes", &b));

1✔

555

        ASSERT_TRUE(b);

1✔

556

        ASSERT_TRUE(parse_boolean("t", &b));

1✔

557

        ASSERT_TRUE(b);

1✔

558

        ASSERT_TRUE(parse_boolean("true", &b));

1✔

559

        ASSERT_TRUE(b);

1✔

560

        ASSERT_TRUE(parse_boolean("on", &b));

1✔

561

        ASSERT_TRUE(b);

1✔

562

        ASSERT_TRUE(parse_boolean("0", &b));

1✔

563

        ASSERT_FALSE(b);

1✔

564

        ASSERT_TRUE(parse_boolean("n", &b));

1✔

565

        ASSERT_FALSE(b);

1✔

566

        ASSERT_TRUE(parse_boolean("no", &b));

1✔

567

        ASSERT_FALSE(b);

1✔

568

        ASSERT_TRUE(parse_boolean("f", &b));

1✔

569

        ASSERT_FALSE(b);

1✔

570

        ASSERT_TRUE(parse_boolean("false", &b));

1✔

571

        ASSERT_FALSE(b);

1✔

572

        ASSERT_TRUE(parse_boolean("off", &b));

1✔

573

        ASSERT_FALSE(b);

1✔

574

1✔

576

TEST(line_get_key_value) {

1✔

577

        char s1[] = "key=value\n"

1✔

582

        char s2[] = "this parser\n"

1✔

587

        size_t pos = 0;

1✔

588

        char *key, *value;

1✔

590

        ASSERT_NULL(line_get_key_value((char[]){ "" }, "=", &pos, &key, &value));

1✔

591

        ASSERT_NULL(line_get_key_value((char[]){ "\t" }, " \t", &pos, &key, &value));

1✔

593

        pos = 0;

1✔

594

        ASSERT_NOT_NULL(line_get_key_value(s1, "=", &pos, &key, &value));

1✔

595

        ASSERT_TRUE(streq8(key, "key"));

1✔

596

        ASSERT_TRUE(streq8(value, "value"));

1✔

597

        ASSERT_NOT_NULL(line_get_key_value(s1, "=", &pos, &key, &value));

1✔

598

        ASSERT_TRUE(streq8(key, "k-e-y"));

1✔

599

        ASSERT_TRUE(streq8(value, "quoted value"));

1✔

600

        ASSERT_NOT_NULL(line_get_key_value(s1, "=", &pos, &key, &value));

1✔

601

        ASSERT_TRUE(streq8(key, "wrong"));

1✔

602

        ASSERT_TRUE(streq8(value, " 'quotes'"));

1✔

603

        ASSERT_NOT_NULL(line_get_key_value(s1, "=", &pos, &key, &value));

1✔

604

        ASSERT_TRUE(streq8(key, "odd"));

1✔

605

        ASSERT_TRUE(streq8(value, " stripping  # with comments"));

1✔

606

        ASSERT_NULL(line_get_key_value(s1, "=", &pos, &key, &value));

1✔

608

        pos = 0;

1✔

609

        ASSERT_NOT_NULL(line_get_key_value(s2, " \t", &pos, &key, &value));

1✔

610

        ASSERT_TRUE(streq8(key, "this"));

1✔

611

        ASSERT_TRUE(streq8(value, "parser"));

1✔

612

        ASSERT_NOT_NULL(line_get_key_value(s2, " \t", &pos, &key, &value));

1✔

613

        ASSERT_TRUE(streq8(key, "also"));

1✔

614

        ASSERT_TRUE(streq8(value, "used"));

1✔

615

        ASSERT_NOT_NULL(line_get_key_value(s2, " \t", &pos, &key, &value));

1✔

616

        ASSERT_TRUE(streq8(key, "for"));

1✔

617

        ASSERT_TRUE(streq8(value, "the conf"));

1✔

618

        ASSERT_NOT_NULL(line_get_key_value(s2, " \t", &pos, &key, &value));

1✔

619

        ASSERT_TRUE(streq8(key, "format"));

1✔

620

        ASSERT_TRUE(streq8(value, "!!"));

1✔

621

        ASSERT_NULL(line_get_key_value(s2, " \t", &pos, &key, &value));

1✔

624

        _cleanup_free_ char *osrel = NULL;

2✔

625

        if (read_full_file("/usr/lib/os-release", &osrel, NULL) >= 0) {

1✔

626

                pos = 0;

1✔

627

                while (line_get_key_value(osrel, "=", &pos, &key, &value)) {

12✔

628

                        ASSERT_NOT_NULL(key);

11✔

629

                        ASSERT_NOT_NULL(value);

11✔

630

                        printf("%s = %s\n", key, value);

11✔

633

1✔

635

TEST(hexdump) {

1✔

636

        char16_t *hex;

1✔

638

        ASSERT_NOT_NULL(hex = hexdump(NULL, 0));

1✔

639

        ASSERT_TRUE(streq16(hex, u""));

1✔

640

        free(hex);

1✔

642

        ASSERT_NOT_NULL(hex = hexdump("1", 2));

1✔

643

        ASSERT_TRUE(streq16(hex, u"3100"));

1✔

644

        free(hex);

1✔

646

        ASSERT_NOT_NULL(hex = hexdump("abc", 4));

1✔

647

        ASSERT_TRUE(streq16(hex, u"61626300"));

1✔

648

        free(hex);

1✔

650

        ASSERT_NOT_NULL(hex = hexdump((uint8_t[]){ 0x0, 0x42, 0xFF, 0xF1, 0x1F }, 5));

1✔

651

        ASSERT_TRUE(streq16(hex, u"0042fff11f"));

1✔

652

        free(hex);

1✔

653

1✔

655

_printf_(1, 2) static void test_printf_one(const char *format, ...) {

69✔

656

        va_list ap, ap_efi;

69✔

657

        int r;

69✔

659

        va_start(ap, format);

69✔

660

        va_copy(ap_efi, ap);

69✔

662

        _cleanup_free_ char *buf = NULL;

138✔

663

        ASSERT_OK(r = vasprintf(&buf, format, ap));

69✔

664

        log_info("/* %s(%s) -> \"%.100s\" */", __func__, format, buf);

69✔

667

        ASSERT_NOT_NULL(buf_efi = xvasprintf_status(0, format, ap_efi));

69✔

670

        for (size_t i = 0; i <= (size_t) r; i++) {

44,313✔

671

                if (buf[i] != buf_efi[i])

44,244✔

673

                buf[i] = buf_efi[i];

44,244✔

676

        log_info("%.100s", buf);

69✔

677

        ASSERT_TRUE(eq);

69✔

679

        va_end(ap);

69✔

680

        va_end(ap_efi);

69✔

681

69✔

683

TEST(xvasprintf_status) {

1✔

686

        test_printf_one("");

1✔

688

        test_printf_one("string");

1✔

689

        test_printf_one("%%-%%%%");

1✔

692

        test_printf_one("%p %p %32p %*p %*p", NULL, (void *) 0xF, &errno, 0, &saved_argc, 20, &saved_argv);

1✔

693

        test_printf_one("%-10p %-32p %-*p %-*p", NULL, &errno, 0, &saved_argc, 20, &saved_argv);

1✔

700

        test_printf_one("%c %3c %*c %*c %-8c", '1', '!', 0, 'a', 9, '_', '>');

1✔

702

        test_printf_one("%s %s %s", "012345", "6789", "ab");

1✔

703

        test_printf_one("%.4s %.4s %.4s %.0s", "cdefgh", "ijkl", "mn", "@");

1✔

704

        test_printf_one("%8s %8s %8s", "opqrst", "uvwx", "yz");

1✔

705

        test_printf_one("%8.4s %8.4s %8.4s %8.0s", "ABCDEF", "GHIJ", "KL", "$");

1✔

706

        test_printf_one("%4.8s %4.8s %4.8s", "ABCDEFGHIJ", "ABCDEFGH", "ABCD");

1✔

708

        test_printf_one("%.*s %.*s %.*s %.*s", 4, "012345", 4, "6789", 4, "ab", 0, "&");

1✔

709

        test_printf_one("%*s %*s %*s", 8, "cdefgh", 8, "ijkl", 8, "mn");

1✔

710

        test_printf_one("%*.*s %*.*s %*.*s %*.*s", 8, 4, "opqrst", 8, 4, "uvwx", 8, 4, "yz", 8, 0, "#");

1✔

711

        test_printf_one("%*.*s %*.*s %*.*s", 3, 8, "OPQRST", 3, 8, "UVWX", 3, 8, "YZ");

1✔

713

        test_printf_one("%ls %ls %ls", L"012345", L"6789", L"ab");

1✔

714

        test_printf_one("%.4ls %.4ls %.4ls %.0ls", L"cdefgh", L"ijkl", L"mn", L"@");

1✔

715

        test_printf_one("%8ls %8ls %8ls", L"opqrst", L"uvwx", L"yz");

1✔

716

        test_printf_one("%8.4ls %8.4ls %8.4ls %8.0ls", L"ABCDEF", L"GHIJ", L"KL", L"$");

1✔

717

        test_printf_one("%4.8ls %4.8ls %4.8ls", L"ABCDEFGHIJ", L"ABCDEFGH", L"ABCD");

1✔

719

        test_printf_one("%.*ls %.*ls %.*ls %.*ls", 4, L"012345", 4, L"6789", 4, L"ab", 0, L"&");

1✔

720

        test_printf_one("%*ls %*ls %*ls", 8, L"cdefgh", 8, L"ijkl", 8, L"mn");

1✔

721

        test_printf_one("%*.*ls %*.*ls %*.*ls %*.*ls", 8, 4, L"opqrst", 8, 4, L"uvwx", 8, 4, L"yz", 8, 0, L"#");

1✔

722

        test_printf_one("%*.*ls %*.*ls %*.*ls", 3, 8, L"OPQRST", 3, 8, L"UVWX", 3, 8, L"YZ");

1✔

724

        test_printf_one("%-14s %-10.0s %-10.3s", "left", "", "chopped");

1✔

725

        test_printf_one("%-14ls %-10.0ls %-10.3ls", L"left", L"", L"chopped");

1✔

727

        test_printf_one("%.6s", (char[]){ 'n', 'o', ' ', 'n', 'u', 'l' });

1✔

728

        test_printf_one("%.6ls", (wchar_t[]){ 'n', 'o', ' ', 'n', 'u', 'l' });

1✔

730

        test_printf_one("%u %u %u", 0U, 42U, 1234567890U);

1✔

731

        test_printf_one("%i %i %i", 0, -42, -1234567890);

1✔

732

        test_printf_one("%x %x %x", 0x0U, 0x42U, 0x123ABCU);

1✔

733

        test_printf_one("%X %X %X", 0x1U, 0x43U, 0x234BCDU);

1✔

734

        test_printf_one("%#x %#x %#x", 0x2U, 0x44U, 0x345CDEU);

1✔

735

        test_printf_one("%#X %#X %#X", 0x3U, 0x45U, 0x456FEDU);

1✔

737

        test_printf_one("%u %lu %llu %zu", UINT_MAX, ULONG_MAX, ULLONG_MAX, SIZE_MAX);

1✔

738

        test_printf_one("%i %i %zi", INT_MIN, INT_MAX, SSIZE_MAX);

1✔

739

        test_printf_one("%li %li %lli %lli", LONG_MIN, LONG_MAX, LLONG_MIN, LLONG_MAX);

1✔

740

        test_printf_one("%x %#lx %llx %#zx", UINT_MAX, ULONG_MAX, ULLONG_MAX, SIZE_MAX);

1✔

741

        test_printf_one("%X %#lX %llX %#zX", UINT_MAX, ULONG_MAX, ULLONG_MAX, SIZE_MAX);

1✔

742

        test_printf_one("%ju %ji %ji", UINTMAX_MAX, INTMAX_MIN, INTMAX_MAX);

1✔

743

        test_printf_one("%ti %ti", PTRDIFF_MIN, PTRDIFF_MAX);

1✔

745

        test_printf_one("%" PRIu32 " %" PRIi32 " %" PRIi32, UINT32_MAX, INT32_MIN, INT32_MAX);

1✔

746

        test_printf_one("%" PRIx32 " %" PRIX32, UINT32_MAX, UINT32_MAX);

1✔

747

        test_printf_one("%#" PRIx32 " %#" PRIX32, UINT32_MAX, UINT32_MAX);

1✔

749

        test_printf_one("%" PRIu64 " %" PRIi64 " %" PRIi64, UINT64_MAX, INT64_MIN, INT64_MAX);

1✔

750

        test_printf_one("%" PRIx64 " %" PRIX64, UINT64_MAX, UINT64_MAX);

1✔

751

        test_printf_one("%#" PRIx64 " %#" PRIX64, UINT64_MAX, UINT64_MAX);

1✔

753

        test_printf_one("%.11u %.11i %.11x %.11X %#.11x %#.11X", 1U, -2, 3U, 0xA1U, 0xB2U, 0xC3U);

1✔

754

        test_printf_one("%13u %13i %13x %13X %#13x %#13X", 4U, -5, 6U, 0xD4U, 0xE5U, 0xF6U);

1✔

755

        test_printf_one("%9.5u %9.5i %9.5x %9.5X %#9.5x %#9.5X", 7U, -8, 9U, 0xA9U, 0xB8U, 0xC7U);

1✔

756

        test_printf_one("%09u %09i %09x %09X %#09x %#09X", 4U, -5, 6U, 0xD6U, 0xE5U, 0xF4U);

1✔

758

        test_printf_one("%*u %.*u %*i %.*i", 15, 42U, 15, 43U, 15, -42, 15, -43);

1✔

759

        test_printf_one("%*.*u %*.*i", 14, 10, 13U, 14, 10, -14);

1✔

760

        test_printf_one("%*x %*X %.*x %.*X", 15, 0x1AU, 15, 0x2BU, 15, 0x3CU, 15, 0x4DU);

1✔

761

        test_printf_one("%#*x %#*X %#.*x %#.*X", 15, 0xA1U, 15, 0xB2U, 15, 0xC3U, 15, 0xD4U);

1✔

762

        test_printf_one("%*.*x %*.*X", 14, 10, 0x1AU, 14, 10, 0x2BU);

1✔

763

        test_printf_one("%#*.*x %#*.*X", 14, 10, 0x3CU, 14, 10, 0x4DU);

1✔

765

        test_printf_one("%+.5i %+.5i % .7i % .7i", -15, 51, -15, 51);

1✔

766

        test_printf_one("%+5.i %+5.i % 7.i % 7.i", -15, 51, -15, 51);

1✔

768

        test_printf_one("%-10u %-10i %-10x %#-10X %- 10i", 1u, -2, 0xA2D2u, 0XB3F4u, -512);

1✔

769

        test_printf_one("%-10.6u %-10.6i %-10.6x %#-10.6X %- 10.6i", 1u, -2, 0xA2D2u, 0XB3F4u, -512);

1✔

770

        test_printf_one("%-6.10u %-6.10i %-6.10x %#-6.10X %- 6.10i", 3u, -4, 0x2A2Du, 0X3B4Fu, -215);

1✔

771

        test_printf_one("%*.u %.*i %.*i", -4, 9u, -4, 8, -4, -6);

1✔

773

        test_printf_one("%.0u %.0i %.0x %.0X", 0u, 0, 0u, 0u);

1✔

774

        test_printf_one("%.*u %.*i %.*x %.*X", 0, 0u, 0, 0, 0, 0u, 0, 0u);

1✔

775

        test_printf_one("%*u %*i %*x %*X", -1, 0u, -1, 0, -1, 0u, -1, 0u);

1✔

777

        test_printf_one("%*s%*s%*s", 256, "", 256, "", 4096, ""); /* Test buf growing. */

1✔

778

        test_printf_one("%0*i%0*i%0*i", 256, 0, 256, 0, 4096, 0); /* Test buf growing. */

1✔

779

        test_printf_one("%0*i", INT16_MAX, 0); /* Poor programmer's memzero. */

1✔

782

        char16_t *s;

1✔

784

        ASSERT_NOT_NULL(s = xasprintf_status(0, "\n \r \r\n"));

1✔

785

        ASSERT_TRUE(streq16(s, u"\r\n \r \r\r\n"));

1✔

786

        s = mfree(s);

1✔

788

        ASSERT_NOT_NULL(s = xasprintf_status(EFI_SUCCESS, "%m"));

1✔

789

        ASSERT_TRUE(streq16(s, u"Success"));

1✔

790

        s = mfree(s);

1✔

792

        ASSERT_NOT_NULL(s = xasprintf_status(EFI_SUCCESS, "%15m"));

1✔

793

        ASSERT_TRUE(streq16(s, u"        Success"));

1✔

794

        s = mfree(s);

1✔

796

        ASSERT_NOT_NULL(s = xasprintf_status(EFI_LOAD_ERROR, "%m"));

1✔

797

        ASSERT_TRUE(streq16(s, u"Load error"));

1✔

798

        s = mfree(s);

1✔

800

        ASSERT_NOT_NULL(s = xasprintf_status(0x42, "%m"));

1✔

801

        ASSERT_TRUE(streq16(s, u"0x42"));

1✔

802

        s = mfree(s);

1✔

803

1✔

805

TEST(efi_memchr) {

1✔

806

        ASSERT_TRUE(streq8(efi_memchr("abcde", 'c', 5), "cde"));

1✔

807

        ASSERT_TRUE(streq8(efi_memchr("abcde", 'c', 3), "cde"));

1✔

808

        ASSERT_TRUE(streq8(efi_memchr("abcde", 'c', 2), NULL));

1✔

809

        ASSERT_TRUE(streq8(efi_memchr("abcde", 'c', 7), "cde"));

1✔

810

        ASSERT_TRUE(streq8(efi_memchr("abcde", 'q', 5), NULL));

1✔

811

        ASSERT_TRUE(streq8(efi_memchr("abcde", 'q', 0), NULL));

1✔

813

        ASSERT_TRUE(streq8(efi_memchr("abcde", 'a', 6), efi_memchr("abcde", 'a' + 0x100, 6)));

1✔

814

        ASSERT_TRUE(streq8(efi_memchr("abcde", 0, 6), ""));

1✔

815

        ASSERT_NULL(efi_memchr(NULL, 0, 0));

1✔

816

1✔

818

TEST(efi_memcmp) {

1✔

819

        ASSERT_EQ(efi_memcmp(NULL, NULL, 0), 0);

1✔

820

        ASSERT_EQ(efi_memcmp(NULL, NULL, 1), 0);

1✔

821

        ASSERT_LT(efi_memcmp(NULL, "", 1), 0);

1✔

822

        ASSERT_GT(efi_memcmp("", NULL, 1), 0);

1✔

823

        ASSERT_EQ(efi_memcmp("", "", 0), 0);

1✔

824

        ASSERT_EQ(efi_memcmp("", "", 1), 0);

1✔

825

        ASSERT_EQ(efi_memcmp("1", "1", 1), 0);

1✔

826

        ASSERT_LT(efi_memcmp("1", "2", 1), 0);

1✔

827

        ASSERT_LT(efi_memcmp("A", "a", 1), 0);

1✔

828

        ASSERT_GT(efi_memcmp("a", "A", 1), 0);

1✔

829

        ASSERT_EQ(efi_memcmp("abc", "ab", 2), 0);

1✔

830

        ASSERT_LT(efi_memcmp("ab", "abc", 3), 0);

1✔

831

        ASSERT_GT(efi_memcmp("abc", "ab", 3), 0);

1✔

832

        ASSERT_EQ(efi_memcmp("ab\000bd", "ab\000bd", 6), 0);

1✔

833

        ASSERT_LT(efi_memcmp("ab\000b\0", "ab\000bd", 6), 0);

1✔

834

1✔

836

TEST(efi_memcpy) {

1✔

837

        char buf[10];

1✔

839

        ASSERT_NULL(efi_memcpy(NULL, NULL, 0));

1✔

840

        ASSERT_NULL(efi_memcpy(NULL, "", 1));

1✔

841

        ASSERT_PTR_EQ(efi_memcpy(buf, NULL, 0), buf);

1✔

842

        ASSERT_PTR_EQ(efi_memcpy(buf, NULL, 1), buf);

1✔

843

        ASSERT_PTR_EQ(efi_memcpy(buf, "a", 0), buf);

1✔

845

        ASSERT_PTR_EQ(efi_memcpy(buf, "", 1), buf);

1✔

846

        ASSERT_EQ(memcmp(buf, "", 1), 0);

1✔

847

        ASSERT_PTR_EQ(efi_memcpy(buf, "1", 1), buf);

1✔

848

        ASSERT_EQ(memcmp(buf, "1", 1), 0);

1✔

849

        ASSERT_PTR_EQ(efi_memcpy(buf, "23", 3), buf);

1✔

850

        ASSERT_EQ(memcmp(buf, "23", 3), 0);

1✔

851

        ASSERT_PTR_EQ(efi_memcpy(buf, "45\0ab\0\0\0c", 9), buf);

1✔

852

        ASSERT_EQ(memcmp(buf, "45\0ab\0\0\0c", 9), 0);

1✔

853

1✔

855

TEST(efi_memset) {

1✔

856

        char buf[10];

1✔

858

        ASSERT_NULL(efi_memset(NULL, '1', 0));

1✔

859

        ASSERT_NULL(efi_memset(NULL, '1', 1));

1✔

860

        ASSERT_PTR_EQ(efi_memset(buf, '1', 0), buf);

1✔

862

        ASSERT_PTR_EQ(efi_memset(buf, '2', 1), buf);

1✔

863

        ASSERT_EQ(memcmp(buf, "2", 1), 0);

1✔

864

        ASSERT_PTR_EQ(efi_memset(buf, '4', 4), buf);

1✔

865

        ASSERT_EQ(memcmp(buf, "4444", 4), 0);

1✔

866

        ASSERT_PTR_EQ(efi_memset(buf, 'a', 10), buf);

1✔

867

        ASSERT_EQ(memcmp(buf, "aaaaaaaaaa", 10), 0);

1✔

868

1✔

870

TEST(efi_strspn) {

1✔

871

        ASSERT_EQ(strspn16(u"foobar", u"fo"), 3U);

1✔

872

        ASSERT_EQ(strspn16(u"foobar", u"ob"), 0U);

1✔

873

        ASSERT_EQ(strspn16(u"foobar", u"fxayzy"), 1U);

1✔

874

        ASSERT_EQ(strspn16(u"", u"abcdefef"), 0U);

1✔

875

        ASSERT_EQ(strspn16(u"", u""), 0U);

1✔

876

        ASSERT_EQ(strspn16(u"foobar", u""), 0U);

1✔

877

        ASSERT_EQ(strspn16(u"foffffffffffoobar", u"fofo"), 14U);

1✔

878

1✔

880

TEST(efi_strcspn) {

1✔

881

        ASSERT_EQ(strcspn16(u"foobar", u"fo"), 0U);

1✔

882

        ASSERT_EQ(strcspn16(u"foobar", u"bar"), 3U);

1✔

883

        ASSERT_EQ(strcspn16(u"foobar", u"xhyfzy"), 0U);

1✔

884

        ASSERT_EQ(strcspn16(u"foobar", u"xhyozy"), 1U);

1✔

885

        ASSERT_EQ(strcspn16(u"foobar", u"xhyzy"), 6U);

1✔

886

        ASSERT_EQ(strcspn16(u"", u"abcdefef"), 0U);

1✔

887

        ASSERT_EQ(strcspn16(u"", u""), 0U);

1✔

888

        ASSERT_EQ(strcspn16(u"foobar", u""), 6U);

1✔

889

        ASSERT_EQ(strcspn16(u"foffffffffffoobar", u"fofo"), 0U);

1✔

890

        ASSERT_EQ(strcspn16(u"foffffffffffoobar", u"a"), 15U);

1✔

891

1✔

893

DEFINE_TEST_MAIN(LOG_INFO);

1✔

systemd / systemd / 19349812769

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

systemd / systemd / 19349812769

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