Reneable ConvertToVole tests

Author: sebastinas

tests/vole.cpp

@@ -88,51 +88,49 @@ BOOST_DATA_TEST_CASE(vole_commit_verify, all_parameters, param_id) {
   }
 }
 
-#if 0
 BOOST_DATA_TEST_CASE(convert_to_vole, all_parameters, param_id) {
+  std::mt19937_64 rd;
   BOOST_TEST_CONTEXT("Parameter set: " << faest_get_param_name(param_id)) {
-    const faest_paramset_t params  = faest_get_paramset(param_id);
-    const unsigned int lambda      = params.faest_param.lambda;
-    const unsigned int lambdaBytes = lambda / 8;
+    const faest_paramset_t params   = faest_get_paramset(param_id);
+    const unsigned int lambda       = params.faest_param.lambda;
+    const unsigned int lambda_bytes = lambda / 8;
     const unsigned int ell_hat =
         params.faest_param.l + params.faest_param.lambda * 2 + UNIVERSAL_HASH_B_BITS;
     const unsigned int ell_hat_bytes = (ell_hat + 7) / 8;
-    const unsigned int max_depth     = std::max(params.faest_param.k0, params.faest_param.k1);
+    const unsigned int max_depth     = params.faest_param.k;
     const unsigned int max_nodes     = 1 << max_depth;
+    const unsigned int tau           = params.faest_param.tau;
 
-    std::vector<uint8_t> sd, u, v, q, chal_out, chal;
-    sd.resize(max_nodes * lambdaBytes);
+    std::vector<uint8_t> sd, u, v, q;
+    sd.resize(max_nodes * lambda_bytes);
     rand_bytes(sd.data(), sd.size());
-    chal_out.resize(max_depth);
     u.resize(ell_hat_bytes);
     v.resize(ell_hat_bytes * max_depth);
     q.resize(ell_hat_bytes * max_depth);
-    chal.resize(lambdaBytes);
-    rand_bytes(chal.data(), chal.size());
 
-    for (unsigned int i = 0; i != params.faest_param.tau; ++i) {
-      unsigned int depth =
-          i < params.faest_param.t0 ? params.faest_param.k0 : params.faest_param.k1;
+    for (unsigned int i = 0; i != tau; ++i) {
+      std::uniform_int_distribution<> distribution{
+          0,
+          static_cast<int>(bavc_max_node_index(i, params.faest_param.tau1, params.faest_param.k)) -
+              1};
+      const unsigned int idx = distribution(rd);
+
+      unsigned int depth = bavc_max_node_depth(i, params.faest_param.tau1, max_depth);
       unsigned int nodes = 1 << depth;
 
-      ConvertToVole(iv.data(), sd.data(), false, lambda, depth, ell_hat_bytes, u.data(), v.data());
+      ConvertToVole(iv.data(), sd.data(), false, i, ell_hat_bytes, u.data(), v.data(), &params);
 
-      ChalDec(chal.data(), i, params.faest_param.k0, params.faest_param.t0, params.faest_param.k1,
-              params.faest_param.t1, chal_out.data());
-      const auto idx = NumRec(depth, chal_out.data());
       std::vector<uint8_t> sdprime;
-      sdprime.resize(max_nodes * lambdaBytes, 0);
+      sdprime.resize(max_nodes * lambda_bytes, 0);
       for (unsigned int j = 1; j != nodes; ++j) {
-        std::copy(&sd[(j ^ idx) * lambdaBytes], &sd[((j ^ idx) + 1) * lambdaBytes],
-                  &sdprime[j * lambdaBytes]);
+        std::copy(&sd[(j ^ idx) * lambda_bytes], &sd[((j ^ idx) + 1) * lambda_bytes],
+                  &sdprime[j * lambda_bytes]);
       }
 
-      ConvertToVole(iv.data(), sdprime.data(), true, lambda, depth, ell_hat_bytes, nullptr,
-                    q.data());
+      ConvertToVole(iv.data(), sdprime.data(), true, i, ell_hat_bytes, nullptr, q.data(), &params);
 
       for (unsigned int j = 0; j != depth; ++j) {
-        BOOST_TEST((chal_out[j] == 0 || chal_out[j] == 1));
-        if (chal_out[j]) {
+        if (idx & (1 << j)) {
           for (unsigned int inner = 0; inner != ell_hat_bytes; ++inner) {
             q[j * ell_hat_bytes + inner] ^= u[inner];
           }
@@ -142,6 +140,5 @@ BOOST_DATA_TEST_CASE(convert_to_vole, all_parameters, param_id) {
     }
   }
 }
-#endif
 
 BOOST_AUTO_TEST_SUITE_END()