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

26

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

110 ✔

27

   if(min == max) {

110 ✔

31

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

110 ✔

32

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

110 ✔

36

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

3 ✔

37

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

6 ✔

39

      if(v.size() < 2) {

3 ✔

42

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

107 ✔

43

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

104 ✔

44

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

104 ✔

46

};

3 ✔

48

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

3 ✔

49

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

3 ✔

50

   shuffle(indices);

3 ✔

51

   indices.resize(n);

3 ✔

52

   return indices;

3 ✔

56

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

3 ✔

57

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

3 ✔

58

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

3 ✔

59

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

3 ✔

61

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

6 ✔

62

6 ✔

65

auto pattern_generator(size_t offset = 0) {

79 ✔

66

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

5,209 ✔

67

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

5,209 ✔

68

      ++i;

5,209 ✔

73

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

1 ✔

74

   return {

1 ✔

76

            [](auto& result) {

1 ✔

77

               Botan::bitvector bv;

1 ✔

78

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

2 ✔

79

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

2 ✔

80

}),

1 ✔

83

            [](auto& result) {

1 ✔

84

               Botan::bitvector bv(10);

1 ✔

85

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

2 ✔

86

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

1 ✔

87

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

11 ✔

88

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

20 ✔

90

}),

1 ✔

93

            [&](auto& result) {

1 ✔

94

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

1 ✔

96

               for(size_t i : ones) {

24 ✔

97

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

23 ✔

98

                     bv.set(i);

8 ✔

100

                     bv.at(i) = true;

15 ✔

103

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

32 ✔

104

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

93 ✔

106

}),

1 ✔

109

            [&](auto& result) {

1 ✔

110

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

1 ✔

111

               for(auto b : bv) {

35 ✔

112

                  b.set();

33 ✔

115

               for(size_t i : zeros) {

3 ✔

116

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

2 ✔

119

                     bv.at(i) = false;

2 ✔

122

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

34 ✔

123

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

99 ✔

125

}),

1 ✔

128

            [&](auto& result) {

1 ✔

129

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

1 ✔

131

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

44 ✔

132

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

86 ✔

133

                     bv.set(i);

13 ✔

135

                  bv.flip(i);

43 ✔

137

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

44 ✔

138

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

129 ✔

140

}),

1 ✔

143

            [](auto& result) {

1 ✔

144

               Botan::bitvector bv(10);

1 ✔

145

               result.template test_throws<Botan::Invalid_Argument>(

2 ✔

146

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

2 ✔

147

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

3 ✔

148

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

3 ✔

149

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

3 ✔

150

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

4 ✔

151

}),

1 ✔

154

            [](auto& result) {

1 ✔

155

               Botan::bitvector bv(128);

1 ✔

156

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

2 ✔

157

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

1 ✔

158

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

129 ✔

159

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

128 ✔

160

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

256 ✔

162

}),

1 ✔

165

            [](auto& result) {

1 ✔

166

               Botan::bitvector bv(128);

1 ✔

167

               bv[0].set();

1 ✔

168

               bv[1] = true;

1 ✔

169

               bv[2].flip();

1 ✔

170

               bv[64] = true;

1 ✔

171

               bv[80] = true;

1 ✔

172

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

2 ✔

173

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

2 ✔

174

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

2 ✔

175

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

2 ✔

176

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

2 ✔

177

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

2 ✔

178

}),

1 ✔

181

            [](auto& result) {

1 ✔

182

               Botan::bitvector bv(10);

1 ✔

183

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

3 ✔

187

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

3 ✔

188

}),

1 ✔

191

            [](auto& result) {

1 ✔

192

               Botan::bitvector bv(4);

1 ✔

194

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

2 ✔

195

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

1 ✔

196

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

2 ✔

197

               bv[0].set();

1 ✔

198

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

1 ✔

199

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

2 ✔

200

               bv[0] &= false;

1 ✔

201

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

2 ✔

202

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

1 ✔

203

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

2 ✔

205

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

2 ✔

206

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

1 ✔

207

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

2 ✔

208

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

1 ✔

209

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

2 ✔

210

               bv[1].unset();

1 ✔

211

               bv[1] |= false;

1 ✔

212

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

2 ✔

213

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

1 ✔

214

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

2 ✔

216

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

2 ✔

217

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

1 ✔

218

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

2 ✔

219

               bv[2] ^= true;

1 ✔

220

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

2 ✔

221

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

1 ✔

222

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

2 ✔

223

}),

