Add transport security state generator tests.

net/tools/transport_security_state_generator/trie/trie_bit_buffer_unittest.cc

Index: net/tools/transport_security_state_generator/trie/trie_bit_buffer_unittest.cc
diff --git a/net/tools/transport_security_state_generator/trie/trie_bit_buffer_unittest.cc b/net/tools/transport_security_state_generator/trie/trie_bit_buffer_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..62ecb3c63b3059a7b376ba6dfeab53a292b40120
--- /dev/null
+++ b/net/tools/transport_security_state_generator/trie/trie_bit_buffer_unittest.cc
@@ -0,0 +1,212 @@
+// Copyright 2017 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/trie/trie_bit_buffer.h"
+#include "net/tools/transport_security_state_generator/bit_writer.h"
+#include "net/tools/transport_security_state_generator/huffman/huffman_builder.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace net {
+
+namespace transport_security_state {
+
+TEST(TrieBitBufferTest, WriteBit) {
+  TrieBitBuffer buffer;
+
+  buffer.WriteBit(0);
+  buffer.WriteBit(1);
+  buffer.WriteBit(0);
+  buffer.WriteBit(1);
+  buffer.WriteBit(0);
+  buffer.WriteBit(1);
+  buffer.WriteBit(0);
+  buffer.WriteBit(1);
+
+  BitWriter writer;
+  buffer.WriteToBitWriter(&writer);
+
+  EXPECT_EQ(8U, writer.position());
+  EXPECT_EQ(1U, writer.bytes().size());
+
+  buffer.WriteBit(0);
+  buffer.WriteBit(1);
+  buffer.WriteBit(0);
+
+  BitWriter writer2;
+  buffer.WriteToBitWriter(&writer2);
+  EXPECT_EQ(11U, writer2.position());
+  EXPECT_EQ(1U, writer2.bytes().size());
+
+  writer2.Flush();
+
+  EXPECT_EQ(2U, writer2.bytes().size());
+
+  // 0 | 1 | 0 | 1 | 0 | 1 | 0 | 1 = 0x55.
+  EXPECT_EQ(0x55, writer2.bytes()[0]);
+  // 0 | 1 | 0 | 00000 (padding) = 0x40.
+  EXPECT_EQ(0x40, writer2.bytes()[1]);
+}
+
+TEST(TrieBitBufferTest, WriteBits) {
+  TrieBitBuffer buffer;
+
+  buffer.WriteBits(170, 1);
+  buffer.WriteBits(170, 2);
+  buffer.WriteBits(170, 3);
+
+  BitWriter writer;
+  buffer.WriteToBitWriter(&writer);
+  EXPECT_EQ(6U, writer.position());
+  EXPECT_EQ(0U, writer.bytes().size());
+
+  buffer.WriteBits(170, 2);
+  buffer.WriteBits(170, 2);
+
+  BitWriter writer2;
+  buffer.WriteToBitWriter(&writer2);
+
+  EXPECT_EQ(10U, writer2.position());
+  EXPECT_EQ(1U, writer2.bytes().size());
+
+  BitWriter writer3;
+  buffer.WriteToBitWriter(&writer3);
+  EXPECT_EQ(10U, writer3.position());
+  EXPECT_EQ(1U, writer3.bytes().size());
+
+  writer3.Flush();
+
+  EXPECT_EQ(2U, writer3.bytes().size());
+
+  // 0 | 10 | 010 | 10 = 0x4A.
+  EXPECT_EQ(0x4A, writer3.bytes()[0]);
+
+  // 10 | 000000 (padding) = 0x80.
+  EXPECT_EQ(0x80, writer3.bytes()[1]);
+}
+
+TEST(TrieBitBufferTest, WritePosition) {
+  TrieBitBuffer buffer;
+  BitWriter writer;
+
+  buffer.WriteBit(1);
+  buffer.WriteBits(170, 6);
+
+  buffer.WriteToBitWriter(&writer);
+
+  TrieBitBuffer buffer2;
+  int32_t last_position = -1;
+  buffer2.WritePosition(4, &last_position);
+  EXPECT_EQ(4, last_position);
+
+  buffer2.WriteBits(170, 8);
+  buffer2.WritePosition(8, &last_position);
+  EXPECT_EQ(8, last_position);
+
+  buffer2.WriteToBitWriter(&writer);
+  writer.Flush();
+
+  EXPECT_EQ(4U, writer.bytes().size());
+
+  // The buffer should contain, in order:
+  // - the bit 1
+  // - the last 6 bits of '0xAA'
+  // - five bits representing '2'; the bit length of the following field
+  // - 2 bits representing '3' (the delta 7 - 4)
+  // - 8 bits representing 0xAA ('170')
+  // - A zero indicating the following 7 bits represent a delta
+  // - 7 bits representing 4 (the delta 8 - 4)
+  // - padding
+  //
+  // 1 | 101010 | 00010 | 11 | 10101010 | 0 | 0000100 | 00
+  EXPECT_THAT(writer.bytes(), testing::ElementsAre(0xD4, 0x2E, 0xA8, 0x10));
+}
+
+TEST(TrieBitBufferTest, WriteChar) {
+  TrieBitBuffer buffer;
+  HuffmanBuilder huffman_builder;
+  HuffmanRepresentationTable table;
+
+  table['a'] = HuffmanRepresentation();
+  table['a'].bits = 0x0A;
+  table['a'].number_of_bits = 4;
+
+  table['b'] = HuffmanRepresentation();
+  table['b'].bits = 0x0F;
+  table['b'].number_of_bits = 4;
+
+  EXPECT_TRUE(buffer.WriteChar('a', table, &huffman_builder));
+
+  HuffmanRepresentationTable encoding = huffman_builder.ToTable();
+
+  // 'a' should have an Huffman encoding.
+  EXPECT_NE(encoding.cend(), encoding.find('a'));
+
+  EXPECT_TRUE(buffer.WriteChar('a', table, &huffman_builder));
+  EXPECT_TRUE(buffer.WriteChar('b', table, &huffman_builder));
+  EXPECT_FALSE(buffer.WriteChar('c', table, &huffman_builder));
+
+  encoding = huffman_builder.ToTable();
+
+  // Both 'a' and 'b' should have an Huffman encoding.
+  EXPECT_NE(encoding.cend(), encoding.find('a'));
+  EXPECT_NE(encoding.cend(), encoding.find('b'));
+
+  BitWriter writer;
+  buffer.WriteToBitWriter(&writer);
+  writer.Flush();
+
+  // There should be 3 characters in the writer. 'a' twice followed by 'b' once.
+  // The characters are written as the representation in |table|.
+  ASSERT_EQ(2U, writer.bytes().size());
+  // Twice 'a'.
+  EXPECT_EQ(0xAA, writer.bytes()[0]);
+  // Once 'b' and padding.
+  EXPECT_EQ(0xF0, writer.bytes()[1]);
+}
+
+TEST(TrieBitBufferTest, WriteMix) {
+  TrieBitBuffer buffer;
+
+  HuffmanRepresentationTable table;
+  table['a'] = HuffmanRepresentation();
+  table['a'].bits = 0x0A;
+  table['a'].number_of_bits = 4;
+
+  buffer.WriteBits(170, 1);
+  buffer.WriteBit(1);
+
+  EXPECT_TRUE(buffer.WriteChar('a', table, nullptr));
+  EXPECT_FALSE(buffer.WriteChar('b', table, nullptr));
+
+  buffer.WriteBits(170, 2);
+  buffer.WriteBits(170, 3);
+
+  BitWriter writer;
+  buffer.WriteToBitWriter(&writer);
+
+  // 1 + 1 + 4 + 2 + 3 = 11.
+  EXPECT_EQ(writer.position(), 11U);
+  EXPECT_EQ(writer.bytes().size(), 1U);
+
+  TrieBitBuffer buffer2;
+  buffer2.WriteBit(1);
+  buffer2.WriteBits(170, 2);
+  buffer2.WriteBit(0);
+
+  buffer2.WriteToBitWriter(&writer);
+  EXPECT_EQ(writer.position(), 15U);
+  EXPECT_EQ(writer.bytes().size(), 1U);
+
+  writer.Flush();
+
+  EXPECT_EQ(writer.bytes().size(), 2U);
+
+  // 0 | 1 | 1010 | 10 | 010 | 1 | 10 | 0 = 0x6A58.
+  EXPECT_THAT(writer.bytes(), testing::ElementsAre(0x6A, 0x58));
+}
+
+}  // transport_security_state
+
+}  // namespace net