Improve documentation and readability of CTLogVerifier tests

net/cert/ct_log_verifier_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/cert/ct_log_verifier.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <string>
@@ skipping 37 matching lines @@
 };
 
 // All test data replicated from
 // https://github.com/google/certificate-transparency/blob/c41b090ecc14ddd6b3531dc7e5ce36b21e253fdd/cpp/merkletree/merkle_tree_test.cc
 // A hash of the empty string.
 const uint8_t kSHA256EmptyTreeHash[32] = {
     0xe3, 0xb0, 0xc4, 0x42, 0x98, 0xfc, 0x1c, 0x14, 0x9a, 0xfb, 0xf4,
     0xc8, 0x99, 0x6f, 0xb9, 0x24, 0x27, 0xae, 0x41, 0xe4, 0x64, 0x9b,
     0x93, 0x4c, 0xa4, 0x95, 0x99, 0x1b, 0x78, 0x52, 0xb8, 0x55};
 
-// Node hashes for a sample tree of size 8 (each element in this array is
-// a node hash, not leaf data; order represents order of the nodes in the tree).
+// Root hashes from building the sample tree of size 8 leaf-by-leaf.
+// The first entry is the root at size 0, the last is the root at size 8.
 const char* const kSHA256Roots[8] = {
     "6e340b9cffb37a989ca544e6bb780a2c78901d3fb33738768511a30617afa01d",
     "fac54203e7cc696cf0dfcb42c92a1d9dbaf70ad9e621f4bd8d98662f00e3c125",
     "aeb6bcfe274b70a14fb067a5e5578264db0fa9b51af5e0ba159158f329e06e77",
     "d37ee418976dd95753c1c73862b9398fa2a2cf9b4ff0fdfe8b30cd95209614b7",
     "4e3bbb1f7b478dcfe71fb631631519a3bca12c9aefca1612bfce4c13a86264d4",
     "76e67dadbcdf1e10e1b74ddc608abd2f98dfb16fbce75277b5232a127f2087ef",
     "ddb89be403809e325750d3d263cd78929c2942b7942a34b77e122c9594a74c8c",
     "5dc9da79a70659a9ad559cb701ded9a2ab9d823aad2f4960cfe370eff4604328"};
 
@@ skipping 292 matching lines @@
   EXPECT_FALSE(VerifyConsistencyProof(log_, 1, empty_tree_hash, 1,
                                       empty_tree_hash, proof));
 }
 
 TEST_F(CTLogVerifierTest, VerifiesValidConsistencyProofs) {
   std::vector<std::string> proof;
   std::string root1, root2;
 
   // Known good proofs.
   for (size_t i = 0; i < arraysize(kSHA256Proofs); ++i) {
+    SCOPED_TRACE(i);
     proof.clear();
     for (size_t j = 0; j < kSHA256Proofs[i].proof_length; ++j) {
       const char* const v = kSHA256Proofs[i].proof[j];
       proof.push_back(HexToBytes(v));
     }
     const uint64_t snapshot1 = kSHA256Proofs[i].snapshot1;
     const uint64_t snapshot2 = kSHA256Proofs[i].snapshot2;
     const char* const old_root = kSHA256Roots[snapshot1 - 1];
     const char* const new_root = kSHA256Roots[snapshot2 - 1];
     VerifierConsistencyCheck(snapshot1, snapshot2, HexToBytes(old_root),
@@ skipping 86 matching lines @@
   }
   return proof;
 }
 
 class CTLogVerifierTestUsingReferenceGenerator
     : public CTLogVerifierTest,
       public ::testing::WithParamInterface<uint64_t> {};
 
 const uint64_t kReferenceTreeSize = 256;
 
+// Tests that every possible valid consistency proof for a tree of a given size
+// verifies correctly. Also checks that invalid variations of each proof fail to
+// verify (see VerifierConsistencyCheck).
 TEST_P(CTLogVerifierTestUsingReferenceGenerator,
        VerifiesValidConsistencyProof) {
   std::vector<std::string> data;
   for (uint64_t i = 0; i < kReferenceTreeSize; ++i)
     data.push_back(std::string(1, static_cast<char>(i)));
 
   const uint64_t tree_size = GetParam();
   const std::string tree_root = ReferenceMerkleTreeHash(data.data(), tree_size);
 
   for (uint64_t snapshot = 1; snapshot <= tree_size; ++snapshot) {
     SCOPED_TRACE(snapshot);
     const std::string snapshot_root =
         ReferenceMerkleTreeHash(data.data(), snapshot);
     const std::vector<std::string> proof =
         ReferenceSnapshotConsistency(data.data(), tree_size, snapshot, true);
     VerifierConsistencyCheck(snapshot, tree_size, snapshot_root, tree_root,
                              proof);
   }
 }
 
 // Test verification of consistency proofs between all tree sizes from 1 to 128.
 INSTANTIATE_TEST_CASE_P(RangeOfTreeSizesAndSnapshots,
                         CTLogVerifierTestUsingReferenceGenerator,
                         testing::Range(UINT64_C(1),
                                        (kReferenceTreeSize / 2) + 1));
 
 }  // namespace
 
 }  // namespace net