1 ✔

224

};

11 ✔

225

1 ✔

227

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

1 ✔

228

   return {

1 ✔

230

            [](auto& result) {

1 ✔

231

               Botan::bitvector bv;

1 ✔

232

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

2 ✔

233

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

2 ✔

234

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

2 ✔

235

}),

1 ✔

238

            [](auto& result) {

1 ✔

239

               Botan::bitvector bv(1);

1 ✔

240

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

2 ✔

241

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

2 ✔

242

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

2 ✔

243

}),

1 ✔

246

            [](auto& result) {

1 ✔

247

               Botan::bitvector bv;

1 ✔

248

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

2 ✔

249

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

2 ✔

251

               bv.reserve(64);

1 ✔

252

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

2 ✔

253

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

2 ✔

255

               bv.reserve(128);

1 ✔

256

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

2 ✔

257

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

2 ✔

258

}),

1 ✔

261

            [](Test::Result& result) {

1 ✔

262

               Botan::bitvector bv;

1 ✔

263

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

2 ✔

264

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

1 ✔

266

               bv.push_back(true);

1 ✔

267

               bv.push_back(false);

1 ✔

268

               bv.push_back(true);

1 ✔

269

               bv.push_back(false);

1 ✔

271

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

2 ✔

272

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

1 ✔

273

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

1 ✔

275

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

2 ✔

276

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

2 ✔

277

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

2 ✔

278

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

2 ✔

280

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

4 ✔

281

}),

1 ✔

284

            [](Test::Result& result) {

1 ✔

285

               Botan::bitvector bv;

1 ✔

286

               bv.push_back(true);

1 ✔

287

               bv.push_back(false);

1 ✔

288

               bv.push_back(true);

1 ✔

289

               bv.push_back(false);

1 ✔

290

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

2 ✔

292

               bv.pop_back();

1 ✔

293

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

1 ✔

294

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

2 ✔

296

               bv.pop_back();

1 ✔

297

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

1 ✔

298

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

2 ✔

300

               bv.pop_back();

1 ✔

301

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

1 ✔

302

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

2 ✔

303

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

2 ✔

305

               bv.pop_back();

1 ✔

306

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

2 ✔

308

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

4 ✔

309

}),

1 ✔

312

            [](auto& result) {

1 ✔

313

               Botan::bitvector bv(10);

1 ✔

314

               bv[0] = true;

1 ✔

315

               bv[5] = true;

1 ✔

316

               bv[9] = true;

1 ✔

318

               bv.resize(8);

1 ✔

319

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

1 ✔

321

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

9 ✔

322

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

8 ✔

323

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

16 ✔

326

               bv.resize(0);

1 ✔

327

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

2 ✔

329

               bv.resize(8);

1 ✔

330

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

2 ✔

331

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

2 ✔

332

}),

1 ✔

333

};

7 ✔

334

1 ✔

336

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

1 ✔

337

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

21 ✔

338

      auto next = pattern_generator<3>(pattern_offset);

20 ✔

341

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

316 ✔

342

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

304 ✔

345

         for(auto& i : bitvector) {

1,616 ✔

346

            i = next();

800 ✔

349

};

8 ✔

351

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

13 ✔

352

      T bitvector = 0;

12 ✔

353

      make_bitpattern(bitvector, pattern_offset);

24 ✔

355

};

1 ✔

357

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

44 ✔

359

      auto next = pattern_generator<3>(offset);

43 ✔

362

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

496 ✔

363

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

960 ✔

366

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

2,056 ✔

367

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

4,058 ✔

370

};

43 ✔

372

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

13 ✔

373

      auto next = pattern_generator<3>();

12 ✔

374

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

1,212 ✔

375

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

1,200 ✔

376

         const bool expected = next();

1,200 ✔

377

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

2,400 ✔

379

};

12 ✔

