randombit/botan | Build 21959119344 | source/src/tests/test_utils_bitvector.cpp | Coveralls

27

size_t rand_in_range(Botan::RandomNumberGenerator& rng, size_t min, size_t max) {

68✔

28

   if(min == max) {

68✔

32

   const size_t val = Botan::load_le<size_t>(rng.random_array<sizeof(size_t)>());

68✔

33

   return min + (val % (max - min));

68✔

37

std::vector<size_t> rand_indices(Botan::RandomNumberGenerator& rng, size_t n, size_t upper_bound) {

3✔

38

   auto shuffle = [&](std::vector<size_t>& v) {

6✔

40

      if(v.size() < 2) {

3✔

43

      for(size_t i = 0; i < v.size() - 1; ++i) {

65✔

44

         auto j = rand_in_range(rng, i, v.size());

62✔

45

         std::swap(v[i], v[j]);

62✔

47

};

3✔

49

   std::vector<size_t> indices(upper_bound);

3✔

50

   std::iota(indices.begin(), indices.end(), 0);

3✔

51

   shuffle(indices);

3✔

52

   indices.resize(n);

3✔

53

   return indices;

3✔

57

std::pair<Botan::bitvector, std::set<size_t>> rnd_bitvector_with_rnd_pois(Botan::RandomNumberGenerator& rng) {

3✔

58

   const Botan::bitvector bv(rand_in_range(rng, 0, 65));

3✔

59

   const size_t no_poi = rand_in_range(rng, 0, bv.size());

3✔

60

   auto points_of_interest = rand_indices(rng, no_poi, bv.size());

3✔

62

   return {bv, {points_of_interest.begin(), points_of_interest.end()}};

6✔

63

6✔

66

auto pattern_generator(size_t offset = 0) {

79✔

67

   return [i = offset]() mutable -> bool {

5,209✔

68

      const bool result = (i % mod) != 0;

5,209✔

69

      ++i;

5,209✔

74

std::vector<Test::Result> test_bitvector_bitwise_accessors(Botan::RandomNumberGenerator& rng) {

1✔

75

   return {

1✔

77

            [](auto& result) {

1✔

78

               const Botan::bitvector bv;

1✔

79

               result.confirm("default constructed bitvector is empty", bv.empty());

2✔

80

               result.test_eq("default constructed bitvector has zero size", bv.size(), size_t(0));

2✔

81

}),

1✔

84

            [](auto& result) {

1✔

85

               Botan::bitvector bv(10);

1✔

86

               result.confirm("allocated bitvector is not empty", !bv.empty());

2✔

87

               result.test_eq("allocated bitvector has allocated size", bv.size(), size_t(10));

1✔

88

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

11✔

89

                  result.confirm("bit not set yet", !bv.at(i));

20✔

91

}),

1✔

94

            [&](auto& result) {

1✔

95

               auto [bv, ones] = rnd_bitvector_with_rnd_pois(rng);

1✔

97

               for(const size_t i : ones) {

2✔

98

                  if(rng.next_byte() % 2 == 0) {

1✔

99

                     bv.set(i);

1✔

104

               for(size_t i = 0; i < bv.size(); ++i) {

29✔

105

                  result.confirm(Botan::fmt("bit {} in expected state", i), bv.at(i) == ones.contains(i));

84✔

107

}),

1✔

110

            [&](auto& result) {

1✔

111

               auto [bv, zeros] = rnd_bitvector_with_rnd_pois(rng);

1✔

112

               for(auto b : bv) {

15✔

113

                  b.set();

13✔

116

               for(const size_t i : zeros) {

1✔

123

               for(size_t i = 0; i < bv.size(); ++i) {

14✔

124

                  result.confirm(Botan::fmt("bit {} in expected state", i), bv.at(i) == !zeros.contains(i));

39✔

126

}),

1✔

129

            [&](auto& result) {

1✔

130

               auto [bv, ones] = rnd_bitvector_with_rnd_pois(rng);

1✔

132

               for(size_t i = 0; i < bv.size(); ++i) {

25✔

133

                  if(std::find(ones.begin(), ones.end(), i) == ones.end()) {

48✔

134

                     bv.set(i);

4✔

136

                  bv.flip(i);

24✔

138

               for(size_t i = 0; i < bv.size(); ++i) {

25✔

139

                  result.confirm(Botan::fmt("bit {} in expected state", i), bv.at(i) == ones.contains(i));

72✔

141

}),

1✔

144

            [](auto& result) {

1✔

145

               Botan::bitvector bv(10);

1✔

146

               result.template test_throws<Botan::Invalid_Argument>(

2✔

147

                  ".at() const out of range", [&] { const_cast<const decltype(bv)&>(bv).at(10); });

2✔

148

               result.template test_throws<Botan::Invalid_Argument>(".at() out of range", [&] { bv.at(10); });

3✔

149

               result.template test_throws<Botan::Invalid_Argument>(".set() out of range", [&] { bv.set(10); });

3✔

150

               result.template test_throws<Botan::Invalid_Argument>(".unset() out of range", [&] { bv.unset(10); });

3✔

151

               result.template test_throws<Botan::Invalid_Argument>(".flip() out of range", [&] { bv.flip(10); });

4✔

152

}),

1✔

155

            [](auto& result) {

1✔

156

               Botan::bitvector bv(128);

1✔

157

               result.test_eq("has more than 64 bits", bv.size(), 128);

2✔

158

               bv.set(1).set(63).set(64).set(127);

1✔

159

               for(size_t i = 0; i < bv.size(); ++i) {

129✔

160

                  const bool expected = (i == 1 || i == 63 || i == 64 || i == 127);

128✔

161

                  result.test_eq(Botan::fmt("bit {} in expected state", i), bv.at(i), expected);

256✔

163

}),

1✔

166

            [](auto& result) {

1✔

167

               Botan::bitvector bv(128);

1✔

168

               bv[0].set();

1✔

169

               bv[1] = true;

1✔

170

               bv[2].flip();

1✔

171

               bv[64] = true;

1✔

172

               bv[80] = true;

1✔

173

               result.confirm("bit 0", bv[0]);

2✔

174

               result.confirm("bit 1", bv[1]);

2✔

175

               result.confirm("bit 2", bv[2]);

2✔

176

               result.confirm("bit 3", !bv[3]);

2✔

177

               result.confirm("bit 64", bv[64]);

2✔

178

               result.confirm("bit 80", bv[80]);

2✔

179

}),

1✔

182

            [](auto& result) {

1✔

183

               Botan::bitvector bv(10);

1✔

184

               result.template test_throws<Botan::Invalid_Argument>(".at() out of range", [&] { bv.at(10); });

2✔

188

               result.test_no_throw("subscript out of range", [&] { bv[10]; });

3✔

189

}),

1✔

192

            [](auto& result) {

1✔

193

               Botan::bitvector bv(4);

1✔

195

               result.require("precondition", !bv[0] && !bv[1]);

2✔

196

               bv[0] &= 1;  // NOLINT(*-use-bool-literals)

1✔

197

               result.confirm("bv[0] still 0", !bv[0]);

2✔

198

               bv[0].set();

1✔

199

               bv[0] &= 1;  // NOLINT(*-use-bool-literals)

1✔

200

               result.confirm("bv[0] still 1", bv[0]);

2✔

201

               bv[0] &= false;

1✔

202

               result.confirm("bv[0] now 0 again", !bv[0]);

2✔

203

               bv[0] &= !bv[1];

1✔

204

               result.confirm("bv[0] still 0 once more", !bv[0]);

2✔

206

               result.require("precondition 2", !bv[1] && !bv[2]);

2✔

207

               bv[1] |= 1;  // NOLINT(modernize-use-bool-literals)

1✔

208

               result.confirm("bv[1] is now 1", bv[1]);

2✔

209

               bv[1] |= 0;  // NOLINT(modernize-use-bool-literals)

1✔

210

               result.confirm("bv[1] is still 1", bv[1]);

2✔

211

               bv[1].unset();

1✔

212

               bv[1] |= false;

1✔

213

               result.confirm("bv[1] is 0", !bv[1]);

2✔

214

               bv[1] |= !bv[2];

1✔

215

               result.confirm("bv[1] is 1 again", bv[1]);

2✔

217

               result.require("precondition 3", !bv[2] && !bv[3]);

2✔

218

               bv[2] ^= 0;  // NOLINT(modernize-use-bool-literals)

1✔

219

               result.confirm("bv[2] is still 0", !bv[2]);

2✔

220

               bv[2] ^= true;

1✔

221

               result.confirm("bv[2] is now 1", bv[2]);

2✔

222

               bv[2] ^= !bv[3];

1✔

223

               result.confirm("bv[2] is 0 again", !bv[2]);

2✔

224

}),

1✔

225

};

11✔

226

1✔

228

std::vector<Test::Result> test_bitvector_capacity(Botan::RandomNumberGenerator& /*rng*/) {

1✔

229

   return {

1✔

231

            [](auto& result) {

1✔

232

               const Botan::bitvector bv;

1✔

233

               result.confirm("empty", bv.empty());

2✔

234

               result.test_eq("no size", bv.size(), size_t(0));

2✔

235

               result.test_eq("no capacity", bv.capacity(), size_t(0));

2✔

236

}),

1✔

239

            [](auto& result) {

1✔

240

               const Botan::bitvector bv(1);

1✔

241

               result.confirm("empty", !bv.empty());

2✔

242

               result.test_eq("small size", bv.size(), size_t(1));

2✔

243

               result.test_gte("a little capacity", bv.capacity(), size_t(8));

2✔

244

}),

1✔

247

            [](auto& result) {

1✔

248

               Botan::bitvector bv;

1✔

249

               result.test_eq("no size", bv.size(), size_t(0));

2✔

250

               result.test_eq("no capacity", bv.capacity(), size_t(0));

2✔

252

               bv.reserve(64);

1✔

253

               result.test_eq("no size", bv.size(), size_t(0));

2✔

254

               result.test_gte("no capacity", bv.capacity(), size_t(64));

2✔

256

               bv.reserve(128);

1✔

257

               result.test_eq("no size", bv.size(), size_t(0));

2✔

258

               result.test_gte("no capacity", bv.capacity(), size_t(128));

2✔

259

}),

1✔

262

            [](Test::Result& result) {

1✔

263

               Botan::bitvector bv;

1✔

264

               result.confirm("empty", bv.empty());

2✔

265

               result.test_eq("no size", bv.size(), size_t(0));

1✔

267

               bv.push_back(true);

1✔

268

               bv.push_back(false);

1✔

269

               bv.push_back(true);

1✔

270

               bv.push_back(false);

1✔

272

               result.confirm("not empty", !bv.empty());

2✔

273

               result.test_eq("some size", bv.size(), size_t(4));

1✔

274

               result.test_gte("capacity is typically bigger than size", bv.capacity(), size_t(8));

1✔

276

               result.confirm("bit 0", bv.at(0));

2✔

277

               result.confirm("bit 1", !bv.at(1));

2✔

278

               result.confirm("bit 2", bv.at(2));

2✔

279

               result.confirm("bit 3", !bv.at(3));

2✔

281

               result.test_throws("bit 4 is not yet allocated", [&] { bv.at(4); });

4✔

282

}),

1✔

285

            [](Test::Result& result) {

1✔

286

               Botan::bitvector bv;

1✔

287

               bv.push_back(true);

1✔

288

               bv.push_back(false);

1✔

289

               bv.push_back(true);

1✔

290

               bv.push_back(false);

1✔

291

               result.confirm("last is false", !bv.back());

2✔

293

               bv.pop_back();

1✔

294

               result.test_eq("size() == 3", bv.size(), 3);

1✔

295

               result.confirm("last is true", bv.back());

2✔

297

               bv.pop_back();

1✔

298

               result.test_eq("size() == 2", bv.size(), 2);

1✔

299

               result.confirm("last is false", !bv.back());

2✔

301

               bv.pop_back();

1✔

302

               result.test_eq("size() == 1", bv.size(), 1);

1✔

303

               result.confirm("last is true", bv.back());

2✔

304

               result.confirm("first is true", bv.front());

2✔

306

               bv.pop_back();

1✔

307

               result.confirm("empty", bv.empty());

2✔

309

               result.test_throws("bit 4 is not yet allocated", [&] { bv.at(4); });

4✔

310

}),

1✔

313

            [](auto& result) {

1✔

314

               Botan::bitvector bv(10);

1✔

315

               bv[0] = true;

1✔

316

               bv[5] = true;

1✔

317

               bv[9] = true;

1✔

319

               bv.resize(8);

1✔

320

               result.test_eq("size is reduced", bv.size(), size_t(8));

1✔

322

               for(size_t i = 0; i < bv.size(); ++i) {

9✔

323

                  const bool expected = (i == 0 || i == 5);

8✔

324

                  result.test_eq(Botan::fmt("{} is as expected", i), bv[i], expected);

16✔

327

               bv.resize(0);

1✔

328

               result.confirm("resize(0) empties buffer", bv.empty());

2✔

330

               bv.resize(8);

1✔

331

               result.confirm("0 is false", !bv[0]);

2✔

332

               result.confirm("5 is false", !bv[5]);

2✔

333

}),

1✔

336

            [](Test::Result& result) {

1✔

337

               Botan::bitvector a(8);

1✔

338

               a.set(0).set(3);

1✔

339

               Botan::bitvector b(8);

1✔

340

               b.set(1).set(3);

1✔

341

               Botan::bitvector c(8);

1✔

342

               c.set(0).set(3);  // same is a

1✔

344

               result.confirm("equal bitvectors compare equal", a == c);

3✔

345

               result.confirm("different bitvectors do not compare equal", !(a == b));

3✔

346

               result.confirm("different bitvectors compare not equal", a != b);

3✔

347

               result.confirm("equal bitvectors do not compare not equal", !(a != c));

3✔

349

               auto or_ab = a | b;

1✔

350

               result.confirm("OR sets union bit 0", or_ab.at(0).is_set());

2✔

351

               result.confirm("OR sets union bit 1", or_ab.at(1).is_set());

2✔

352

               result.confirm("OR sets union bit 3", or_ab.at(3).is_set());

2✔

353

               result.confirm("OR leaves unset bit 2", !or_ab.at(2).is_set());

2✔

355

               auto and_ab = a & b;

1✔

356

               result.confirm("AND keeps common bit 3", and_ab.at(3).is_set());

2✔

357

               result.confirm("AND clears non-common bit 0", !and_ab.at(0).is_set());

2✔

358

               result.confirm("AND clears non-common bit 1", !and_ab.at(1).is_set());

2✔

360

               auto xor_ab = a ^ b;

1✔

361

               result.confirm("XOR sets differing bit 0", xor_ab.at(0).is_set());

2✔

362

               result.confirm("XOR sets differing bit 1", xor_ab.at(1).is_set());

2✔

363

               result.confirm("XOR clears common bit 3", !xor_ab.at(3).is_set());

2✔

364

}),

6✔

365

};

8✔

366

1✔

368

std::vector<Test::Result> test_bitvector_subvector(Botan::RandomNumberGenerator& /*rng*/) {

1✔

369

   auto make_bitpattern = [&]<typename T>(T& bitvector, size_t pattern_offset = 0) {

21✔

370

      auto next = pattern_generator<3>(pattern_offset);

20✔

373

         for(size_t i = 0; i < sizeof(T) * 8; ++i) {

316✔

374

            bitvector |= static_cast<T>(next()) << i;

304✔

377

         for(auto& i : bitvector) {

1,616✔

378

            i = next();

800✔

381

};

8✔

383

   auto bitpattern_at = [&]<std::unsigned_integral T>(T /* ignored */, size_t pattern_offset) -> T {

13✔

384

      T bitvector = 0;

12✔

385

      make_bitpattern(bitvector, pattern_offset);

24✔

387

};

1✔

389

   auto check_bitpattern = [&](auto& result, auto& bitvector, size_t offset = 0) {

44✔

391

      auto next = pattern_generator<3>(offset);

43✔

394

         for(size_t i = 0; i < sizeof(bv_t) * 8; ++i) {

496✔

395

            result.confirm(Botan::fmt("{} is as expected", i), (bitvector & (bv_t(1) << i)) != 0, next());

960✔

398

         for(size_t i = 0; i < bitvector.size(); ++i) {

2,056✔

399

            result.confirm(Botan::fmt("{} is as expected", i), bitvector[i], next());

4,058✔

402

};

43✔

404

   auto check_bitpattern_with_zero_region = [&](auto& result, auto& bitvector, std::pair<size_t, size_t> zero_region) {

13✔

405

      auto next = pattern_generator<3>();

12✔

406

      for(size_t i = 0; i < bitvector.size(); ++i) {

1,212✔

407

         const bool i_in_range = (zero_region.first <= i && i < zero_region.second);

1,200✔

408

         const bool expected = next();

1,200✔

409

         result.confirm(Botan::fmt("{} is as expected", i), bitvector[i], !i_in_range && expected);

2,400✔

411

};

12✔

413

   return {

1✔

415

            [&](auto& result) {

1✔

416

               const Botan::bitvector bv(100);

1✔

417

               result.template test_throws<Botan::Invalid_Argument>("out of range", [&] { bv.subvector(0, 101); });

3✔

418

               result.template test_throws<Botan::Invalid_Argument>("out of range", [&] { bv.subvector(90, 11); });

3✔

419

               result.template test_throws<Botan::Invalid_Argument>("out of range", [&] { bv.subvector(100, 1); });

3✔

420

               result.template test_throws<Botan::Invalid_Argument>("out of range", [&] { bv.subvector(101, 0); });

4✔

421

}),

1✔

424

            [&](auto& result) {

1✔

425

               const Botan::bitvector bv1(100);

1✔

426

               auto bv2 = bv1.subvector(0, 0);

1✔

427

               result.test_eq("empty at 0", bv2.size(), size_t(0));

1✔

428

               auto bv3 = bv1.subvector(10, 0);

1✔

429

               result.test_eq("empty at 10", bv3.size(), size_t(0));

1✔

430

               auto bv4 = bv1.subvector(100, 0);

1✔

431

               result.test_eq("empty at 100", bv3.size(), size_t(0));

2✔

432

}),

2✔

435

            [&](auto& result) {

1✔

436

               Botan::bitvector bv1(100);

1✔

437

               make_bitpattern(bv1);

1✔

439

               auto bv2 = bv1.subvector(16, 58);

1✔

440

               result.test_eq("size is as requested", bv2.size(), size_t(58));

1✔

441

               check_bitpattern(result, bv2, 16);

1✔

443

               auto bv3 = bv1.subvector(32);  // copy until the end

1✔

444

               result.test_eq("size is as expected", bv3.size(), size_t(68));

1✔

445

               check_bitpattern(result, bv3, 32);

1✔

446

}),

3✔

449

            [&](auto& result) {

1✔

450

               Botan::bitvector bv1(100);

1✔

451

               make_bitpattern(bv1);

1✔

453

               auto bv2 = bv1.subvector(8, 91);

1✔

454

               result.test_eq("size is as expected", bv2.size(), size_t(91));

1✔

455

               check_bitpattern(result, bv2, 8);

1✔

457

               auto bv3 = bv1.subvector(16, 58);

1✔

458

               result.test_eq("size is as requested", bv3.size(), size_t(58));

1✔

459

               check_bitpattern(result, bv3, 16);

1✔

461

               auto bv4 = bv1.subvector(24);  // copy until the end

1✔

462

               result.test_eq("size is as expected", bv4.size(), size_t(100 - 24));

1✔

463

               check_bitpattern(result, bv4, 24);

1✔

465

               auto bv5 = bv1.subvector(32);  // copy until the end

1✔

466

               result.test_eq("size is as expected", bv5.size(), size_t(100 - 32));

1✔

467

               check_bitpattern(result, bv5, 32);

1✔

469

               auto bv6 = bv1.subvector(48, 51);  // copy until the end

1✔

470

               result.test_eq("size is as expected", bv6.size(), size_t(51));

1✔

471

               check_bitpattern(result, bv6, 48);

1✔

472

}),

6✔

475

            [&](auto& result) {

1✔

476

               Botan::bitvector bv1(100);

1✔

477

               make_bitpattern(bv1);

1✔

479

               auto bv2 = bv1.subvector(16, 17);

1✔

480

               result.test_eq("size is as requested", bv2.size(), size_t(17));

1✔

481

               check_bitpattern(result, bv2, 16);

1✔

483

               bv2.resize(32);

1✔

484

               for(size_t i = 17; i < bv2.size(); ++i) {

16✔

485

                  result.confirm("tail is zero", !bv2[i]);

30✔

487

}),

2✔

490

            [&](auto& result) {

1✔

491

               Botan::bitvector bv1(100);

1✔

492

               make_bitpattern(bv1);

1✔

494

               auto bv2 = bv1.subvector(19, 69);

1✔

495

               result.test_eq("size is as requested", bv2.size(), size_t(69));

1✔

496

               check_bitpattern(result, bv2, 19);

1✔

498

               auto bv3 = bv1.subvector(21);  // copy until the end

1✔

499

               result.test_eq("size is as expected", bv3.size(), size_t(79));

1✔

500

               check_bitpattern(result, bv3, 21);

1✔

502

               auto bv4 = bv1.subvector(1, 16);

1✔

503

               result.test_eq("size is as expected", bv4.size(), size_t(16));

1✔

504

               check_bitpattern(result, bv4, 1);

1✔

506

               auto bv5 = bv1.subvector(1, 32);

1✔

507

               result.test_eq("size is as expected", bv5.size(), size_t(32));

1✔

508

               check_bitpattern(result, bv5, 1);

1✔

510

               auto bv6 = bv5.subvector(1, 12);

1✔

511

               result.test_eq("size is as expected", bv6.size(), size_t(12));

1✔

512

               check_bitpattern(result, bv6, 1 + 1);

1✔

514

               auto bv7 = bv1.subvector(17, 67);

1✔

515

               result.test_eq("size is as expected", bv7.size(), size_t(67));

1✔

516

               check_bitpattern(result, bv7, 17);

1✔

518

               auto bv8 = bv1.subvector(33);  // copy until the end

1✔

519

               result.test_eq("size is as expected", bv8.size(), size_t(67));

1✔

520

               check_bitpattern(result, bv8, 33);

1✔

521

}),

8✔

524

            [&](auto& result) {

1✔

525

               Botan::bitvector bv1(100);

1✔

526

               make_bitpattern(bv1);

1✔

528

               const auto u8_0 = bv1.subvector<uint8_t>(0);

1✔

529

               const auto u8_32 = bv1.subvector<uint8_t>(32);

1✔

530

               check_bitpattern(result, u8_0, 0);

1✔

531

               check_bitpattern(result, u8_32, 32);

1✔

533

               const auto u16_0 = bv1.subvector<uint16_t>(0);

1✔

534

               const auto u16_56 = bv1.subvector<uint16_t>(56);

1✔

535

               check_bitpattern(result, u16_0, 0);

1✔

536

               check_bitpattern(result, u16_56, 56);

1✔

538

               const auto u32_0 = bv1.subvector<uint32_t>(0);

1✔

539

               const auto u32_48 = bv1.subvector<uint32_t>(48);

1✔

540

               check_bitpattern(result, u32_0, 0);

1✔

541

               check_bitpattern(result, u32_48, 48);

1✔

543

               const auto u64_0 = bv1.subvector<uint64_t>(0);

1✔

544

               const auto u64_32 = bv1.subvector<uint64_t>(32);

1✔

545

               check_bitpattern(result, u64_0, 0);

1✔

546

               check_bitpattern(result, u64_32, 32);

1✔

548

               result.test_throws("out of range (uint8_t)", [&] { bv1.subvector<uint8_t>(93); });

3✔

549

               result.test_throws("out of range (uint16_t)", [&] { bv1.subvector<uint16_t>(85); });

3✔

550

               result.test_throws("out of range (uint32_t)", [&] { bv1.subvector<uint32_t>(69); });

3✔

551

               result.test_throws("out of range (uint64_t)", [&] { bv1.subvector<uint64_t>(37); });

4✔

552

}),

1✔

555

            [&](Test::Result& result) {

1✔

556

               Botan::bitvector bv1(100);

1✔

557

               make_bitpattern(bv1);

1✔

559

               const auto u8_3 = bv1.subvector<uint8_t>(3);

1✔

560

               const auto u8_92 = bv1.subvector<uint8_t>(92);

1✔

561

               check_bitpattern(result, u8_3, 3);

1✔

562

               check_bitpattern(result, u8_92, 92);

1✔

564

               const auto u16_7 = bv1.subvector<uint16_t>(7);

1✔

565

               const auto u16_84 = bv1.subvector<uint16_t>(84);

1✔

566

               check_bitpattern(result, u16_7, 7);

1✔

567

               check_bitpattern(result, u16_84, 84);

1✔

569

               const auto u32_11 = bv1.subvector<uint32_t>(11);

1✔

570

               const auto u32_68 = bv1.subvector<uint32_t>(68);

1✔

571

               check_bitpattern(result, u32_11, 11);

1✔

572

               check_bitpattern(result, u32_68, 68);

1✔

574

               const auto u64_21 = bv1.subvector<uint64_t>(21);

1✔

575

               const auto u64_36 = bv1.subvector<uint64_t>(36);

1✔

576

               check_bitpattern(result, u64_21, 21);

1✔

577

               check_bitpattern(result, u64_36, 36);

1✔

578

}),

1✔

581

            [&](auto& result) {

1✔

582

               Botan::bitvector bv1(100);

1✔

583

               make_bitpattern(bv1);

1✔

585

               bv1.subvector_replace(0, uint8_t(0));

1✔

586

               check_bitpattern_with_zero_region(result, bv1, {0, 8});

1✔

587

               bv1.subvector_replace(0, bitpattern_at(uint8_t(0), 0));

2✔

588

               check_bitpattern(result, bv1);

1✔

590

               bv1.subvector_replace(32, uint8_t(0));

1✔

591

               check_bitpattern_with_zero_region(result, bv1, {32, 32 + 8});

1✔

592

               bv1.subvector_replace(32, bitpattern_at(uint8_t(0), 32));

2✔

593

               check_bitpattern(result, bv1);

1✔

595

               bv1.subvector_replace(56, uint16_t(0));

1✔

596

               check_bitpattern_with_zero_region(result, bv1, {56, 56 + 16});

1✔

597

               bv1.subvector_replace(56, bitpattern_at(uint16_t(0), 56));

2✔

598

               check_bitpattern(result, bv1);

1✔

600

               bv1.subvector_replace(48, uint32_t(0));

1✔

601

               check_bitpattern_with_zero_region(result, bv1, {48, 48 + 32});

1✔

602

               bv1.subvector_replace(48, bitpattern_at(uint32_t(0), 48));

2✔

603

               check_bitpattern(result, bv1);

1✔

605

               bv1.subvector_replace(16, uint64_t(0));

1✔

606

               check_bitpattern_with_zero_region(result, bv1, {16, 16 + 64});

1✔

607

               bv1.subvector_replace(16, bitpattern_at(uint64_t(0), 16));

2✔

608

               check_bitpattern(result, bv1);

1✔

610

               result.test_throws("out of range (uint8_t)", [&] { bv1.subvector_replace<uint8_t>(93, 42); });

3✔

611

               result.test_throws("out of range (uint16_t)", [&] { bv1.subvector_replace<uint16_t>(85, 42); });

3✔

612

               result.test_throws("out of range (uint32_t)", [&] { bv1.subvector_replace<uint32_t>(69, 42); });

3✔

613

               result.test_throws("out of range (uint64_t)", [&] { bv1.subvector_replace<uint64_t>(37, 42); });

4✔

614

}),

1✔

617

            [&](auto& result) {

1✔

618

               Botan::bitvector bv1(100);

1✔

619

               make_bitpattern(bv1);

1✔

621

               bv1.subvector_replace(3, uint8_t(0));

1✔

622

               check_bitpattern_with_zero_region(result, bv1, {3, 3 + 8});

1✔

623

               bv1.subvector_replace(3, bitpattern_at(uint8_t(0), 3));

2✔

624

               check_bitpattern(result, bv1);

1✔

626

               bv1.subvector_replace(92, uint8_t(0));

1✔

627

               check_bitpattern_with_zero_region(result, bv1, {92, 92 + 8});

1✔

628

               bv1.subvector_replace(92, bitpattern_at(uint8_t(0), 92));

2✔

629

               check_bitpattern(result, bv1);

1✔

631

               bv1.subvector_replace(7, uint16_t(0));

1✔

632

               check_bitpattern_with_zero_region(result, bv1, {7, 7 + 16});

1✔

633

               bv1.subvector_replace(7, bitpattern_at(uint16_t(0), 7));

2✔

634

               check_bitpattern(result, bv1);

1✔

636

               bv1.subvector_replace(84, uint16_t(0));

1✔

637

               check_bitpattern_with_zero_region(result, bv1, {84, 84 + 16});

1✔

638

               bv1.subvector_replace(84, bitpattern_at(uint16_t(0), 84));

2✔

639

               check_bitpattern(result, bv1);

1✔

641

               bv1.subvector_replace(11, uint32_t(0));

1✔

642

               check_bitpattern_with_zero_region(result, bv1, {11, 11 + 32});

1✔

643

               bv1.subvector_replace(11, bitpattern_at(uint32_t(0), 11));

2✔

644

               check_bitpattern(result, bv1);

1✔

646

               bv1.subvector_replace(68, uint32_t(0));

1✔

647

               check_bitpattern_with_zero_region(result, bv1, {68, 68 + 32});

1✔

648

               bv1.subvector_replace(68, bitpattern_at(uint32_t(0), 68));

2✔

649

               check_bitpattern(result, bv1);

1✔

651

               bv1.subvector_replace(21, uint64_t(0));

1✔

652

               check_bitpattern_with_zero_region(result, bv1, {21, 21 + 64});

1✔

653

               bv1.subvector_replace(21, bitpattern_at(uint64_t(0), 21));

2✔

654

               check_bitpattern(result, bv1);

1✔

655

}),

1✔

656

};

11✔

657

1✔

659

std::vector<Test::Result> test_bitvector_global_modifiers_and_predicates(Botan::RandomNumberGenerator& /*rng*/) {

1✔

660

   auto make_bitpattern = [](auto& bitvector) {

3✔

661

      auto next = pattern_generator<5>();

2✔

662

      for(auto& i : bitvector) {

400✔

663

         i = next();

198✔

665

};

2✔

667

   auto check_bitpattern = [](auto& result, auto& bitvector) {

2✔

668

      auto next = pattern_generator<5>();

1✔

669

      for(size_t i = 0; i < bitvector.size(); ++i) {

100✔

670

         result.confirm(Botan::fmt("{} is as expected", i), bitvector[i], next());

198✔

672

};

1✔

674

   auto check_flipped_bitpattern = [](auto& result, auto& bitvector) {

2✔

675

      auto next = pattern_generator<5>();

1✔

676

      for(size_t i = 0; i < bitvector.size(); ++i) {

100✔

677

         result.confirm(Botan::fmt("{} is as expected", i), bitvector[i], !next());

198✔

679

};

1✔

681

   return {

1✔

683

            [](auto& result) {

1✔

684

               Botan::bitvector bv;

1✔

685

               bv.push_back(true);

1✔

687

               bv.flip();

1✔

688

               result.confirm("bit is flipped", !bv[0]);

2✔

691

               bv.resize(8);

1✔

692

               for(auto&& b : bv) {

9✔

693

                  result.confirm("all bits are false", !b);

16✔

695

               bv.resize(1);

1✔

697

               bv.flip();

1✔

698

               result.confirm("bit is flipped again", bv[0]);

2✔

699

}),

1✔

702

            [&](auto& result) {

1✔

703

               Botan::bitvector bv(99);

1✔

705

               make_bitpattern(bv);

1✔

706

               bv.flip();

1✔

707

               check_flipped_bitpattern(result, bv);

1✔

709

               bv = ~bv;

2✔

710

               check_bitpattern(result, bv);

1✔

712

               bv.resize(112);

1✔

713

               for(size_t i = 99; i < bv.size(); ++i) {

14✔

714

                  result.confirm("just-allocated bit is not set", !bv[i]);

26✔

716

}),

1✔

719

            [&](auto& result) {

1✔

720

               Botan::bitvector bv(99);

1✔

722

               make_bitpattern(bv);

1✔

723

               bv.set();

1✔

724

               bv.resize(128);

1✔

725

               for(size_t i = 0; i < bv.size(); ++i) {

129✔

726

                  const bool expected = (i < 99);

128✔

727

                  result.test_eq("only set bits are set", bv[i], expected);

256✔

730

               bv.unset();

1✔

731

               for(auto&& b : bv) {

130✔

732

                  result.confirm("bit is not set", !b);

256✔

734

}),

1✔

737

            [&](auto& result) {

1✔

738

               Botan::bitvector bv(99);

1✔

740

               result.confirm("default construction yields all-zero", bv.none_vartime());

2✔

741

               result.confirm("default construction yields all-zero 2", !bv.any_vartime());

2✔

742

               result.confirm("default construction yields all-zero 3", !bv.all_vartime());

2✔

743

               result.confirm("default construction yields all-zero 4", bv.none());

2✔

744

               result.confirm("default construction yields all-zero 5", !bv.any());

2✔

745

               result.confirm("default construction yields all-zero 6", !bv.all());

2✔

747

               bv.set(42);

1✔

748

               result.confirm("setting a bit means there's a bit set", !bv.none_vartime());

2✔

749

               result.confirm("setting a bit means there's a bit set 2", bv.any_vartime());

2✔

750

               result.confirm("setting a bit means there's not all bits set", !bv.all_vartime());

2✔

751

               result.confirm("setting a bit means there's a bit set 3", !bv.none());

2✔

752

               result.confirm("setting a bit means there's a bit set 4", bv.any());

2✔

753

               result.confirm("setting a bit means there's not all bits set 2", !bv.all());

2✔

755

               bv.set();

1✔

756

               result.confirm("setting all bits means there's a bit set", !bv.none_vartime());

2✔

757

               result.confirm("setting all bits means there's a bit set 2", bv.any_vartime());

2✔

758

               result.confirm("setting all bits means all bits are set", bv.all_vartime());

2✔

759

               result.confirm("setting all bits means there's a bit set 3", !bv.none());

2✔

760

               result.confirm("setting all bits means there's a bit set 4", bv.any());

2✔

761

               result.confirm("setting all bits means all bits are set 2", bv.all());

2✔

763

               bv.unset(97);

1✔

764

               result.confirm("a single 0 at the end means that there's a bit set", !bv.none_vartime());

2✔

765

               result.confirm("a single 0 at the end means that there are bits set", bv.any_vartime());

2✔

766

               result.confirm("a single 0 at the end means that there are not all bits set", !bv.all_vartime());

2✔

767

               result.confirm("a single 0 at the end means that there's a bit set 2", !bv.none());

2✔

768

               result.confirm("a single 0 at the end means that there are bits set 2", bv.any());

2✔

769

               result.confirm("a single 0 at the end means that there are not all bits set 2", !bv.all());

2✔

771

               bv.unset();

1✔

772

               result.confirm("unsetting all bits means there's no bit set", bv.none_vartime());

2✔

773

               result.confirm("unsetting all bits means there's no bit set 2", !bv.any_vartime());

2✔

774

               result.confirm("unsetting all bits means there's not all bits set", !bv.all_vartime());

2✔

775

               result.confirm("unsetting all bits means there's no bit set 3", bv.none());

2✔

776

               result.confirm("unsetting all bits means there's no bit set 4", !bv.any());

2✔

777

               result.confirm("unsetting all bits means there's not all bits set 2", !bv.all());

2✔

778

}),

1✔

781

            [](auto& result) {

1✔

782

               const auto even = Botan::hex_decode("FE3410CB0278E4D26602");

1✔

783

               const auto odd = Botan::hex_decode("BB2418C2B4F288921203");

1✔

785

               result.confirm("odd hamming", Botan::bitvector(odd).has_odd_hamming_weight().as_bool());

3✔

786

               result.confirm("even hamming", !Botan::bitvector(even).has_odd_hamming_weight().as_bool());

3✔

787

}),

2✔

790

            [](auto& result) {

1✔

791

               auto naive_count = [](const auto& v) {

5✔

792

                  size_t weight = 0;

5✔

793

                  for(const auto& bit : v) {

440✔

794

                     weight += bit.template as<size_t>();

430✔

796

                  return weight;

5✔

800

               auto bv = Botan::bitvector(Botan::hex_decode("FE3410CB0278E4D26602E0"));

2✔

801

               result.test_eq("hamming weight", bv.hamming_weight(), size_t(37));

1✔

802

               result.test_eq("hamming weight", bv.hamming_weight(), naive_count(bv));

2✔

804

               bv.pop_back();

1✔

805

               result.test_eq("hamming weight", bv.hamming_weight(), size_t(36));

1✔

806

               result.test_eq("hamming weight", bv.hamming_weight(), naive_count(bv));

2✔

808

               bv.pop_back();

1✔

809

               result.test_eq("hamming weight", bv.hamming_weight(), size_t(35));

1✔

810

               result.test_eq("hamming weight", bv.hamming_weight(), naive_count(bv));

2✔

812

               bv.pop_back();

1✔

813

               result.test_eq("hamming weight", bv.hamming_weight(), size_t(34));

1✔

814

               result.test_eq("hamming weight", bv.hamming_weight(), naive_count(bv));

2✔

816

               bv.pop_back();

1✔

817

               result.test_eq("hamming weight", bv.hamming_weight(), size_t(34));

1✔

818

               result.test_eq("hamming weight", bv.hamming_weight(), naive_count(bv));

2✔

819

}),

1✔

820

};

7✔

821

1✔

823

std::vector<Test::Result> test_bitvector_binary_operators(Botan::RandomNumberGenerator& /*rng*/) {

1✔

824

   auto check_set = [](auto& result, auto bits, std::vector<size_t> set_bits) {

13✔

825

      for(size_t i = 0; i < bits.size(); ++i) {

252✔

826

         const auto should_be_set = std::find(set_bits.begin(), set_bits.end(), i) != set_bits.end();

240✔

827

         result.test_eq(Botan::fmt("{} should {}be set", i, (!should_be_set ? "not " : "")), bits[i], should_be_set);

661✔

829

};

12✔

831

   auto is_secure_allocator = []<template <typename> typename AllocatorT>(auto& result,

7✔

833

      result.confirm("allocator is Botan::secure_allocator<>",

12✔

835

};

6✔

837

   auto is_standard_allocator = []<template <typename> typename AllocatorT>(auto& result,

4✔

839

      result.confirm("allocator is std::allocator<>", std::same_as<std::allocator<uint8_t>, AllocatorT<uint8_t>>);

6✔

840

};

3✔

842

   return {

1✔

844

            [&](auto& result) {

1✔

845

               Botan::bitvector lhs(20);

1✔

846

               lhs.set(0).set(4).set(15).set(16).set(19);

1✔

847

               Botan::bitvector rhs(20);

1✔

848

               rhs.set(1).set(4).set(16).set(17).set(18);

1✔

850

               result.test_eq("Not equal bitvectors", lhs.equals_vartime(rhs), false);

1✔

851

               result.test_eq("Not equal bitvectors 2", lhs.equals(rhs), false);

2✔

853

               lhs.unset().set(13);

1✔

854

               rhs.unset().set(13);

1✔

856

               result.test_eq("equal bitvectors", lhs.equals_vartime(rhs), true);

1✔

857

               result.test_eq("equal bitvectors 2", lhs.equals(rhs), true);

2✔

858

}),

2✔

861

            [&](auto& result) {

1✔

862

               Botan::bitvector lhs(20);

1✔

863

               lhs.set(0).set(4).set(15).set(16).set(19);

1✔

864

               Botan::bitvector rhs(20);

1✔

865

               rhs.set(1).set(4).set(16).set(17).set(18);

1✔

866

               Botan::bitvector unary(20);

1✔

867

               unary.set(8);

1✔

869

               Botan::bitvector res = lhs | rhs;

1✔

870

               check_set(result, res, {0, 1, 4, 15, 16, 17, 18, 19});

4✔

872

               res |= unary;

1✔

873

               check_set(result, res, {0, 1, 4, 8, 15, 16, 17, 18, 19});

3✔

875

               is_standard_allocator(result, res);

1✔

876

}),

4✔

879

            [&](auto& result) {

1✔

880

               Botan::bitvector lhs(20);

1✔

881

               lhs.set(0).set(4).set(15).set(16).set(18);

1✔

882

               Botan::bitvector rhs(20);

1✔

883

               rhs.set(1).set(4).set(16).set(17).set(18);

1✔

884

               Botan::bitvector unary(20);

1✔

885

               unary.set(8).set(16);

1✔

887

               Botan::bitvector res = lhs & rhs;

1✔

888

               check_set(result, res, {4, 16, 18});

4✔

890

               res &= unary;

1✔

891

               check_set(result, res, {16});

3✔

893

               is_standard_allocator(result, res);

1✔

894

}),

4✔

897

            [&](auto& result) {

1✔

898

               Botan::bitvector lhs(20);

1✔

899

               lhs.set(0).set(4).set(15).set(16).set(18);

1✔

900

               Botan::bitvector rhs(20);

1✔

901

               rhs.set(1).set(4).set(16).set(17).set(18);

1✔

902

               Botan::bitvector unary(20);

1✔

903

               unary.set(8).set(16);

1✔

905

               Botan::bitvector res = lhs ^ rhs;

1✔

906

               check_set(result, res, {0, 1, 15, 17});

4✔

908

               res ^= unary;

1✔

909

               check_set(result, res, {0, 1, 8, 15, 16, 17});

3✔

911

               is_standard_allocator(result, res);

1✔

912

}),

4✔

915

            [&](auto& result) {

1✔

916

               Botan::bitvector lhs(20);

1✔

917

               lhs.set(0).set(4).set(15).set(16).set(18);

1✔

918

               Botan::secure_bitvector rhs(20);

1✔

919

               rhs.set(1).set(4).set(16).set(17).set(18);

1✔

920

               Botan::bitvector unary(20);

1✔

921

               unary.set(8).set(16);

1✔

923

               auto res1 = lhs | rhs;

1✔

924

               is_secure_allocator(result, res1);

1✔

925

               check_set(result, res1, {0, 1, 4, 15, 16, 17, 18, 20});

3✔

927

               auto res2 = rhs | lhs;

1✔

928

               is_secure_allocator(result, res2);

1✔

929

               check_set(result, res2, {0, 1, 4, 15, 16, 17, 18, 20});

3✔

931

               auto res3 = lhs & rhs;

1✔

932

               is_secure_allocator(result, res3);

1✔

933

               check_set(result, res3, {4, 16, 18});

3✔

935

               auto res4 = rhs & lhs;

1✔

936

               is_secure_allocator(result, res4);

1✔

937

               check_set(result, res4, {4, 16, 18});

3✔

939

               auto res5 = lhs ^ rhs;

1✔

940

               is_secure_allocator(result, res5);

1✔

941

               check_set(result, res5, {0, 1, 15, 17});

3✔

943

               auto res6 = rhs ^ lhs;

1✔

944

               is_secure_allocator(result, res6);

1✔

945

               check_set(result, res6, {0, 1, 15, 17});

4✔

946

}),

8✔

947

};

6✔

948

1✔

950

std::vector<Test::Result> test_bitvector_serialization(Botan::RandomNumberGenerator& /*rng*/) {

1✔

951

   constexpr uint8_t outlen = 64;

1✔

952

   const auto bytearray = [] {

1✔

960

   auto validate_bytewise = [](auto& result, const auto& bv, std::span<const uint8_t> bytes) {

3✔

961

      for(size_t i = 0; i < bytes.size(); ++i) {

129✔

962

         const uint8_t b = (static_cast<uint8_t>(bv[0 + i * 8]) << 0) | (static_cast<uint8_t>(bv[1 + i * 8]) << 1) |

127✔

963

                           (static_cast<uint8_t>(bv[2 + i * 8]) << 2) | (static_cast<uint8_t>(bv[3 + i * 8]) << 3) |

127✔

964

                           (static_cast<uint8_t>(bv[4 + i * 8]) << 4) | (static_cast<uint8_t>(bv[5 + i * 8]) << 5) |

127✔

965

                           (static_cast<uint8_t>(bv[6 + i * 8]) << 6) | (static_cast<uint8_t>(bv[7 + i * 8]) << 7);

127✔

967

         result.test_eq(Botan::fmt("byte {} is as expected", i), static_cast<size_t>(b), static_cast<size_t>(bytes[i]));

254✔

969

};

2✔

971

   return {

1✔

973

            [](auto& result) {

1✔

974

               std::vector<uint8_t> bytes;

1✔

975

               result.require("empty buffer", bytes.empty());

2✔

977

               const Botan::bitvector bv(bytes);

1✔

978

               result.confirm("empty bit vector", bv.empty());

2✔

980

               auto rendered = bv.to_bytes();

1✔

981

               result.confirm("empty bit vector renders an empty buffer", rendered.empty());

2✔

982

}),

1✔

985

            [](auto& result) {

1✔

986

               const Botan::bitvector bv;

1✔

987

               const Botan::secure_bitvector sbv;

1✔

989

               auto rbv = bv.to_bytes();

1✔

990

               auto rsbv = sbv.to_bytes();

1✔

992

               result.confirm("ordinary bitvector uses ordinary std::vector",

2✔

994

               result.confirm("secure bitvector uses secure_vector",

2✔

996

}),

1✔

999

            [&](auto& result) {

1✔

1000

               const Botan::bitvector bv(bytearray);

1✔

1001

               validate_bytewise(result, bv, bytearray);

1✔

1003

               const auto rbv = bv.to_bytes();

1✔

1004

               result.confirm("uint8_t rendered correctly", std::ranges::equal(bytearray, rbv));

3✔

1005

}),

2✔

1008

            [&](auto& result) {

1✔

1009

               std::array<uint8_t, 63> unaligned_bytearray{};

1✔

1010

               Botan::copy_mem(unaligned_bytearray, std::span{bytearray}.first<unaligned_bytearray.size()>());

1✔

1012

               const Botan::bitvector bv(unaligned_bytearray);

1✔

1013

               validate_bytewise(result, bv, unaligned_bytearray);

1✔

1015

               const auto rbv = bv.to_bytes();

1✔

1016

               result.confirm("uint8_t rendered correctly", std::ranges::equal(unaligned_bytearray, rbv));

2✔

1017

}),

3✔

1020

            [&](auto& result) {

1✔

1021

               constexpr size_t bits_to_load = 31;

1✔

1022

               constexpr size_t bytes_to_load = Botan::ceil_tobytes(bits_to_load);

1✔

1024

               Botan::bitvector bv(bytearray, bits_to_load);

1✔

1026

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

32✔

1027

                  const bool expected = (i == 8) || (i == 17) || (i == 24) || (i == 25);

31✔

1028

                  result.test_eq(Botan::fmt("bit {} is correct", i), bv.at(i), expected);

62✔

1031

               const auto rbv = bv.to_bytes();

1✔

1032

               std::array<uint8_t, bytes_to_load> expected_bytes{};

1✔

1033

               Botan::copy_mem(expected_bytes, std::span{bytearray}.first<bytes_to_load>());

1✔

1034

               expected_bytes.back() &= (uint8_t(1) << (bits_to_load % 8)) - 1;

1✔

1035

               result.confirm("uint8_t rendered correctly", std::ranges::equal(expected_bytes, rbv));

2✔

1036

}),

2✔

1039

            [&](auto& result) {

1✔

1040

               constexpr size_t bits_to_load = 33;

1✔

1041

               constexpr size_t bytes_to_load = Botan::ceil_tobytes(bits_to_load);

1✔

1043

               Botan::bitvector bv(bytearray, bits_to_load);

1✔

1044

               bv.set(32);

1✔

1046

               std::array<uint8_t, bytes_to_load> out = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF};

1✔

1047

               bv.to_bytes(out);

1✔

1049

               result.test_eq_sz("uint8_t rendered correctly", out[4], 0x01);

2✔

1050

}),

1✔

1051

};

7✔

1052

1✔

1054

std::vector<Test::Result> test_bitvector_constant_time_operations(Botan::RandomNumberGenerator& /*rng*/) {

1✔

1055

   constexpr Botan::CT::Choice yes = Botan::CT::Choice::yes();

1✔

1056

   constexpr Botan::CT::Choice no = Botan::CT::Choice::no();

1✔

1058

   return {

1✔

1060

            [&](auto& result) {

1✔

1061

               Botan::bitvector bv1(Botan::hex_decode("BAADF00DCAFEBEEF"));

2✔

1062

               const Botan::secure_bitvector bv2(Botan::hex_decode("CAFEBEEFC001B33F"));

2✔

1063

               const auto initial_bv1 = bv1;

1✔

1064

               const auto xor_result = bv1 ^ bv2;

1✔

1066

               bv1.ct_conditional_xor(no, bv2);

1✔

1067

               result.confirm("no change after false condition", bv1 == initial_bv1);

2✔

1069

               bv1.ct_conditional_xor(yes, bv2);

1✔

1070

               result.confirm("XORed if condition was true", bv1 == xor_result);

2✔

1071

}),

4✔

1074

            [&](auto& result) {

1✔

1075

               Botan::bitvector bv1(Botan::hex_decode("BAADF00DCAFEBEEF42"));

2✔

1076

               const Botan::secure_bitvector bv2(Botan::hex_decode("CAFEBEEFC001B33F13"));

2✔

1077

               const auto initial_bv1 = bv1;

1✔

1078

               const auto xor_result = bv1 ^ bv2;

1✔

1080

               bv1.ct_conditional_xor(no, bv2);

1✔

1081

               result.confirm("no change after false condition", bv1 == initial_bv1);

2✔

1083

               bv1.ct_conditional_xor(yes, bv2);

1✔

1084

               result.confirm("XORed if condition was true", bv1 == xor_result);

2✔

1085

}),

4✔

1088

            [&](auto& result) {

1✔

1089

               Botan::bitvector bv1(Botan::hex_decode("BAADF00DCAFEBEEF42"));

1✔

1090

               bv1.push_back(true);

1✔

1091

               bv1.push_back(false);

1✔

1092

               Botan::secure_bitvector bv2(Botan::hex_decode("CAFEBEEFC001B33F13"));

1✔

1093

               bv2.push_back(false);

1✔

1094

               bv2.push_back(false);

1✔

1096

               const auto initial_bv1 = bv1;

1✔

1097

               const auto xor_result = bv1 ^ bv2;

1✔

1099

               bv1.ct_conditional_xor(no, bv2);

1✔

1100

               result.confirm("no change after false condition", bv1 == initial_bv1);

2✔

1102

               bv1.ct_conditional_xor(yes, bv2);

1✔

1103

               result.confirm("XORed if condition was true", bv1 == xor_result);

2✔

1104

}),

