Add transport security state generator tests.

net/tools/transport_security_state_generator/bit_writer_unittest.cc

Index: net/tools/transport_security_state_generator/bit_writer_unittest.cc
diff --git a/net/tools/transport_security_state_generator/bit_writer_unittest.cc b/net/tools/transport_security_state_generator/bit_writer_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e5ee473cb46f401613fcaaecf965553e02674dee
--- /dev/null
+++ b/net/tools/transport_security_state_generator/bit_writer_unittest.cc
@@ -0,0 +1,151 @@
+// 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/bit_writer.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace net {
+
+namespace transport_security_state {
+
+// Test that single bits are written to the buffer correctly.
+TEST(BitWriterTest, WriteBit) {
+  BitWriter writer;
+
+  EXPECT_EQ(0U, writer.position());
+  EXPECT_EQ(0U, writer.bytes().size());
+
+  writer.WriteBit(0);
+
+  EXPECT_EQ(1U, writer.position());
+  EXPECT_EQ(0U, writer.bytes().size());
+
+  writer.WriteBit(1);
+  writer.WriteBit(0);
+  writer.WriteBit(1);
+  writer.WriteBit(0);
+  writer.WriteBit(1);
+  writer.WriteBit(0);
+  writer.WriteBit(1);
+
+  EXPECT_EQ(8U, writer.position());
+  EXPECT_EQ(1U, writer.bytes().size());
+
+  // 0 | 1 | 0 | 1 | 0 | 1 | 0 | 1 = 0x55.
+  EXPECT_EQ(0x55, writer.bytes()[0]);
+
+  writer.WriteBit(0);
+
+  EXPECT_EQ(9U, writer.position());
+  EXPECT_EQ(1U, writer.bytes().size());
+
+  writer.WriteBit(1);
+  writer.WriteBit(0);
+
+  EXPECT_EQ(11U, writer.position());
+  EXPECT_EQ(1U, writer.bytes().size());
+
+  // Flush should pad the current byte with zero's until it's full.
+  writer.Flush();
+
+  // The writer should have 2 bytes now even though we only wrote 11 bits.
+  EXPECT_EQ(16U, writer.position());
+  EXPECT_EQ(2U, writer.bytes().size());
+
+  // 0 | 1 | 0  | 00000 (padding) = 0x40.
+  EXPECT_EQ(0x40, writer.bytes()[1]);
+}
+
+// Test that when multiple bits are written to the buffer, they are appended
+// correctly.
+TEST(BitWriterTest, WriteBits) {
+  BitWriter writer;
+
+  writer.WriteBits(170, 1);
+
+  EXPECT_EQ(1U, writer.position());
+  EXPECT_EQ(0U, writer.bytes().size());
+
+  writer.WriteBits(170, 2);
+
+  EXPECT_EQ(3U, writer.position());
+  EXPECT_EQ(0U, writer.bytes().size());
+
+  writer.WriteBits(170, 3);
+
+  EXPECT_EQ(6U, writer.position());
+  EXPECT_EQ(0U, writer.bytes().size());
+
+  writer.WriteBits(170, 2);
+
+  EXPECT_EQ(8U, writer.position());
+  EXPECT_EQ(1U, writer.bytes().size());
+
+  // 0 | 10 | 010 | 10 = 0x4A.
+  EXPECT_EQ(0x4A, writer.bytes()[0]);
+
+  writer.WriteBits(170, 2);
+
+  EXPECT_EQ(10U, writer.position());
+  EXPECT_EQ(1U, writer.bytes().size());
+
+  // Flush should pad the current byte with zero's until it's full.
+  writer.Flush();
+
+  // The writer should have 2 bytes now even though we only wrote 10 bits.
+  EXPECT_EQ(16U, writer.position());
+  EXPECT_EQ(2U, writer.bytes().size());
+
+  // 10 | 000000 (padding) = 0x80
+  EXPECT_EQ(0x80, writer.bytes()[1]);
+}
+
+// Test that buffering works correct when the methods are mixed.
+TEST(BitWriterTest, WriteBoth) {
+  BitWriter writer;
+
+  writer.WriteBits(170, 1);
+
+  EXPECT_EQ(1U, writer.position());
+  EXPECT_EQ(0U, writer.bytes().size());
+
+  writer.WriteBit(1);
+  writer.WriteBits(170, 2);
+
+  EXPECT_EQ(4U, writer.position());
+  EXPECT_EQ(0U, writer.bytes().size());
+
+  writer.WriteBits(170, 3);
+
+  EXPECT_EQ(7U, writer.position());
+  EXPECT_EQ(0U, writer.bytes().size());
+
+  writer.WriteBit(1);
+
+  EXPECT_EQ(8U, writer.position());
+  EXPECT_EQ(1U, writer.bytes().size());
+
+  // 0 | 1 | 10 | 010 | 1 = 0x65
+  EXPECT_EQ(0x65, writer.bytes()[0]);
+
+  writer.WriteBits(170, 2);
+  writer.WriteBit(0);
+
+  EXPECT_EQ(11U, writer.position());
+  EXPECT_EQ(1U, writer.bytes().size());
+
+  // Flush should pad the current byte with zero's until it's full.
+  writer.Flush();
+
+  // The writer should have 2 bytes now even though we only wrote 10 bits.
+  EXPECT_EQ(16U, writer.position());
+  EXPECT_EQ(2U, writer.bytes().size());
+
+  // 10 | 0 | 00000 (padding) = 0x80
+  EXPECT_EQ(0x80, writer.bytes()[1]);
+}
+
+}  // transport_security_state
+
+}  // namespace net