381

   return {

1 ✔

383

            [&](auto& result) {

1 ✔

384

               Botan::bitvector bv(100);

1 ✔

385

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

3 ✔

386

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

3 ✔

387

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

3 ✔

388

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

4 ✔

389

}),

1 ✔

392

            [&](auto& result) {

1 ✔

393

               Botan::bitvector bv1(100);

1 ✔

394

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

1 ✔

395

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

1 ✔

396

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

1 ✔

397

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

1 ✔

398

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

1 ✔

399

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

2 ✔

400

}),

2 ✔

403

            [&](auto& result) {

1 ✔

404

               Botan::bitvector bv1(100);

1 ✔

405

               make_bitpattern(bv1);

1 ✔

407

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

1 ✔

408

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

1 ✔

409

               check_bitpattern(result, bv2, 16);

1 ✔

411

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

1 ✔

412

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

1 ✔

413

               check_bitpattern(result, bv3, 32);

1 ✔

414

}),

3 ✔

417

            [&](auto& result) {

1 ✔

418

               Botan::bitvector bv1(100);

1 ✔

419

               make_bitpattern(bv1);

1 ✔

421

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

1 ✔

422

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

1 ✔

423

               check_bitpattern(result, bv2, 8);

1 ✔

425

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

1 ✔

426

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

1 ✔

427

               check_bitpattern(result, bv3, 16);

1 ✔

429

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

1 ✔

430

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

1 ✔

431

               check_bitpattern(result, bv4, 24);

1 ✔

433

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

1 ✔

434

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

1 ✔

435

               check_bitpattern(result, bv5, 32);

1 ✔

437

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

1 ✔

438

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

1 ✔

439

               check_bitpattern(result, bv6, 48);

1 ✔

440

}),

6 ✔

443

            [&](auto& result) {

1 ✔

444

               Botan::bitvector bv1(100);

1 ✔

445

               make_bitpattern(bv1);

1 ✔

447

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

1 ✔

448

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

1 ✔

449

               check_bitpattern(result, bv2, 16);

1 ✔

451

               bv2.resize(32);

1 ✔

452

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

16 ✔

453

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

30 ✔

455

}),

2 ✔

458

            [&](auto& result) {

1 ✔

459

               Botan::bitvector bv1(100);

1 ✔

460

               make_bitpattern(bv1);

1 ✔

462

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

1 ✔

463

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

1 ✔

464

               check_bitpattern(result, bv2, 19);

1 ✔

466

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

1 ✔

467

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

1 ✔

468

               check_bitpattern(result, bv3, 21);

1 ✔

470

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

1 ✔

471

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

1 ✔

472

               check_bitpattern(result, bv4, 1);

1 ✔

474

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

1 ✔

475

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

1 ✔

476

               check_bitpattern(result, bv5, 1);

1 ✔

478

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

1 ✔

479

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

1 ✔

480

               check_bitpattern(result, bv6, 1 + 1);

1 ✔

482

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

1 ✔

483

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

1 ✔

484

               check_bitpattern(result, bv7, 17);

1 ✔

486

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

1 ✔

487

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

1 ✔

488

               check_bitpattern(result, bv8, 33);

1 ✔

489

}),

8 ✔

492

            [&](auto& result) {

1 ✔

493

               Botan::bitvector bv1(100);

1 ✔

494

               make_bitpattern(bv1);

1 ✔

496

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

1 ✔

497

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

1 ✔

498

               check_bitpattern(result, u8_0, 0);

1 ✔

499

               check_bitpattern(result, u8_32, 32);

1 ✔

501

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

1 ✔

502

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

1 ✔

503

               check_bitpattern(result, u16_0, 0);

1 ✔

504

               check_bitpattern(result, u16_56, 56);

1 ✔

506

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

1 ✔

507

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

1 ✔

508

               check_bitpattern(result, u32_0, 0);

1 ✔

509

               check_bitpattern(result, u32_48, 48);

1 ✔

511

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

1 ✔

512

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

1 ✔

513

               check_bitpattern(result, u64_0, 0);

1 ✔

514

               check_bitpattern(result, u64_32, 32);

1 ✔

516

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

3 ✔

517

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

3 ✔

518

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

3 ✔

519

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

4 ✔

520

}),

1 ✔

523

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

1 ✔