4✔

1105

};

4✔

1106

1✔

1108

std::vector<Test::Result> test_bitvector_conditional_xor_workload(Botan::RandomNumberGenerator& /*rng*/) {

1✔

1109

   Test::Result res("Conditional XOR, Gauss Workload");

1✔

1111

   auto rng = Test::new_rng("Conditional XOR, Gauss Workload");

1✔

1113

   const size_t matrix_rows = 1664;

1✔

1114

   const size_t matrix_columns = 8192;

1✔

1116

   std::vector<Botan::bitvector> bitvec_vec;

1✔

1117

   bitvec_vec.reserve(matrix_rows);

1✔

1118

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

1,665✔

1119

      bitvec_vec.push_back(Botan::bitvector(rng->random_vec(matrix_columns / 8)));

4,992✔

1123

   const size_t total_iter = matrix_rows * (3 * matrix_rows - 1) / 2;

1✔

1124

   const auto start = Test::timestamp();

1✔

1125

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

4,152,513✔

1126

      const auto choice = Botan::CT::Choice::from_int(static_cast<uint8_t>(rng->next_byte() % 2));

4,152,512✔

1127

      bitvec_vec.at(i % matrix_rows).ct_conditional_xor(choice, bitvec_vec.at(rng->next_byte() % matrix_rows));

4,152,512✔

1129

   res.set_ns_consumed(Test::timestamp() - start);

1✔

1131

   res.confirm("Prevent compiler from optimizing away",

3✔

1132

               bitvec_vec.at(0).any_vartime() || bitvec_vec.at(0).none_vartime());

1✔

1133

   return {res};

3✔

1134

3✔

1136

std::vector<Test::Result> test_bitvector_iterators(Botan::RandomNumberGenerator& /*rng*/) {

1✔

1137

   return {

1✔

1139

            [](auto& result) {

1✔

1140

               Botan::bitvector bv(6);

1✔

1141

               bv.set(0).set(3).set(4);

1✔

1143

               for(size_t i = 0; auto& ref : bv) {

8✔

1144

                  const bool expected = i == 0 || i == 3 || i == 4;

6✔

1145

                  result.test_eq(Botan::fmt("bit {} is as expected", i), ref, expected);

6✔

1146

                  ++i;

6✔

1149

               for(size_t i = 0; const auto& ref : bv) {

8✔

1150

                  const bool expected = i == 0 || i == 3 || i == 4;

6✔

1151

                  result.test_eq(Botan::fmt("const bit {} is as expected", i), ref, expected);

6✔

1152

                  ++i;

6✔

1155

               for(auto ref : bv) {

14✔

1156

                  ref = true;

6✔

1159

               result.confirm("all bits are set", bv.all_vartime());

2✔

1160

}),

1✔

1163

            [](auto& result) {

1✔

1164

               Botan::bitvector bv(6);

1✔

1165

               bv.set(0).set(3).set(4);

1✔

1167

               size_t i = 0;

1✔

1168

               for(auto itr = bv.begin(); itr != bv.end(); ++itr, ++i) {

7✔

1169

                  const bool expected = i == 0 || i == 3 || i == 4;

6✔

1170

                  result.test_eq(Botan::fmt("bit {} is as expected", i), *itr, expected);

12✔

1173

               i = 0;

1✔

1174

               for(auto itr = bv.cbegin(); itr != bv.cend(); itr++, ++i) {

7✔

1175

                  const bool expected = i == 0 || i == 3 || i == 4;

6✔

1176

                  result.test_eq(Botan::fmt("const bit {} is as expected", i), itr->is_set(), expected);

12✔

1179

               i = 6;

1✔

1180

               auto ritr = bv.end();

1✔

1183

                  --ritr;

6✔

1184

                  --i;

6✔

1185

                  const bool expected = i == 0 || i == 3 || i == 4;

6✔

1186

                  result.test_eq(Botan::fmt("reverse bit {} is as expected", i), *ritr, expected);

6✔

1187

               } while(ritr != bv.begin());

11✔

1189

               for(auto& itr : bv) {

8✔

1190

                  itr.flip();

6✔

1193

               i = 0;

1✔

1194

               for(auto itr = bv.begin(); itr != bv.end(); ++itr, ++i) {

7✔

1195

                  const bool expected = i == 1 || i == 2 || i == 5;

6✔

1196

                  result.test_eq(Botan::fmt("flipped bit {} is as expected", i), *itr, expected);

12✔

1198

}),

1✔

1201

            [](auto& result) {

1✔

1202

               Botan::bitvector bv(6);

1✔

1205

               result.test_is_eq("distance", std::distance(bv.begin(), bv.end()), signed_size_t(6));

2✔

1206

               result.test_is_eq("const distance", std::distance(bv.cbegin(), bv.cend()), signed_size_t(6));

3✔

1208

               auto b = bv.begin();

1✔

1209

               std::advance(b, 3);

1✔

1210

               result.test_is_eq("half distance", std::distance(bv.begin(), b), signed_size_t(3));

3✔

1211

}),

1✔

1214

            [](auto& result) {

1✔

1215

               Botan::bitvector bv(500);

1✔

1217

               for(auto itr = bv.begin(); itr != bv.end(); ++itr) {

1,001✔

1218

                  if(std::distance(bv.begin(), itr) % 2 == 0) {

1,000✔

1219

                     itr->set();

250✔

1221

                  if(std::distance(bv.begin(), itr) % 3 == 0) {

1,000✔

1222

                     *itr = true;

167✔

1226

               for(size_t i = 0; const auto& bit : bv) {

502✔

1227

                  const bool expected = (i % 2 == 0) || (i % 3 == 0);

500✔

1228

                  result.test_eq(Botan::fmt("bit {} is as expected", i), bit, expected);

500✔

1229

                  ++i;

500✔

1231

}),

1✔

1234

            [](auto& result) {

1✔

1235

               Botan::secure_bitvector bv(42);

1✔

1236

               auto ro_itr = bv.cbegin();

1✔

1237

               auto rw_itr = bv.begin();

1✔

1242

               result.confirm("ro input iterator", std::input_iterator<ro>);

2✔

1243

               result.confirm("rw input iterator", std::input_iterator<rw>);

2✔

1244

               result.confirm("ro is not an output iterator", !std::output_iterator<ro, bool>);

2✔

1245

               result.confirm("rw output iterator", std::output_iterator<rw, bool>);

2✔

1246

               result.confirm("ro bidirectional iterator", std::bidirectional_iterator<ro>);

2✔

1247

               result.confirm("rw bidirectional iterator", std::bidirectional_iterator<rw>);

2✔

1248

               result.confirm("ro not a contiguous iterator", !std::contiguous_iterator<ro>);

2✔

1249

               result.confirm("rw not a contiguous iterator", !std::contiguous_iterator<rw>);

2✔

1250

}),

1✔

1251

};

6✔

1252

1✔

1258

std::vector<Test::Result> test_bitvector_strongtype_adapter(Botan::RandomNumberGenerator& /*rng*/) {

1✔

1259

   Test::Result result("Bitvector in strong type");

1✔

1261

   TestBitvector bv1(33);

1✔

1263

   result.confirm("bv1 is not empty", !bv1.empty());

2✔

1264

   result.test_eq("bv1 has size 33", bv1.size(), size_t(33));

1✔

1266

   bv1[0] = true;

1✔

1267

   bv1.at(1) = true;

1✔

1268

   bv1.set(2);

2✔

1269

   bv1.unset(3);

2✔

1270

   bv1.flip(4);

2✔

1271

   bv1.push_back(true);

1✔

1272

   bv1.push_back(false);

1✔

1273

   bv1.pop_back();

1✔

1275

   result.confirm("bv1 front is set", bv1.front());

2✔

1276

   result.confirm("bv1 back is set", bv1.back());

2✔

1277

   result.confirm("bv1 has some one bits", bv1.any_vartime());

2✔

1278

   result.confirm("bv1 is not all zero", !bv1.none_vartime());

2✔

1279

   result.confirm("bv1 is not all one", !bv1.all_vartime());

2✔

1281

   result.confirm("hamming weight of bv1", bv1.has_odd_hamming_weight().as_bool());

2✔

1283

   for(size_t i = 0; auto bit : bv1) {

36✔

1284

      const bool expected = (i == 0 || i == 1 || i == 2 || i == 4 || i == 33);

34✔

1285

      result.confirm(Botan::fmt("bv1 bit {} is set", i), bit == expected);

68✔

1286

      ++i;

34✔

1289

   bv1.flip();

2✔

1291

   for(size_t i = 0; auto bit : bv1) {

36✔

1292

      const bool expected = (i == 0 || i == 1 || i == 2 || i == 4 || i == 33);

34✔

1293

      result.confirm(Botan::fmt("bv1 bit {} is set", i), bit != expected);

68✔

1294

      ++i;

34✔

1297

   auto bv2 = bv1.as<TestSecureBitvector>();

1✔

1299

   auto bv3 = bv1 | bv2;

1✔

1300

   result.confirm("bv3 is a secure_bitvector", std::same_as<Botan::secure_bitvector, decltype(bv3)>);

2✔

1302

   auto bv4 = bv2.subvector<TestSecureBitvector>(0, 5);

1✔

1303

   result.confirm("bv4 is a TestSecureBitvector", std::same_as<TestSecureBitvector, decltype(bv4)>);

2✔

1305

   auto bv5 = bv2.subvector<TestUInt32>(1);

1✔

1306

   result.confirm("bv5 is a TestUInt32", std::same_as<TestUInt32, decltype(bv5)>);

2✔

1307

   result.test_is_eq<TestUInt32::wrapped_type>("bv5 has expected value", bv5.get(), 0xFFFFFFF4);

1✔

1309

   const auto str = bv4.to_string();

1✔

1310

   result.test_eq("bv4 to_string", str, "00010");

2✔

1312

   return {result};

3✔

1313

6✔

1317

class BitVector_Tests final : public Test {

1✔

1319

      std::vector<Test::Result> run() override {

1✔

1320

         std::vector<Test::Result> results;

1✔

1321

         auto& rng = Test::rng();

1✔

1323

         const std::vector<std::function<std::vector<Test::Result>(Botan::RandomNumberGenerator&)>> funcs{

1✔

1334

};

11✔

1336

         for(const auto& test_func : funcs) {

11✔

1337

            auto fn_results = test_func(rng);

10✔

1338

            results.insert(results.end(), fn_results.begin(), fn_results.end());

10✔

1339

10✔

1341

         return results;

1✔

1342

2✔

randombit / botan / 21959119344

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

randombit / botan / 21959119344

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