Add transport security state generator tests.

net/tools/transport_security_state_generator/preloaded_state_generator.cc

 // Copyright (c) 2016 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/tools/transport_security_state_generator/preloaded_state_generator.h"
 
-#include <iostream>
-
 #include <string>
 
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "net/tools/transport_security_state_generator/cert_util.h"
 #include "net/tools/transport_security_state_generator/huffman/huffman_builder.h"
 #include "net/tools/transport_security_state_generator/spki_hash.h"
 
 namespace net {
 
@@ skipping 103 matching lines @@
 
   return huffman_builder.ToTable();
 }
 
 }  // namespace
 
 PreloadedStateGenerator::PreloadedStateGenerator() {}
 
 PreloadedStateGenerator::~PreloadedStateGenerator() {}
 
-std::string PreloadedStateGenerator::Generate(
+bool PreloadedStateGenerator::Generate(
     const std::string& preload_template,
     const TransportSecurityStateEntries& entries,
     const DomainIDList& domain_ids,
     const Pinsets& pinsets,
-    bool verbose) {
-  std::string output = preload_template;
+    std::string* output) {
+  DCHECK(output);
+  *output = preload_template;
 
   NameIDMap domain_ids_map;
-  ProcessDomainIds(domain_ids, &domain_ids_map, &output);
+  ProcessDomainIds(domain_ids, &domain_ids_map, output);
 
-  ProcessSPKIHashes(pinsets, &output);
+  ProcessSPKIHashes(pinsets, output);
 
   NameIDMap expect_ct_report_uri_map;
-  ProcessExpectCTURIs(entries, &expect_ct_report_uri_map, &output);
+  ProcessExpectCTURIs(entries, &expect_ct_report_uri_map, output);
 
   NameIDMap expect_staple_report_uri_map;
-  ProcessExpectStapleURIs(entries, &expect_staple_report_uri_map, &output);
+  ProcessExpectStapleURIs(entries, &expect_staple_report_uri_map, output);
 
   NameIDMap pinsets_map;
-  ProcessPinsets(pinsets, &pinsets_map, &output);
+  ProcessPinsets(pinsets, &pinsets_map, output);
 
   // The trie generation process is ran twice, the first time using an
   // approximate Huffman table. During this first run, the correct character
   // frequencies are collected which are then used to calculate the most space
   // efficient Huffman table for the given inputs. This table is used for the
   // second run.
   HuffmanRepresentationTable table = ApproximateHuffman(entries);
   HuffmanBuilder huffman_builder;
   TrieWriter writer(table, domain_ids_map, expect_ct_report_uri_map,
                     expect_staple_report_uri_map, pinsets_map,
                     &huffman_builder);
-  writer.WriteEntries(entries);
-  uint32_t initial_length = writer.position();
+  uint32_t root_position;
+  bool success = writer.WriteEntries(entries, &root_position);
 
   HuffmanRepresentationTable optimal_table = huffman_builder.ToTable();
   TrieWriter new_writer(optimal_table, domain_ids_map, expect_ct_report_uri_map,
                         expect_staple_report_uri_map, pinsets_map, nullptr);
 
-  uint32_t root_position = new_writer.WriteEntries(entries);
+  success = success && new_writer.WriteEntries(entries, &root_position);
   uint32_t new_length = new_writer.position();
 
   std::vector<uint8_t> huffman_tree = huffman_builder.ToVector();
 
   new_writer.Flush();
 
-  ReplaceTag("HUFFMAN_TREE", FormatVectorAsArray(huffman_tree), &output);
-  ReplaceTag("HSTS_TRIE", FormatVectorAsArray(new_writer.bytes()), &output);
+  ReplaceTag("HUFFMAN_TREE", FormatVectorAsArray(huffman_tree), output);
+  ReplaceTag("HSTS_TRIE", FormatVectorAsArray(new_writer.bytes()), output);
 
-  ReplaceTag("HSTS_TRIE_BITS", std::to_string(new_length), &output);
-  ReplaceTag("HSTS_TRIE_ROOT", std::to_string(root_position), &output);
+  ReplaceTag("HSTS_TRIE_BITS", std::to_string(new_length), output);
+  ReplaceTag("HSTS_TRIE_ROOT", std::to_string(root_position), output);
 
-  if (verbose) {
-    std::cout << "Saved " << std::to_string(initial_length - new_length)
-              << " bits by using accurate Huffman counts." << std::endl;
-    std::cout << "Bit length " << std::to_string(new_length) << std::endl;
-    std::cout << "Root position " << std::to_string(root_position) << std::endl;
-  }
-
-  return output;
+  return success;
 }
 
 void PreloadedStateGenerator::ProcessDomainIds(const DomainIDList& domain_ids,
                                                NameIDMap* map,
                                                std::string* tpl) {
   std::string output = "{";
   output.append(kNewLine);
 
   for (size_t i = 0; i < domain_ids.size(); ++i) {
     const std::string& current = domain_ids.at(i);
@@ skipping 66 matching lines @@
       output.append(kIndent);
       output.append("\"" + entry->expect_ct_report_uri + "\",");
       output.append(kNewLine);
 
       expect_ct_report_uri_map->insert(
           NameIDPair(entry->expect_ct_report_uri,
                      static_cast<uint32_t>(expect_ct_report_uri_map->size())));
     }
   }
 
+  output.append(kIndent);

[martijnc, 2017/02/08 20:58:21]

There are tests without Expect-CT and Expect-Staple report URIs which throw
compiler errors because these arrays would be empty in those cases.

+  output.append(kIndent);
+  output.append("NULL,");
+  output.append(kNewLine);
+
   output.append("}");
   ReplaceTag("EXPECT_CT_REPORT_URIS", output, tpl);
 }
 
 void PreloadedStateGenerator::ProcessExpectStapleURIs(
     const TransportSecurityStateEntries& entries,
     NameIDMap* expect_staple_report_uri_map,
     std::string* tpl) {
   std::string output = "{";
   output.append(kNewLine);
 
   for (const auto& entry : entries) {
     const std::string& url = entry->expect_staple_report_uri;
     if (entry->expect_staple && url.size() &&
         expect_staple_report_uri_map->find(url) ==
             expect_staple_report_uri_map->cend()) {
       output.append(kIndent);
       output.append(kIndent);
       output.append("\"" + entry->expect_staple_report_uri + "\",");
       output.append(kNewLine);
 
       expect_staple_report_uri_map->insert(NameIDPair(
           entry->expect_staple_report_uri,
           static_cast<uint32_t>(expect_staple_report_uri_map->size())));
     }
   }
 
+  output.append(kIndent);
+  output.append(kIndent);
+  output.append("NULL,");
+  output.append(kNewLine);
+
   output.append("}");
   ReplaceTag("EXPECT_STAPLE_REPORT_URIS", output, tpl);
 }
 
 void PreloadedStateGenerator::ProcessPinsets(const Pinsets& pinset,
                                              NameIDMap* pinset_map,
                                              std::string* tpl) {
   std::string certs_output;
   std::string pinsets_output = "{";
   pinsets_output.append(kNewLine);
@@ skipping 43 matching lines @@
 
   base::TrimString(certs_output, kNewLine, &certs_output);
 
   ReplaceTag("ACCEPTABLE_CERTS", certs_output, tpl);
   ReplaceTag("PINSETS", pinsets_output, tpl);
 }
 
 }  // namespace transport_security_state
 
 }  // namespace net