524

               Botan::bitvector bv1(100);

1 ✔

525

               make_bitpattern(bv1);

1 ✔

527

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

1 ✔

528

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

1 ✔

529

               check_bitpattern(result, u8_3, 3);

1 ✔

530

               check_bitpattern(result, u8_92, 92);

1 ✔

532

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

1 ✔

533

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

1 ✔

534

               check_bitpattern(result, u16_7, 7);

1 ✔

535

               check_bitpattern(result, u16_84, 84);

1 ✔

537

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

1 ✔

538

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

1 ✔

539

               check_bitpattern(result, u32_11, 11);

1 ✔

540

               check_bitpattern(result, u32_68, 68);

1 ✔

542

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

1 ✔

543

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

1 ✔

544

               check_bitpattern(result, u64_21, 21);

1 ✔

545

               check_bitpattern(result, u64_36, 36);

1 ✔

546

}),

1 ✔

549

            [&](auto& result) {

1 ✔

550

               Botan::bitvector bv1(100);

1 ✔

551

               make_bitpattern(bv1);

1 ✔

553

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

1 ✔

554

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

1 ✔

555

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

2 ✔

556

               check_bitpattern(result, bv1);

1 ✔

558

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

1 ✔

559

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

1 ✔

560

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

2 ✔

561

               check_bitpattern(result, bv1);

1 ✔

563

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

1 ✔

564

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

1 ✔

565

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

2 ✔

566

               check_bitpattern(result, bv1);

1 ✔

568

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

1 ✔

569

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

1 ✔

570

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

2 ✔

571

               check_bitpattern(result, bv1);

1 ✔

573

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

1 ✔

574

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

1 ✔

575

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

2 ✔

576

               check_bitpattern(result, bv1);

1 ✔

578

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

3 ✔

579

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

3 ✔

580

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

3 ✔

581

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

4 ✔

582

}),

1 ✔

585

            [&](auto& result) {

1 ✔

586

               Botan::bitvector bv1(100);

1 ✔

587

               make_bitpattern(bv1);

1 ✔

589

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

1 ✔

590

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

1 ✔

591

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

2 ✔

592

               check_bitpattern(result, bv1);

1 ✔

594

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

1 ✔

595

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

1 ✔

596

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

2 ✔

597

               check_bitpattern(result, bv1);

1 ✔

599

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

1 ✔

600

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

1 ✔

601

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

2 ✔

602

               check_bitpattern(result, bv1);

1 ✔

604

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

1 ✔

605

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

1 ✔

606

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

2 ✔

607

               check_bitpattern(result, bv1);

1 ✔

609

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

1 ✔

610

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

1 ✔

611

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

2 ✔

612

               check_bitpattern(result, bv1);

1 ✔

614

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

1 ✔

615

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

1 ✔

616

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

2 ✔

617

               check_bitpattern(result, bv1);

1 ✔

619

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

1 ✔

620

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

1 ✔

621

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

2 ✔

622

               check_bitpattern(result, bv1);

1 ✔

623

}),

1 ✔

624

};

11 ✔

625

1 ✔

627

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

1 ✔

628

   auto make_bitpattern = [](auto& bitvector) {

3 ✔

629

      auto next = pattern_generator<5>();

2 ✔

630

      for(auto& i : bitvector) {

400 ✔

631

         i = next();

198 ✔

633

};

2 ✔

635

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

2 ✔

636

      auto next = pattern_generator<5>();

1 ✔

637

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

100 ✔

638

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

198 ✔

640

};

1 ✔

642

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

2 ✔

643

      auto next = pattern_generator<5>();

1 ✔

644

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

100 ✔

645

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

198 ✔

647

};

1 ✔

649

   return {

1 ✔

651

            [](auto& result) {

1 ✔

652

               Botan::bitvector bv;

1 ✔

653

               bv.push_back(true);

1 ✔

655

               bv.flip();

1 ✔

656

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

2 ✔

659

               bv.resize(8);

1 ✔

660

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

9 ✔

661

                  result.confirm("all bits are false", !bv[i]);

16 ✔

663

               bv.resize(1);

1 ✔

665

               bv.flip();

1 ✔

666

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

2 ✔

667

}),

1 ✔

