Add functions for DER parsing a BIT STRING.

net/der/parse_values_unittest.cc

 // Copyright 2015 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 <stdint.h>
 
 #include "base/macros.h"
 #include "net/der/parse_values.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 177 matching lines @@
     SCOPED_TRACE(i);
 
     uint64_t result;
     EXPECT_EQ(test_case.should_pass,
               ParseUint64(Input(test_case.input, test_case.length), &result));
     if (test_case.should_pass)
       EXPECT_EQ(test_case.expected_value, result);
   }
 }
 
+// Tests parsing an empty BIT STRING.
+TEST(ParseValuesTest, ParseBitString_Empty_NoUnusedBits) {

[nharper, 2015/07/21 23:23:47]

Test names shouldn't contain underscores (according to
https://code.google.com/p/googletest/wiki/FAQ#Why_should_not_test_case_names_...,
although I noticed that there are several tests in //net that has underscores in
their names.)

[eroman, 2015/07/22 17:05:23]

Ah, thanks for pointing this out! (I was not aware of that)

Removed all the underscores.

+  const uint8_t kData[] = {0x00};
+
+  Input bytes;
+  uint8_t unused_bits;
+  ASSERT_TRUE(ParseBitString(Input(kData), &bytes, &unused_bits));
+
+  EXPECT_EQ(0u, unused_bits);
+  EXPECT_EQ(0u, bytes.Length());
+}
+
+// Tests parsing an empty BIT STRING that incorrectly claims one unused bit.
+TEST(ParseValuesTest, ParseBitString_Empty_OneUnusedBit) {
+  const uint8_t kData[] = {0x01};
+
+  Input bytes;
+  uint8_t unused_bits;
+  ASSERT_FALSE(ParseBitString(Input(kData), &bytes, &unused_bits));

[nharper, 2015/07/21 23:23:47]

I generally prefer the EXPECT_* macros to ASSERT_* where feasible to allow the
test to continue running. I guess it doesn't really matter when it's the last
line of a test case though.

[eroman, 2015/07/22 17:05:23]

Done.

These are the result of copy-paste from success test cases.
(For which if ParseBitString were to fail, I don't want to proceed as the unused
bit length could be invalid memory).

+}
+
+// Tests parsing an empty BIT STRING that is not minmally encoded (the entire
+// last byte is comprised of unused bits).
+TEST(ParseValuesTest, ParseBitString_NonEmpty_TooManyUnusedBits) {
+  const uint8_t kData[] = {0x08, 0x00};
+
+  Input bytes;
+  uint8_t unused_bits;
+  ASSERT_FALSE(ParseBitString(Input(kData), &bytes, &unused_bits));
+}
+
+// Tests parsing a BIT STRING of 7 bits each of which are 1.
+TEST(ParseValuesTest, ParseBitString_SevenOneBits) {
+  const uint8_t kData[] = {0x01, 0xFE};
+
+  Input bytes;
+  uint8_t unused_bits;
+  ASSERT_TRUE(ParseBitString(Input(kData), &bytes, &unused_bits));
+
+  EXPECT_EQ(1u, unused_bits);
+  EXPECT_EQ(1u, bytes.Length());
+  EXPECT_EQ(0xFE, bytes.UnsafeData()[0]);
+}
+
+// Tests parsing a BIT STRING of 7 bits each of which are 1. The unused bit
+// however is set to 1, which is an invalid encoding.
+TEST(ParseValuesTest, ParseBitString_SevenOneBits_UnusedBitIsOne) {
+  const uint8_t kData[] = {0x01, 0xFF};
+
+  Input bytes;
+  uint8_t unused_bits;
+  ASSERT_FALSE(ParseBitString(Input(kData), &bytes, &unused_bits));
+}
+
 }  // namespace test
 }  // namespace der
 }  // namespace net