670

            [&](auto& result) {

1 ✔

671

               Botan::bitvector bv(99);

1 ✔

673

               make_bitpattern(bv);

1 ✔

674

               bv.flip();

1 ✔

675

               check_flipped_bitpattern(result, bv);

1 ✔

677

               bv = ~bv;

2 ✔

678

               check_bitpattern(result, bv);

1 ✔

680

               bv.resize(112);

1 ✔

681

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

14 ✔

682

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

26 ✔

684

}),

1 ✔

687

            [&](auto& result) {

1 ✔

688

               Botan::bitvector bv(99);

1 ✔

690

               make_bitpattern(bv);

1 ✔

691

               bv.set();

1 ✔

692

               bv.resize(128);

1 ✔

693

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

129 ✔

694

                  const bool expected = (i < 99);

128 ✔

695

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

256 ✔

698

               bv.unset();

1 ✔

699

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

129 ✔

700

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

256 ✔

702

}),

1 ✔

705

            [&](auto& result) {

1 ✔

706

               Botan::bitvector bv(99);

1 ✔

708

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

2 ✔

709

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

2 ✔

710

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

2 ✔

711

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

2 ✔

712

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

2 ✔

713

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

2 ✔

715

               bv.set(42);

1 ✔

716

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

2 ✔

717

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

2 ✔

718

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

2 ✔

719

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

2 ✔

720

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

2 ✔

721

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

2 ✔

723

               bv.set();

1 ✔

724

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

2 ✔

725

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

2 ✔

726

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

2 ✔

727

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

2 ✔

728

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

2 ✔

729

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

2 ✔

731

               bv.unset(97);

1 ✔

732

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

2 ✔

733

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

2 ✔

734

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

2 ✔

735

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

2 ✔

736

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

2 ✔

737

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

2 ✔

739

               bv.unset();

1 ✔

740

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

2 ✔

741

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

2 ✔

742

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

2 ✔

743

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

2 ✔

744

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

2 ✔

745

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

2 ✔

746

}),

1 ✔

749

            [](auto& result) {

1 ✔

750

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

1 ✔

751

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

1 ✔

753

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

3 ✔

754

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

3 ✔

755

}),

2 ✔

758

            [](auto& result) {

1 ✔

759

               auto naive_count = [](auto& v) {

5 ✔

760

                  size_t weight = 0;

5 ✔

761

                  for(const auto& bit : v) {

440 ✔

762

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

430 ✔

764

                  return weight;

5 ✔

768

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

2 ✔

769

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

1 ✔

770

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

2 ✔

772

               bv.pop_back();

1 ✔

773

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

1 ✔

774

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

2 ✔

776

               bv.pop_back();

1 ✔

777

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

1 ✔

778

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

2 ✔

780

               bv.pop_back();

1 ✔

781

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

1 ✔

782

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

2 ✔

784

               bv.pop_back();

1 ✔

785

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

1 ✔

786

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

2 ✔

787

}),

1 ✔

788

};

7 ✔

789

1 ✔

791

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

1 ✔

792

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

13 ✔

793

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

252 ✔

794

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

240 ✔

795

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

661 ✔

797

};

12 ✔

799

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

7 ✔

801

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

12 ✔

803

};

6 ✔

805

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

4 ✔

807

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

6 ✔

808

};

3 ✔

810

   return {

1 ✔

812

            [&](auto& result) {

1 ✔

813

               Botan::bitvector lhs(20);

1 ✔

814

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

1 ✔

815

               Botan::bitvector rhs(20);

1 ✔

816

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

1 ✔

818

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

1 ✔

819

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

2 ✔

821

               lhs.unset().set(13);

1 ✔

822

               rhs.unset().set(13);

1 ✔

824

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

1 ✔

825

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

2 ✔

826

}),

2 ✔

829

            [&](auto& result) {

1 ✔

830

               Botan::bitvector lhs(20);

1 ✔

831

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

1 ✔

832

               Botan::bitvector rhs(20);

1 ✔

833

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

1 ✔

834

               Botan::bitvector unary(20);

1 ✔

835

               unary.set(8);

1 ✔

837

               Botan::bitvector res = lhs | rhs;

1 ✔

838

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

4 ✔

840

               res |= unary;

1 ✔

841

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

3 ✔

843

               is_standard_allocator(result, res);

1 ✔

844

}),

4 ✔

847

            [&](auto& result) {

1 ✔

848

               Botan::bitvector lhs(20);

1 ✔

849

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

1 ✔

850

               Botan::bitvector rhs(20);

1 ✔

851

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

1 ✔

852

               Botan::bitvector unary(20);

1 ✔

853

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

1 ✔

855

               Botan::bitvector res = lhs & rhs;

1 ✔

856

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

4 ✔

858

               res &= unary;

1 ✔

859

               check_set(result, res, {16});

3 ✔

861

               is_standard_allocator(result, res);

1 ✔

862

}),

4 ✔

865

            [&](auto& result) {

1 ✔

866

               Botan::bitvector lhs(20);

1 ✔

867

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

1 ✔

868

               Botan::bitvector rhs(20);

1 ✔

869

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

1 ✔

870

               Botan::bitvector unary(20);

1 ✔

871

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

1 ✔

873

               Botan::bitvector res = lhs ^ rhs;

1 ✔

874

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

4 ✔

876

               res ^= unary;

1 ✔

877

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

3 ✔

879

               is_standard_allocator(result, res);

1 ✔

880

}),

4 ✔

883

            [&](auto& result) {

1 ✔

884

               Botan::bitvector lhs(20);

1 ✔

885

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

1 ✔

886

               Botan::secure_bitvector rhs(20);

1 ✔

887

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

1 ✔

888

               Botan::bitvector unary(20);

1 ✔

889

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

1 ✔

891

               auto res1 = lhs | rhs;

1 ✔

892

               is_secure_allocator(result, res1);

1 ✔

893

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

3 ✔

895

               auto res2 = rhs | lhs;

1 ✔

896

               is_secure_allocator(result, res2);

1 ✔

897

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

3 ✔

899

               auto res3 = lhs & rhs;

1 ✔

900

               is_secure_allocator(result, res3);

1 ✔

901

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

3 ✔

903

               auto res4 = rhs & lhs;

1 ✔

904

               is_secure_allocator(result, res4);

1 ✔

905

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

3 ✔

907

               auto res5 = lhs ^ rhs;

1 ✔

908

               is_secure_allocator(result, res5);

1 ✔

909

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

3 ✔

911

               auto res6 = rhs ^ lhs;

1 ✔

912

               is_secure_allocator(result, res6);

1 ✔

913

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

4 ✔

914

}),

8 ✔

915

};

6 ✔

916

1 ✔

918

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

1 ✔

919

   constexpr uint8_t outlen = 64;

1 ✔

920

   const auto bytearray = [] {

1 ✔

928

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

3 ✔

929

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

129 ✔

930

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

127 ✔

931

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

127 ✔

932

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

127 ✔

933

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

127 ✔

935

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

254 ✔

937

};

2 ✔

939

   return {

1 ✔

941

            [](auto& result) {

1 ✔

942

               std::vector<uint8_t> bytes;

1 ✔

943

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

2 ✔

945

               Botan::bitvector bv(bytes);

1 ✔

946

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

2 ✔

948

               auto rendered = bv.to_bytes();

1 ✔

949

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

2 ✔

950

}),

1 ✔

953

            [](auto& result) {

1 ✔

954

               Botan::bitvector bv;

1 ✔

955

               Botan::secure_bitvector sbv;

1 ✔

957

               auto rbv = bv.to_bytes();

1 ✔

958

               auto rsbv = sbv.to_bytes();

1 ✔

960

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

2 ✔

962

               result.confirm("secure bitvector uses secure_vector",

2 ✔

964

}),

1 ✔

967

            [&](auto& result) {

1 ✔

968

               Botan::bitvector bv(bytearray);

1 ✔

969

               validate_bytewise(result, bv, bytearray);

1 ✔

971

               const auto rbv = bv.to_bytes();

1 ✔

972

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

3 ✔

973

}),

2 ✔

976

            [&](auto& result) {

1 ✔

978

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

1 ✔

980

               Botan::bitvector bv(unaligned_bytearray);

1 ✔

981

               validate_bytewise(result, bv, unaligned_bytearray);

1 ✔

983

               const auto rbv = bv.to_bytes();

1 ✔

984

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

2 ✔

985

}),

3 ✔

988

            [&](auto& result) {

1 ✔

989

               constexpr size_t bits_to_load = 31;

1 ✔

990

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

1 ✔

992

               Botan::bitvector bv(bytearray, bits_to_load);

1 ✔

994

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

32 ✔

995

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

31 ✔

996

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

62 ✔

999

               const auto rbv = bv.to_bytes();

1 ✔

1001

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

1 ✔

1002

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

1 ✔

1003

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

2 ✔

1004

}),

2 ✔

1007

            [&](auto& result) {

1 ✔

1008

               constexpr size_t bits_to_load = 33;

1 ✔

1009

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

1 ✔

1011

               Botan::bitvector bv(bytearray, bits_to_load);

1 ✔

1012

               bv.set(32);

1 ✔

1014

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

1 ✔

1015

               bv.to_bytes(out);

1 ✔

1017

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

2 ✔

1018

}),

1 ✔

1019

};

7 ✔

1020

1 ✔

1022

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

1 ✔

1023

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

1 ✔

1024

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

1 ✔

1026

   return {

1 ✔

1028

            [&](auto& result) {

1 ✔

1029

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

2 ✔

1030

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

2 ✔

1031

               const auto initial_bv1 = bv1;

1 ✔

1032

               const auto xor_result = bv1 ^ bv2;

1 ✔

1034

               bv1.ct_conditional_xor(no, bv2);

1 ✔

1035

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

2 ✔

1037

               bv1.ct_conditional_xor(yes, bv2);

1 ✔

1038

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

2 ✔

1039

}),

4 ✔

1042

            [&](auto& result) {

1 ✔

1043

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

2 ✔

1044

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

2 ✔

1045

               const auto initial_bv1 = bv1;

1 ✔

1046

               const auto xor_result = bv1 ^ bv2;

1 ✔

1048

               bv1.ct_conditional_xor(no, bv2);

1 ✔

1049

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

2 ✔

1051

               bv1.ct_conditional_xor(yes, bv2);

1 ✔

1052

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

2 ✔

1053

}),

4 ✔

1056

            [&](auto& result) {

1 ✔

1057

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

1 ✔

1058

               bv1.push_back(true);

1 ✔

1059

               bv1.push_back(false);

1 ✔

1060

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

1 ✔

1061

               bv2.push_back(false);

1 ✔

1062

               bv2.push_back(false);

1 ✔

1064

               const auto initial_bv1 = bv1;

1 ✔

1065

               const auto xor_result = bv1 ^ bv2;

1 ✔

1067

               bv1.ct_conditional_xor(no, bv2);

1 ✔

1068

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

2 ✔

1070

               bv1.ct_conditional_xor(yes, bv2);

1 ✔

1071

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

2 ✔

1072

}),

4 ✔

1073

};

4 ✔

1074

1 ✔

1076

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

1 ✔

1077

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

1 ✔

1079

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

1 ✔

1081

   const size_t matrix_rows = 1664;

1 ✔

1082

   const size_t matrix_columns = 8192;

1 ✔

1084

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

1 ✔

1085

   bitvec_vec.reserve(matrix_rows);

1 ✔

1086

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

1,665 ✔

1087

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

4,992 ✔

1091

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

1 ✔

1092

   const auto start = Test::timestamp();

1 ✔

1093

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

4,152,513 ✔

1094

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

4,152,512 ✔

1095

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

4,152,512 ✔

1097

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

1 ✔

1099

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

3 ✔

1100

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

1 ✔

1101

   return {res};

3 ✔

1102

3 ✔

1104

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

1 ✔

1105

   return {

1 ✔

1107

            [](auto& result) {

1 ✔

1108

               Botan::bitvector bv(6);

1 ✔

1109

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

1 ✔

1111

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

8 ✔

1112

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

6 ✔

1113

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

6 ✔

1114

                  ++i;

6 ✔

1117

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

8 ✔

1118

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

6 ✔

1119

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

6 ✔

1120

                  ++i;

6 ✔

1123

               for(auto ref : bv) {

14 ✔

1124

                  ref = true;

6 ✔

1127

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

2 ✔

1128

}),

1 ✔

1131

            [](auto& result) {

1 ✔

1132

               Botan::bitvector bv(6);

1 ✔

1133

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

1 ✔

1135

               size_t i = 0;

1 ✔

1136

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

7 ✔

1137

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

6 ✔

1138

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

12 ✔

1141

               i = 0;

1 ✔

1142

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

7 ✔

1143

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

6 ✔

1144

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

12 ✔

1147

               i = 6;

1 ✔

1148

               auto ritr = bv.end();

1 ✔

1150

                  --ritr;

6 ✔

1151

                  --i;

6 ✔

1152

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

6 ✔

1153

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

6 ✔

1154

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

11 ✔

1156

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

7 ✔

1157

                  itr->flip();

6 ✔

1160

               i = 0;

1 ✔

1161

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

7 ✔

1162

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

6 ✔

1163

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

12 ✔

1165

}),

1 ✔

1168

            [](auto& result) {

1 ✔

1169

               Botan::bitvector bv(6);

1 ✔

1172

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

2 ✔

1173

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

3 ✔

1175

               auto b = bv.begin();

1 ✔

1176

               std::advance(b, 3);

1 ✔

1177

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

3 ✔

1178

}),

1 ✔

1181

            [](auto& result) {

1 ✔

1182

               Botan::bitvector bv(500);

1 ✔

1184

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

1,001 ✔

1185

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

1,000 ✔

1186

                     itr->set();

250 ✔

1188

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

1,000 ✔

1189

                     *itr = true;

167 ✔

1193

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

502 ✔

1194

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

500 ✔

1195

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

500 ✔

1196

                  ++i;

500 ✔

1198

}),

1 ✔

1201

            [](auto& result) {

1 ✔

1202

               Botan::secure_bitvector bv(42);

1 ✔

1203

               auto ro_itr = bv.cbegin();

1 ✔

1204

               auto rw_itr = bv.begin();

1 ✔

1209

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

2 ✔

1210

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

2 ✔

1211

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

2 ✔

1212

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

2 ✔

1213

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

2 ✔

1214

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

2 ✔

1215

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

2 ✔

1216

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

2 ✔

1217

}),

1 ✔

1218

};

6 ✔

1219

1 ✔

1225

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

1 ✔

1226

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

1 ✔

1228

   TestBitvector bv1(33);

1 ✔

1230

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

2 ✔

1231

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

1 ✔

1233

   bv1[0] = true;

1 ✔

1234

   bv1.at(1) = true;

1 ✔

1235

   bv1.set(2);

2 ✔

1236

   bv1.unset(3);

2 ✔

1237

   bv1.flip(4);

2 ✔

1238

   bv1.push_back(true);

1 ✔

1239

   bv1.push_back(false);

1 ✔

1240

   bv1.pop_back();

1 ✔

1242

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

2 ✔

1243

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

2 ✔

1244

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

2 ✔

1245

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

2 ✔

1246

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

2 ✔

1248

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

2 ✔

1250

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

36 ✔

1251

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

34 ✔

1252

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

68 ✔

1253

      ++i;

34 ✔

1256

   bv1.flip();

2 ✔

1258

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

36 ✔

1259

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

34 ✔

1260

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

68 ✔

1261

      ++i;

34 ✔

1264

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

1 ✔

1266

   auto bv3 = bv1 | bv2;

1 ✔

1267

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

2 ✔

1269

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

1 ✔

1270

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

2 ✔

1272

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

1 ✔

1273

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

2 ✔

1274

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

1 ✔

1276

   const auto str = bv4.to_string();

1 ✔

1277

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

2 ✔

1279

   return {result};

3 ✔

1280

6 ✔

1286

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

1 ✔

1287

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

1 ✔

1288

         auto& rng = Test::rng();

1 ✔

1290

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

1 ✔

1301

};

11 ✔

1303

         for(const auto& test_func : funcs) {

11 ✔

1304

            auto fn_results = test_func(rng);

10 ✔

1305

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

10 ✔

1306

10 ✔

1308

         return results;

1 ✔

1309

2 ✔

randombit / botan / 13073892384

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

randombit / botan / 13073892384

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