Source release v3.0.1 + third_party

2015-09-11 16:15:34 -07:00
parent 0546ee6732
commit b5d6be97cb
32 changed files with 1344 additions and 129 deletions
--- a/core/test/buffer_reader_test.cpp
+++ b/core/test/buffer_reader_test.cpp
@@ -0,0 +1,838 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+
+#include <string>
+#include <errno.h>
+#include <getopt.h>
+#include <gtest/gtest.h>
+
+#include "buffer_reader.h"
+
+namespace wvcdm {
+
+class BufferReaderTest : public testing::Test {
+ public:
+  template <typename T>
+  void WriteToBuffer(uint8_t* buffer, T v) {
+    for (size_t i = 0; i < sizeof(T); ++i) {
+      size_t insertAt = (sizeof(T) - i) - 1;  // reverse the order of i
+      size_t shiftAmount = 8 * i;
+
+      buffer[insertAt] = (uint8_t)((v >> shiftAmount) & 0xff);
+    }
+  }
+
+  // populate and validate data by cycling through the alphabet
+  // (lower case) so that it will work for strings and raw bytes
+
+  void PopulateData(uint8_t* dest, size_t byte_count) {
+    for (size_t i = 0; i < byte_count; i++) {
+      dest[i] = (uint8_t)(i % 26 + 'a');
+    }
+  }
+
+  bool ValidateData(const uint8_t* data, size_t byte_count) {
+    for (size_t i = 0; i < byte_count; i++) {
+      if (data[i] != (uint8_t)(i % 26 + 'a')) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  bool ValidateReader(const BufferReader& reader,
+                      const uint8_t* expectedAddress, size_t expectedSize,
+                      size_t expectedPosition) {
+    return reader.data() == expectedAddress && reader.size() == expectedSize &&
+           reader.pos() == expectedPosition;
+  }
+
+  bool CheckRead1(uint8_t input) {
+    uint8_t raw_data[sizeof(input)];
+    WriteToBuffer(raw_data, input);
+
+    BufferReader reader(raw_data, sizeof(raw_data));
+
+    uint8_t read;
+
+    return reader.Read1(&read) && input == read &&
+           ValidateReader(reader, raw_data, sizeof(raw_data), sizeof(input));
+  }
+
+  bool CheckRead2(uint16_t input) {
+    uint8_t raw_data[sizeof(input)];
+    WriteToBuffer(raw_data, input);
+
+    BufferReader reader(raw_data, sizeof(raw_data));
+
+    uint16_t read;
+
+    return reader.Read2(&read) && input == read &&
+           ValidateReader(reader, raw_data, sizeof(raw_data), sizeof(input));
+  }
+
+  bool CheckRead2s(int16_t input) {
+    uint8_t raw_data[sizeof(input)];
+    WriteToBuffer(raw_data, input);
+
+    BufferReader reader(raw_data, sizeof(raw_data));
+
+    int16_t read;
+
+    return reader.Read2s(&read) && input == read &&
+           ValidateReader(reader, raw_data, sizeof(raw_data), sizeof(input));
+  }
+
+  bool CheckRead4(uint32_t input) {
+    uint8_t raw_data[sizeof(input)];
+    WriteToBuffer(raw_data, input);
+
+    BufferReader reader(raw_data, sizeof(raw_data));
+
+    uint32_t read;
+
+    return reader.Read4(&read) && input == read &&
+           ValidateReader(reader, raw_data, sizeof(raw_data), sizeof(input));
+  }
+
+  bool CheckRead4s(int32_t input) {
+    uint8_t raw_data[sizeof(input)];
+    WriteToBuffer(raw_data, input);
+
+    BufferReader reader(raw_data, sizeof(raw_data));
+
+    int32_t read;
+
+    return reader.Read4s(&read) && input == read &&
+           ValidateReader(reader, raw_data, sizeof(raw_data), sizeof(input));
+  }
+
+  bool CheckRead8(uint64_t input) {
+    uint8_t raw_data[sizeof(input)];
+    WriteToBuffer(raw_data, input);
+
+    BufferReader reader(raw_data, sizeof(raw_data));
+
+    uint64_t read;
+
+    return reader.Read8(&read) && input == read &&
+           ValidateReader(reader, raw_data, sizeof(raw_data), sizeof(input));
+  }
+
+  bool CheckRead8s(int64_t input) {
+    uint8_t raw_data[sizeof(input)];
+    WriteToBuffer(raw_data, input);
+
+    BufferReader reader(raw_data, sizeof(raw_data));
+
+    int64_t read;
+
+    return reader.Read8s(&read) && input == read &&
+           ValidateReader(reader, raw_data, sizeof(raw_data), sizeof(input));
+  }
+
+  bool CheckRead4Into8(uint32_t input) {
+    uint8_t raw_data[sizeof(input)];
+    WriteToBuffer(raw_data, input);
+
+    BufferReader reader(raw_data, sizeof(raw_data));
+
+    uint64_t read;
+    return reader.Read4Into8(&read) && read == input &&
+           ValidateReader(reader, raw_data, sizeof(raw_data), sizeof(input));
+  }
+
+  bool CheckRead4sInto8s(int32_t input) {
+    uint8_t raw_data[sizeof(input)];
+    WriteToBuffer(raw_data, input);
+
+    BufferReader reader(raw_data, sizeof(raw_data));
+
+    int64_t read;
+    return reader.Read4sInto8s(&read) && read == input &&
+           ValidateReader(reader, raw_data, sizeof(raw_data), sizeof(input));
+  }
+};
+
+TEST_F(BufferReaderTest, InitializeGoodDataAndGoodSize) {
+  uint8_t raw_data[16];
+  PopulateData(raw_data, sizeof(raw_data));
+
+  BufferReader reader(raw_data, sizeof(raw_data));
+
+  ASSERT_TRUE(ValidateData(raw_data, sizeof(raw_data)));
+  ASSERT_TRUE(ValidateReader(reader, raw_data, sizeof(raw_data), 0));
+}
+
+TEST_F(BufferReaderTest, InitializeGoodDataAndNoSize) {
+  uint8_t raw_data[16];
+  PopulateData(raw_data, sizeof(raw_data));
+
+  BufferReader reader(raw_data, 0);
+
+  ASSERT_TRUE(ValidateData(raw_data, sizeof(raw_data)));
+  ASSERT_TRUE(ValidateReader(reader, raw_data, 0, 0));
+}
+
+TEST_F(BufferReaderTest, InitializeNoDataNoSize) {
+  BufferReader reader(NULL, 0);
+  ASSERT_TRUE(ValidateReader(reader, NULL, 0, 0));
+}
+
+TEST_F(BufferReaderTest, InitializeNoDataBadSize) {
+  BufferReader reader(NULL, 16);
+
+  // Buffer reader should default to a size of 0 when given
+  // NULL data to ensure no reading of bad data
+  ASSERT_TRUE(ValidateReader(reader, NULL, 0, 0));
+}
+
+TEST_F(BufferReaderTest, HasBytesWithBytes) {
+  uint8_t raw_data[16];
+  PopulateData(raw_data, sizeof(raw_data));
+
+  BufferReader reader(raw_data, sizeof(raw_data));
+
+  // the reader should have enough bytes from 0 to the size of the buffer
+  for (size_t i = 0; i <= sizeof(raw_data); i++) {
+    ASSERT_TRUE(reader.HasBytes(i));
+  }
+
+  ASSERT_FALSE(reader.HasBytes(sizeof(raw_data) + 1));
+
+  ASSERT_TRUE(ValidateData(raw_data, sizeof(raw_data)));
+  ASSERT_TRUE(ValidateReader(reader, raw_data, sizeof(raw_data), 0));
+}
+
+TEST_F(BufferReaderTest, HasBytesWithEmptyBuffer) {
+  uint8_t raw_data[16];
+  PopulateData(raw_data, sizeof(raw_data));
+
+  BufferReader reader(raw_data, 0);
+
+  ASSERT_FALSE(reader.HasBytes(1));
+  ASSERT_TRUE(reader.HasBytes(0));
+
+  ASSERT_TRUE(ValidateData(raw_data, sizeof(raw_data)));
+  ASSERT_TRUE(ValidateReader(reader, raw_data, 0, 0));
+}
+
+TEST_F(BufferReaderTest, HasBytesWithNullBuffer) {
+  BufferReader reader(NULL, 8);
+
+  ASSERT_FALSE(reader.HasBytes(1));
+  ASSERT_TRUE(reader.HasBytes(0));
+
+  ASSERT_TRUE(ValidateReader(reader, NULL, 0, 0));
+}
+
+TEST_F(BufferReaderTest, HasBytesAfterAllRead) {
+  uint8_t raw_data[16];
+  PopulateData(raw_data, sizeof(raw_data));
+
+  BufferReader reader(raw_data, sizeof(raw_data));
+
+  for (size_t i = 0; i < sizeof(raw_data); i++) {
+    uint8_t read;
+    ASSERT_TRUE(reader.Read1(&read));
+  }
+
+  ASSERT_FALSE(reader.HasBytes(1));
+  ASSERT_TRUE(reader.HasBytes(0));
+
+  ASSERT_TRUE(ValidateData(raw_data, sizeof(raw_data)));
+  ASSERT_TRUE(
+      ValidateReader(reader, raw_data, sizeof(raw_data), sizeof(raw_data)));
+}
+
+TEST_F(BufferReaderTest, Read1LargeNumber) { ASSERT_TRUE(CheckRead1(0xFF)); }
+
+TEST_F(BufferReaderTest, Read1SmallNumber) { ASSERT_TRUE(CheckRead1(0x0F)); }
+
+TEST_F(BufferReaderTest, Read1Zero) { ASSERT_TRUE(CheckRead1(0)); }
+
+TEST_F(BufferReaderTest, Read1WithNoData) {
+  uint8_t raw_data[16];
+  PopulateData(raw_data, sizeof(raw_data));
+
+  BufferReader reader(raw_data, 0);
+
+  uint8_t read;
+  ASSERT_FALSE(reader.Read1(&read));
+
+  ASSERT_TRUE(ValidateData(raw_data, sizeof(raw_data)));
+  ASSERT_TRUE(ValidateReader(reader, raw_data, 0, 0));
+}
+
+TEST_F(BufferReaderTest, Read1WithNullBuffer) {
+  BufferReader reader(NULL, 16);
+
+  uint8_t read;
+  ASSERT_FALSE(reader.Read1(&read));
+
+  ASSERT_TRUE(ValidateReader(reader, NULL, 0, 0));
+}
+
+TEST_F(BufferReaderTest, Read1WithNullReturn) {
+  uint8_t raw_data[16];
+  PopulateData(raw_data, sizeof(raw_data));
+
+  BufferReader reader(raw_data, sizeof(raw_data));
+
+  ASSERT_FALSE(reader.Read1(NULL));
+
+  ASSERT_TRUE(ValidateData(raw_data, sizeof(raw_data)));
+  ASSERT_TRUE(ValidateReader(reader, raw_data, sizeof(raw_data), 0));
+}
+
+TEST_F(BufferReaderTest, Read2LargeNumber) { ASSERT_TRUE(CheckRead2(30000)); }
+
+TEST_F(BufferReaderTest, Read2SmallNumber) { ASSERT_TRUE(CheckRead2(10)); }
+
+TEST_F(BufferReaderTest, Read2Zero) { ASSERT_TRUE(CheckRead2(0)); }
+
+TEST_F(BufferReaderTest, Read2WithNoData) {
+  uint8_t raw_data[16];
+  PopulateData(raw_data, sizeof(raw_data));
+
+  BufferReader reader(raw_data, 0);
+
+  uint16_t read;
+  ASSERT_FALSE(reader.Read2(&read));
+
+  ASSERT_TRUE(ValidateData(raw_data, sizeof(raw_data)));
+  ASSERT_TRUE(ValidateReader(reader, raw_data, 0, 0));
+}
+
+TEST_F(BufferReaderTest, Read2WithNullBuffer) {
+  BufferReader reader(NULL, 16);
+
+  uint16_t read;
+  ASSERT_FALSE(reader.Read2(&read));
+
+  ASSERT_TRUE(ValidateReader(reader, NULL, 0, 0));
+}
+
+TEST_F(BufferReaderTest, Read2WithNullReturn) {
+  uint8_t raw_data[16];
+  PopulateData(raw_data, sizeof(raw_data));
+
+  BufferReader reader(raw_data, sizeof(raw_data));
+
+  ASSERT_FALSE(reader.Read2(NULL));
+
+  ASSERT_TRUE(ValidateData(raw_data, sizeof(raw_data)));
+  ASSERT_TRUE(ValidateReader(reader, raw_data, sizeof(raw_data), 0));
+}
+
+TEST_F(BufferReaderTest, Read2sLargePositive) {
+  ASSERT_TRUE(CheckRead2s(30000));
+}
+
+TEST_F(BufferReaderTest, Read2sSmallPositive) { ASSERT_TRUE(CheckRead2s(10)); }
+
+TEST_F(BufferReaderTest, Read2sZero) { ASSERT_TRUE(CheckRead2s(0)); }
+
+TEST_F(BufferReaderTest, Read2sSmallNegative) { ASSERT_TRUE(CheckRead2s(-10)); }
+
+TEST_F(BufferReaderTest, Read2sLargeNegative) {
+  ASSERT_TRUE(CheckRead2s(-30000));
+}
+
+TEST_F(BufferReaderTest, Read2sWithNoData) {
+  uint8_t raw_data[16];
+  PopulateData(raw_data, sizeof(raw_data));
+
+  BufferReader reader(raw_data, 0);
+
+  int16_t read;
+  ASSERT_FALSE(reader.Read2s(&read));
+
+  ASSERT_TRUE(ValidateData(raw_data, sizeof(raw_data)));
+  ASSERT_TRUE(ValidateReader(reader, raw_data, 0, 0));
+}
+
+TEST_F(BufferReaderTest, Read2sWithNullBuffer) {
+  BufferReader reader(NULL, 16);
+
+  int16_t read;
+  ASSERT_FALSE(reader.Read2s(&read));
+
+  ASSERT_TRUE(ValidateReader(reader, NULL, 0, 0));
+}
+
+TEST_F(BufferReaderTest, Read2sWithNullReturn) {
+  uint8_t raw_data[16];
+  PopulateData(raw_data, sizeof(raw_data));
+
+  BufferReader reader(raw_data, sizeof(raw_data));
+
+  ASSERT_FALSE(reader.Read2s(NULL));
+
+  ASSERT_TRUE(ValidateData(raw_data, sizeof(raw_data)));
+  ASSERT_TRUE(ValidateReader(reader, raw_data, sizeof(raw_data), 0));
+}
+
+TEST_F(BufferReaderTest, Read4LargeNumber) {
+  // a number near uint32's max value
+  ASSERT_TRUE(CheckRead4(2000000000));
+}
+
+TEST_F(BufferReaderTest, Read4SmallNumber) { ASSERT_TRUE(CheckRead4(10)); }
+
+TEST_F(BufferReaderTest, Read4Zero) { ASSERT_TRUE(CheckRead4(0)); }
+
+TEST_F(BufferReaderTest, Read4WithNoData) {
+  uint8_t raw_data[16];
+  PopulateData(raw_data, sizeof(raw_data));
+
+  BufferReader reader(raw_data, 0);
+
+  uint32_t read;
+  ASSERT_FALSE(reader.Read4(&read));
+
+  ASSERT_TRUE(ValidateData(raw_data, sizeof(raw_data)));
+  ASSERT_TRUE(ValidateReader(reader, raw_data, 0, 0));
+}
+
+TEST_F(BufferReaderTest, Read4WithNullBuffer) {
+  BufferReader reader(NULL, 16);
+
+  uint32_t read;
+  ASSERT_FALSE(reader.Read4(&read));
+
+  ASSERT_TRUE(ValidateReader(reader, NULL, 0, 0));
+}
+
+TEST_F(BufferReaderTest, Read4WithNullReturn) {
+  uint8_t raw_data[16];
+  PopulateData(raw_data, sizeof(raw_data));
+
+  BufferReader reader(raw_data, sizeof(raw_data));
+
+  ASSERT_FALSE(reader.Read4(NULL));
+
+  ASSERT_TRUE(ValidateData(raw_data, sizeof(raw_data)));
+  ASSERT_TRUE(ValidateReader(reader, raw_data, sizeof(raw_data), 0));
+}
+
+TEST_F(BufferReaderTest, Read4sLargePositive) {
+  // a number near int32's max value
+  ASSERT_TRUE(CheckRead4s(2000000000));
+}
+
+TEST_F(BufferReaderTest, Read4sSmallPositive) { ASSERT_TRUE(CheckRead4s(10)); }
+
+TEST_F(BufferReaderTest, Read4sZero) { ASSERT_TRUE(CheckRead4s(0)); }
+
+TEST_F(BufferReaderTest, Read4sSmallNegative) { ASSERT_TRUE(CheckRead4s(-10)); }
+
+TEST_F(BufferReaderTest, Read4sLargeNegative) {
+  // a number near int32's max negative value
+  ASSERT_TRUE(CheckRead4s(-2000000000));
+}
+
+TEST_F(BufferReaderTest, Read4sWithNoData) {
+  uint8_t raw_data[16];
+  PopulateData(raw_data, sizeof(raw_data));
+
+  BufferReader reader(raw_data, 0);
+
+  int32_t read;
+  ASSERT_FALSE(reader.Read4s(&read));
+
+  ASSERT_TRUE(ValidateData(raw_data, sizeof(raw_data)));
+  ASSERT_TRUE(ValidateReader(reader, raw_data, 0, 0));
+}
+
+TEST_F(BufferReaderTest, Read4sWithNullBuffer) {
+  BufferReader reader(NULL, 16);
+
+  int32_t read;
+  ASSERT_FALSE(reader.Read4s(&read));
+
+  ASSERT_TRUE(ValidateReader(reader, NULL, 0, 0));
+}
+
+TEST_F(BufferReaderTest, Read4sWithNullReturn) {
+  uint8_t raw_data[16];
+  PopulateData(raw_data, sizeof(raw_data));
+
+  BufferReader reader(raw_data, sizeof(raw_data));
+
+  ASSERT_FALSE(reader.Read4s(NULL));
+
+  ASSERT_TRUE(ValidateData(raw_data, sizeof(raw_data)));
+  ASSERT_TRUE(ValidateReader(reader, raw_data, sizeof(raw_data), 0));
+}
+
+TEST_F(BufferReaderTest, Read8LargeNumber) {
+  // a number near uint64's max value
+  ASSERT_TRUE(CheckRead8(9000000000000000000));
+}
+
+TEST_F(BufferReaderTest, Read8SmallNumber) { ASSERT_TRUE(CheckRead8(10)); }
+
+TEST_F(BufferReaderTest, Read8Zero) { ASSERT_TRUE(CheckRead8(0)); }
+
+TEST_F(BufferReaderTest, Read8WithNoData) {
+  uint8_t raw_data[16];
+  PopulateData(raw_data, sizeof(raw_data));
+
+  BufferReader reader(raw_data, 0);
+
+  uint64_t read;
+  ASSERT_FALSE(reader.Read8(&read));
+
+  ASSERT_TRUE(ValidateData(raw_data, sizeof(raw_data)));
+  ASSERT_TRUE(ValidateReader(reader, raw_data, 0, 0));
+}
+
+TEST_F(BufferReaderTest, Read8WithNullBuffer) {
+  BufferReader reader(NULL, 16);
+
+  uint64_t read;
+  ASSERT_FALSE(reader.Read8(&read));
+
+  ASSERT_TRUE(ValidateReader(reader, NULL, 0, 0));
+}
+
+TEST_F(BufferReaderTest, Read8WithNullReturn) {
+  uint8_t raw_data[16];
+  PopulateData(raw_data, sizeof(raw_data));
+
+  BufferReader reader(raw_data, sizeof(raw_data));
+
+  ASSERT_FALSE(reader.Read8(NULL));
+
+  ASSERT_TRUE(ValidateData(raw_data, sizeof(raw_data)));
+  ASSERT_TRUE(ValidateReader(reader, raw_data, sizeof(raw_data), 0));
+}
+
+TEST_F(BufferReaderTest, Read8sLargePositive) {
+  // a number near int64's max value
+  ASSERT_TRUE(CheckRead8s(9000000000000000000));
+}
+
+TEST_F(BufferReaderTest, Read8sSmallPositive) { ASSERT_TRUE(CheckRead8s(10)); }
+
+TEST_F(BufferReaderTest, Read8sZero) { ASSERT_TRUE(CheckRead8s(0)); }
+
+TEST_F(BufferReaderTest, Read8sSmallNegative) { ASSERT_TRUE(CheckRead8s(-10)); }
+
+TEST_F(BufferReaderTest, Read8sLargeNegative) {
+  // a number near int64's max negative value
+  ASSERT_TRUE(CheckRead8s(-9000000000000000000));
+}
+
+TEST_F(BufferReaderTest, Read8sWithNoData) {
+  uint8_t raw_data[16];
+  PopulateData(raw_data, sizeof(raw_data));
+
+  BufferReader reader(raw_data, 0);
+
+  int64_t read;
+  ASSERT_FALSE(reader.Read8s(&read));
+
+  ASSERT_TRUE(ValidateData(raw_data, sizeof(raw_data)));
+  ASSERT_TRUE(ValidateReader(reader, raw_data, 0, 0));
+}
+
+TEST_F(BufferReaderTest, Read8sWithNullBuffer) {
+  BufferReader reader(NULL, 16);
+
+  int64_t read;
+  ASSERT_FALSE(reader.Read8s(&read));
+
+  ASSERT_TRUE(ValidateReader(reader, NULL, 0, 0));
+}
+
+TEST_F(BufferReaderTest, Read8sWithNullReturn) {
+  uint8_t raw_data[16];
+  PopulateData(raw_data, sizeof(raw_data));
+
+  BufferReader reader(raw_data, sizeof(raw_data));
+
+  ASSERT_FALSE(reader.Read8s(NULL));
+
+  ASSERT_TRUE(ValidateData(raw_data, sizeof(raw_data)));
+  ASSERT_TRUE(ValidateReader(reader, raw_data, sizeof(raw_data), 0));
+}
+
+TEST_F(BufferReaderTest, ReadString) {
+  uint8_t raw_data[5];
+  PopulateData(raw_data, sizeof(raw_data));
+
+  BufferReader reader(raw_data, sizeof(raw_data));
+
+  std::string read;
+  ASSERT_TRUE(reader.ReadString(&read, sizeof(raw_data)));
+
+  ASSERT_TRUE(ValidateData(raw_data, sizeof(raw_data)));
+  ASSERT_TRUE(read.length() == sizeof(raw_data));
+  ASSERT_TRUE(ValidateData((const uint8_t*)read.c_str(), read.length()));
+
+  ASSERT_TRUE(
+      ValidateReader(reader, raw_data, sizeof(raw_data), sizeof(raw_data)));
+}
+
+TEST_F(BufferReaderTest, ReadStringNullSource) {
+  BufferReader reader(NULL, 5);
+
+  std::string read;
+  ASSERT_FALSE(reader.ReadString(&read, 5));
+
+  ASSERT_TRUE(ValidateReader(reader, NULL, 0, 0));
+}
+
+TEST_F(BufferReaderTest, ReadStringNullReturn) {
+  uint8_t raw_data[16];
+  PopulateData(raw_data, sizeof(raw_data));
+
+  BufferReader reader(raw_data, sizeof(raw_data));
+
+  ASSERT_FALSE(reader.ReadString(NULL, 5));
+
+  ASSERT_TRUE(ValidateData(raw_data, sizeof(raw_data)));
+  ASSERT_TRUE(ValidateReader(reader, raw_data, sizeof(raw_data), 0));
+}
+
+TEST_F(BufferReaderTest, ReadStringZeroCount) {
+  uint8_t raw_data[16];
+  PopulateData(raw_data, sizeof(raw_data));
+
+  BufferReader reader(raw_data, sizeof(raw_data));
+
+  std::string read;
+  ASSERT_TRUE(reader.ReadString(&read, 0));
+
+  ASSERT_TRUE(0 == read.length());
+  ASSERT_TRUE(ValidateData(raw_data, sizeof(raw_data)));
+  ASSERT_TRUE(ValidateReader(reader, raw_data, sizeof(raw_data), 0));
+}
+
+TEST_F(BufferReaderTest, ReadStringTooLarge) {
+  uint8_t raw_data[16];
+  PopulateData(raw_data, sizeof(raw_data));
+
+  BufferReader reader(raw_data, sizeof(raw_data));
+
+  std::string read;
+  ASSERT_FALSE(reader.ReadString(&read, sizeof(raw_data) * 2));
+
+  ASSERT_TRUE(0 == read.length());
+  ASSERT_TRUE(ValidateData(raw_data, sizeof(raw_data)));
+  ASSERT_TRUE(ValidateReader(reader, raw_data, sizeof(raw_data), 0));
+}
+
+TEST_F(BufferReaderTest, ReadVector) {
+  uint8_t raw_data[16];
+  PopulateData(raw_data, sizeof(raw_data));
+
+  BufferReader reader(raw_data, sizeof(raw_data));
+
+  std::vector<uint8_t> read;
+
+  ASSERT_TRUE(reader.ReadVec(&read, 4));
+
+  ASSERT_TRUE(read.size() == 4);
+
+  for (size_t i = 0; i < 4; i++) {
+    ASSERT_TRUE(raw_data[i] == read[i]);
+  }
+
+  ASSERT_TRUE(ValidateData(raw_data, sizeof(raw_data)));
+  ASSERT_TRUE(ValidateReader(reader, raw_data, sizeof(raw_data), 4));
+}
+
+TEST_F(BufferReaderTest, ReadVectorTooLarge) {
+  uint8_t raw_data[16];
+  PopulateData(raw_data, sizeof(raw_data));
+
+  BufferReader reader(raw_data, sizeof(raw_data));
+
+  std::vector<uint8_t> read;
+
+  ASSERT_FALSE(reader.ReadVec(&read, sizeof(raw_data) * 2));
+
+  ASSERT_TRUE(0 == read.size());
+  ASSERT_TRUE(ValidateData(raw_data, sizeof(raw_data)));
+  ASSERT_TRUE(ValidateReader(reader, raw_data, sizeof(raw_data), 0));
+}
+
+TEST_F(BufferReaderTest, ReadVectorNullSource) {
+  BufferReader reader(NULL, 16);
+
+  std::vector<uint8_t> read;
+  ASSERT_FALSE(reader.ReadVec(&read, 4));
+
+  ASSERT_TRUE(0 == read.size());
+  ASSERT_TRUE(ValidateReader(reader, NULL, 0, 0));
+}
+
+TEST_F(BufferReaderTest, ReadVectorNullReturn) {
+  uint8_t raw_data[16];
+  PopulateData(raw_data, sizeof(raw_data));
+
+  BufferReader reader(raw_data, sizeof(raw_data));
+
+  ASSERT_FALSE(reader.ReadVec(NULL, 4));
+
+  ASSERT_TRUE(ValidateData(raw_data, sizeof(raw_data)));
+  ASSERT_TRUE(ValidateReader(reader, raw_data, sizeof(raw_data), 0));
+}
+
+TEST_F(BufferReaderTest, ReadVectorNone) {
+  uint8_t raw_data[16];
+  PopulateData(raw_data, sizeof(raw_data));
+
+  BufferReader reader(raw_data, sizeof(raw_data));
+
+  std::vector<uint8_t> read;
+  ASSERT_TRUE(reader.ReadVec(&read, 0));
+
+  ASSERT_TRUE(0 == read.size());
+  ASSERT_TRUE(ValidateData(raw_data, sizeof(raw_data)));
+  ASSERT_TRUE(ValidateReader(reader, raw_data, sizeof(raw_data), 0));
+}
+
+TEST_F(BufferReaderTest, Read4Into84Bytes) {
+  ASSERT_TRUE(CheckRead4Into8(0xFFFFFF));
+}
+
+TEST_F(BufferReaderTest, Read4Into83Bytes) {
+  ASSERT_TRUE(CheckRead4Into8(0xFFFF));
+}
+
+TEST_F(BufferReaderTest, Read4Into82Bytes) {
+  ASSERT_TRUE(CheckRead4Into8(0xFF));
+}
+
+TEST_F(BufferReaderTest, Read4Into8Zero) { ASSERT_TRUE(CheckRead4Into8(0)); }
+
+TEST_F(BufferReaderTest, Read4Into8NullSource) {
+  BufferReader reader(NULL, 4);
+
+  uint64_t read;
+  ASSERT_FALSE(reader.Read4Into8(&read));
+
+  ASSERT_TRUE(ValidateReader(reader, NULL, 0, 0));
+}
+
+TEST_F(BufferReaderTest, Read4Into8TooLittleData) {
+  uint8_t raw_data[2];
+  PopulateData(raw_data, sizeof(raw_data));
+
+  BufferReader reader(raw_data, sizeof(raw_data));
+
+  uint64_t read;
+  ASSERT_FALSE(reader.Read4Into8(&read));
+
+  ASSERT_TRUE(ValidateData(raw_data, sizeof(raw_data)));
+  ASSERT_TRUE(ValidateReader(reader, raw_data, sizeof(raw_data), 0));
+}
+
+TEST_F(BufferReaderTest, Read4Into8NoReturn) {
+  uint8_t raw_data[16];
+  PopulateData(raw_data, sizeof(raw_data));
+
+  BufferReader reader(raw_data, sizeof(raw_data));
+
+  ASSERT_FALSE(reader.Read4Into8(NULL));
+
+  ASSERT_TRUE(ValidateData(raw_data, sizeof(raw_data)));
+  ASSERT_TRUE(ValidateReader(reader, raw_data, sizeof(raw_data), 0));
+}
+
+TEST_F(BufferReaderTest, Read4sInto8s4Bytes) {
+  ASSERT_TRUE(CheckRead4sInto8s(0x0FFFFFFF));
+}
+
+TEST_F(BufferReaderTest, Read4sInto8s3Bytes) {
+  ASSERT_TRUE(CheckRead4sInto8s(0xFFFFFF));
+}
+
+TEST_F(BufferReaderTest, Read4sInto8s2Bytes) {
+  ASSERT_TRUE(CheckRead4sInto8s(0xFFFF));
+}
+
+TEST_F(BufferReaderTest, Read4sInto8s1Bytes) {
+  ASSERT_TRUE(CheckRead4sInto8s(0xFF));
+}
+
+TEST_F(BufferReaderTest, Read4sInto8sZero) {
+  ASSERT_TRUE(CheckRead4sInto8s(0));
+}
+
+TEST_F(BufferReaderTest, Read4sInto8sNegative) {
+  ASSERT_TRUE(CheckRead4sInto8s(-100));
+}
+
+TEST_F(BufferReaderTest, Read4sInto8sNullSource) {
+  BufferReader reader(NULL, 4);
+
+  int64_t read;
+  ASSERT_FALSE(reader.Read4sInto8s(&read));
+
+  ASSERT_TRUE(ValidateReader(reader, NULL, 0, 0));
+}
+
+TEST_F(BufferReaderTest, Read4sInto8sTooLittleData) {
+  uint8_t raw_data[2];
+  PopulateData(raw_data, sizeof(raw_data));
+
+  BufferReader reader(raw_data, sizeof(raw_data));
+
+  int64_t read;
+  ASSERT_FALSE(reader.Read4sInto8s(&read));
+
+  ASSERT_TRUE(ValidateData(raw_data, sizeof(raw_data)));
+  ASSERT_TRUE(ValidateReader(reader, raw_data, sizeof(raw_data), 0));
+}
+
+TEST_F(BufferReaderTest, Read4sInto8sNoReturn) {
+  uint8_t raw_data[16];
+  PopulateData(raw_data, sizeof(raw_data));
+
+  BufferReader reader(raw_data, sizeof(raw_data));
+
+  ASSERT_FALSE(reader.Read4sInto8s(NULL));
+
+  ASSERT_TRUE(ValidateData(raw_data, sizeof(raw_data)));
+  ASSERT_TRUE(ValidateReader(reader, raw_data, sizeof(raw_data), 0));
+}
+
+TEST_F(BufferReaderTest, SkipBytesNone) {
+  uint8_t raw_data[16];
+  PopulateData(raw_data, sizeof(raw_data));
+
+  BufferReader reader(raw_data, sizeof(raw_data));
+
+  ASSERT_TRUE(reader.SkipBytes(0));
+  ASSERT_TRUE(ValidateData(raw_data, sizeof(raw_data)));
+  ASSERT_TRUE(ValidateReader(reader, raw_data, sizeof(raw_data), 0));
+}
+
+TEST_F(BufferReaderTest, SkipBytes) {
+  uint8_t raw_data[16];
+  PopulateData(raw_data, sizeof(raw_data));
+
+  BufferReader reader(raw_data, sizeof(raw_data));
+
+  ASSERT_TRUE(reader.SkipBytes(4));
+  ASSERT_TRUE(ValidateData(raw_data, sizeof(raw_data)));
+  ASSERT_TRUE(ValidateReader(reader, raw_data, sizeof(raw_data), 4));
+}
+
+TEST_F(BufferReaderTest, SkipBytesTooLarge) {
+  uint8_t raw_data[16];
+  PopulateData(raw_data, sizeof(raw_data));
+
+  BufferReader reader(raw_data, sizeof(raw_data));
+
+  ASSERT_FALSE(reader.SkipBytes(sizeof(raw_data) * 2));
+
+  ASSERT_TRUE(ValidateData(raw_data, sizeof(raw_data)));
+  ASSERT_TRUE(ValidateReader(reader, raw_data, sizeof(raw_data), 0));
+}
+}  // namespace
--- a/core/test/cdm_engine_test.cpp
+++ b/core/test/cdm_engine_test.cpp
@@ -13,6 +13,7 @@
 #include "initialization_data.h"
 #include "license_request.h"
 #include "log.h"
+#include "OEMCryptoCENC.h"
 #include "properties.h"
 #include "scoped_ptr.h"
 #include "string_conversions.h"
@@ -43,7 +44,7 @@ const std::string kWebmMimeType = "video/webm";
 class WvCdmEngineTest : public testing::Test {
 public:
  static void SetUpTestCase() {
-    ConfigTestEnv config(kContentProtectionServer);
+    ConfigTestEnv config(kContentProtectionUatServer);
    g_client_auth.assign(config.client_auth());
    g_key_system.assign(config.key_system());
    g_wrong_key_id.assign(config.wrong_key_id());
@@ -178,6 +179,18 @@ class WvCdmEngineTest : public testing::Test {

 // Test that provisioning works, even if device is already provisioned.
 TEST_F(WvCdmEngineTest, ProvisioningTest) {
+  uint32_t nonce = 0;
+  uint8_t buffer[1];
+  size_t size = 0;
+  int result = OEMCrypto_RewrapDeviceRSAKey(
+      0, buffer, 0, buffer, 0, &nonce, buffer, 0, buffer, buffer, &size);
+  if (result == OEMCrypto_ERROR_NOT_IMPLEMENTED) {
+    LOGW("WARNING: Skipping ProvisioningTest because the device does not "
+         "support provisioning. If you are using a baked-in certificate, this "
+         "is expected. Otherwise, something is wrong.");
+    return;
+  }
+
  Provision();
 }

--- a/core/test/config_test_env.cpp
+++ b/core/test/config_test_env.cpp
@@ -9,8 +9,8 @@ namespace {
 const std::string kWidevineKeySystem = "com.widevine.alpha";

 // Content Protection license server (UAT) data
-// For staging server replace url with http://wv-staging-proxy.appspot.com/proxy
-const std::string kCpLicenseServer = "http://widevine-proxy.appspot.com/proxy";
+const std::string kCpUatLicenseServer =
+    "http://widevine-proxy.appspot.com/proxy";
 const std::string kCpClientAuth = "";
 const std::string kCpKeyId =
    "00000042"                          // blob size
@@ -31,6 +31,52 @@ const std::string kCpOfflineKeyId =
    // pssh data:
    "08011a0d7769646576696e655f746573"
    "74220d6f66666c696e655f636c697032";
+const std::string kCpUatServiceCertificate =
+    "0ABF020803121028703454C008F63618ADE7443DB6C4C8188BE7F99005228E023082010A02"
+    "82010100B52112B8D05D023FCC5D95E2C251C1C649B4177CD8D2BEEF355BB06743DE661E3D"
+    "2ABC3182B79946D55FDC08DFE95407815E9A6274B322A2C7F5E067BB5F0AC07A89D45AEA94"
+    "B2516F075B66EF811D0D26E1B9A6B894F2B9857962AA171C4F66630D3E4C602718897F5E1E"
+    "F9B6AAF5AD4DBA2A7E14176DF134A1D3185B5A218AC05A4C41F081EFFF80A3A040C50B09BB"
+    "C740EEDCD8F14D675A91980F92CA7DDC646A06ADAD5101F74A0E498CC01F00532BAC217850"
+    "BD905E90923656B7DFEFEF42486767F33EF6283D4F4254AB72589390BEE55808F1D668080D"
+    "45D893C2BCA2F74D60A0C0D0A0993CEF01604703334C3638139486BC9DAF24FD67A07F9AD9"
+    "4302030100013A1273746167696E672E676F6F676C652E636F6D128003983E30352675F40B"
+    "A715FC249BDAE5D4AC7249A2666521E43655739529721FF880E0AAEFC5E27BC980DAEADABF"
+    "3FC386D084A02C82537848CC753FF497B011A7DA97788A00E2AA6B84CD7D71C07A48EBF616"
+    "02CCA5A3F32030A7295C30DA915B91DC18B9BC9593B8DE8BB50F0DEDC12938B8E9E039CDDE"
+    "18FA82E81BB032630FE955D85A566CE154300BF6D4C1BD126966356B287D657B18CE63D0EF"
+    "D45FC5269E97EAB11CB563E55643B26FF49F109C2101AFCAF35B832F288F0D9D45960E259E"
+    "85FB5D24DBD2CF82764C5DD9BF727EFBE9C861F869321F6ADE18905F4D92F9A6DA6536DB84"
+    "75871D168E870BB2303CF70C6E9784C93D2DE845AD8262BE7E0D4E2E4A0759CEF82D109D25"
+    "92C72429F8C01742BAE2B3DECADBC33C3E5F4BAF5E16ECB74EADBAFCB7C6705F7A9E3B6F39"
+    "40383F9C5116D202A20C9229EE969C2519718303B50D0130C3352E06B014D838540F8A0C22"
+    "7C0011E0F5B38E4E298ED2CB301EB4564965F55C5D79757A250A4EB9C84AB3E6539F6B6FDF"
+    "56899EA29914";
+
+// Content Protection license server (staging) data
+const std::string kCpStagingLicenseServer =
+    "http://wv-staging-proxy.appspot.com/proxy";
+const std::string kCpStagingServiceCertificate =
+    "0AC102080312101705B917CC1204868B06333A2F772A8C1882B4829205228E023082010A02"
+    "8201010099ED5B3B327DAB5E24EFC3B62A95B598520AD5BCCB37503E0645B814D876B8DF40"
+    "510441AD8CE3ADB11BB88C4E725A5E4A9E0795291D58584023A7E1AF0E38A9127939300861"
+    "0B6F158C878C7E21BFFBFEEA77E1019E1E5781E8A45F46263D14E60E8058A8607ADCE04FAC"
+    "8457B137A8D67CCDEB33705D983A21FB4EECBD4A10CA47490CA47EAA5D438218DDBAF1CADE"
+    "3392F13D6FFB6442FD31E1BF40B0C604D1C4BA4C9520A4BF97EEBD60929AFCEEF55BBAF564"
+    "E2D0E76CD7C55C73A082B996120B8359EDCE24707082680D6F67C6D82C4AC5F3134490A74E"
+    "EC37AF4B2F010C59E82843E2582F0B6B9F5DB0FC5E6EDF64FBD308B4711BCF1250019C9F5A"
+    "0902030100013A146C6963656E73652E7769646576696E652E636F6D128003AE347314B5A8"
+    "35297F271388FB7BB8CB5277D249823CDDD1DA30B93339511EB3CCBDEA04B944B927C12134"
+    "6EFDBDEAC9D413917E6EC176A10438460A503BC1952B9BA4E4CE0FC4BFC20A9808AAAF4BFC"
+    "D19C1DCFCDF574CCAC28D1B410416CF9DE8804301CBDB334CAFCD0D40978423A642E54613D"
+    "F0AFCF96CA4A9249D855E42B3A703EF1767F6A9BD36D6BF82BE76BBF0CBA4FDE59D2ABCC76"
+    "FEB64247B85C431FBCA52266B619FC36979543FCA9CBBDBBFAFA0E1A55E755A3C7BCE655F9"
+    "646F582AB9CF70AA08B979F867F63A0B2B7FDB362C5BC4ECD555D85BCAA9C593C383C857D4"
+    "9DAAB77E40B7851DDFD24998808E35B258E75D78EAC0CA16F7047304C20D93EDE4E8FF1C6F"
+    "17E6243E3F3DA8FC1709870EC45FBA823A263F0CEFA1F7093B1909928326333705043A29BD"
+    "A6F9B4342CC8DF543CB1A1182F7C5FFF33F10490FACA5B25360B76015E9C5A06AB8EE02F00"
+    "D2E8D5986104AACC4DD475FD96EE9CE4E326F21B83C7058577B38732CDDABC6A6BED13FB0D"
+    "49D38A45EB87A5F4";

 // Google Play license server data
 const std::string kGpLicenseServer =
@@ -78,9 +124,11 @@ const std::string kProductionProvisioningServerUrl =

 const ConfigTestEnv::LicenseServerConfiguration license_servers[] = {
    {kGooglePlayServer, kGpLicenseServer, kGpClientAuth, kGpKeyId,
-     kGpOfflineKeyId},
-    {kContentProtectionServer, kCpLicenseServer, kCpClientAuth, kCpKeyId,
-     kCpOfflineKeyId},
+     kGpOfflineKeyId, ""},
+    {kContentProtectionUatServer, kCpUatLicenseServer, kCpClientAuth,
+     kCpKeyId, kCpOfflineKeyId, kCpUatServiceCertificate},
+    {kContentProtectionStagingServer, kCpStagingLicenseServer,
+     kCpClientAuth, kCpKeyId, kCpOfflineKeyId, kCpStagingServiceCertificate},
 };

 }  // namespace
@@ -116,6 +164,7 @@ void ConfigTestEnv::Init(LicenseServerId server_id) {
  key_system_ = kWidevineKeySystem;
  license_server_ = license_servers[server_id].url;
  provisioning_server_url_ = kProductionProvisioningServerUrl;
+  service_certificate_ = license_servers[server_id].service_certificate;
  wrong_key_id_ = kWrongKeyId;
 }

--- a/core/test/config_test_env.h
+++ b/core/test/config_test_env.h
@@ -9,7 +9,8 @@
 namespace wvcdm {
 typedef enum {
  kGooglePlayServer,
-  kContentProtectionServer,
+  kContentProtectionUatServer,
+  kContentProtectionStagingServer,
 } LicenseServerId;

 // Configures default test environment.
@@ -21,13 +22,14 @@ class ConfigTestEnv {
    std::string client_tag;
    std::string key_id;
    std::string offline_key_id;
+    std::string service_certificate;
  } LicenseServerConfiguration;

  explicit ConfigTestEnv(LicenseServerId server_id);
  ConfigTestEnv(LicenseServerId server_id, bool streaming);
  ConfigTestEnv(LicenseServerId server_id, bool streaming, bool renew,
                bool release);
-  ~ConfigTestEnv() {};
+  ~ConfigTestEnv(){};

  const std::string& client_auth() const { return client_auth_; }
  const KeyId& key_id() const { return key_id_; }
@@ -36,6 +38,9 @@ class ConfigTestEnv {
  const std::string& provisioning_server_url() const {
    return provisioning_server_url_;
  }
+  const std::string& service_certificate() const {
+    return service_certificate_;
+  }
  const KeyId& wrong_key_id() const { return wrong_key_id_; }

  void set_key_id(KeyId& key_id) { key_id_.assign(key_id); }
@@ -54,6 +59,7 @@ class ConfigTestEnv {
  CdmKeySystem key_system_;
  std::string license_server_;
  std::string provisioning_server_url_;
+  std::string service_certificate_;
  KeyId wrong_key_id_;

  CORE_DISALLOW_COPY_AND_ASSIGN(ConfigTestEnv);
--- a/core/test/http_socket.cpp
+++ b/core/test/http_socket.cpp
@@ -105,7 +105,7 @@ bool SocketWait(int fd, bool for_read, int timeout_in_ms) {
 // static
 bool HttpSocket::ParseUrl(const std::string& url, std::string* scheme,
                          bool* secure_connect, std::string* domain_name,
-                          int* port, std::string* path) {
+                          std::string* port, std::string* path) {
  size_t offset = 0;

  if (!Tokenize(url, "://", offset, scheme, &offset)) {
@@ -117,10 +117,10 @@ bool HttpSocket::ParseUrl(const std::string& url, std::string* scheme,
  // Otherwise, consider the scheme unsupported and fail.
  if (*scheme == "http") {
    *secure_connect = false;
-    *port = 80;
+    port->assign("80");
  } else if (*scheme == "https") {
    *secure_connect = true;
-    *port = 443;
+    port->assign("443");
  } else {
    LOGE("Invalid URL, scheme not supported: %s", url.c_str());
    return false;
@@ -140,8 +140,9 @@ bool HttpSocket::ParseUrl(const std::string& url, std::string* scheme,
  std::string domain_name_without_port;
  size_t port_offset;
  if (Tokenize(*domain_name, ":", 0, &domain_name_without_port, &port_offset)) {
-    *port = atoi(domain_name->c_str() + port_offset);
-    if (*port <= 0 || *port >= 65536) {
+    port->assign(domain_name->c_str() + port_offset);
+    int port_num = atoi(port->c_str());
+    if (port_num <= 0 || port_num >= 65536) {
      LOGE("Invalid URL, port not valid: %s", url.c_str());
      return false;
    }
@@ -180,8 +181,24 @@ bool HttpSocket::Connect(int timeout_in_ms) {
    return false;
  }

+  // lookup the server IP
+  struct addrinfo hints;
+  memset(&hints, 0, sizeof(hints));
+  hints.ai_family = AF_UNSPEC;
+  hints.ai_socktype = SOCK_STREAM;
+  hints.ai_flags = AI_NUMERICSERV | AI_ADDRCONFIG;
+
+  struct addrinfo* addr_info = NULL;
+  int ret = getaddrinfo(domain_name_.c_str(), port_.c_str(), &hints,
+                        &addr_info);
+  if (ret != 0) {
+    LOGE("getaddrinfo failed, errno = %d", ret);
+    return false;
+  }
+
  // get a socket
-  socket_fd_ = socket(AF_INET, SOCK_STREAM, 0);
+  socket_fd_ = socket(addr_info->ai_family, addr_info->ai_socktype,
+                      addr_info->ai_protocol);
  if (socket_fd_ < 0) {
    LOGE("cannot open socket, errno = %d", errno);
    return false;
@@ -200,24 +217,6 @@ bool HttpSocket::Connect(int timeout_in_ms) {
    return false;
  }

-  // lookup the server IP
-  struct addrinfo hints;
-  memset(&hints, 0, sizeof(hints));
-  hints.ai_family = AF_INET;
-  hints.ai_socktype = SOCK_STREAM;
-
-  struct addrinfo* addr_info = NULL;
-  int ret = getaddrinfo(domain_name_.c_str(), NULL, &hints, &addr_info);
-  if (ret != 0) {
-    LOGE("getaddrinfo failed, errno = %d", ret);
-    return false;
-  }
-
-  // set the port
-  struct sockaddr_in* addr_ipv4 =
-      reinterpret_cast<struct sockaddr_in*>(addr_info->ai_addr);
-  addr_ipv4->sin_port = htons(port_);
-
  // connect to the server
  ret = connect(socket_fd_, addr_info->ai_addr, addr_info->ai_addrlen);
  freeaddrinfo(addr_info);
--- a/core/test/http_socket.h
+++ b/core/test/http_socket.h
@@ -3,6 +3,8 @@
 #ifndef CDM_TEST_HTTP_SOCKET_H_
 #define CDM_TEST_HTTP_SOCKET_H_

+#include <stdlib.h>
+
 #include <string>

 #include <gtest/gtest_prod.h>
@@ -25,7 +27,7 @@ class HttpSocket {
  const std::string& scheme() const { return scheme_; }
  bool secure_connect() const { return secure_connect_; }
  const std::string& domain_name() const { return domain_name_; }
-  int port() const { return port_; }
+  int port() const { return atoi(port_.c_str()); }
  const std::string& resource_path() const { return resource_path_; }

  int Read(char* data, int len, int timeout_in_ms);
@@ -34,13 +36,13 @@ class HttpSocket {
 private:
  static bool ParseUrl(const std::string& url, std::string* scheme,
                       bool* secure_connect, std::string* domain_name,
-                       int* port, std::string* path);
+                       std::string* port, std::string* path);
  FRIEND_TEST(HttpSocketTest, ParseUrlTest);

  std::string scheme_;
  bool secure_connect_;
  std::string domain_name_;
-  int port_;
+  std::string port_;
  std::string resource_path_;
  bool valid_url_;

--- a/core/test/http_socket_test.cpp
+++ b/core/test/http_socket_test.cpp
@@ -98,7 +98,7 @@ struct ParseUrlTests {
  const char* scheme;
  bool secure_connect;
  const char* domain_name;
-  int port;
+  const char* port;
  const char* path;
 };

@@ -108,7 +108,7 @@ ParseUrlTests parse_url_tests[] = {
     "https",                                             // scheme
     true,                                                // secure_connect
     "code.google.com",                                   // domain_name
-     443,                                                 // port
+     "443",                                               // port
     "/p/googletest/wiki/Primer",                         // path
    },
    {
@@ -116,7 +116,7 @@ ParseUrlTests parse_url_tests[] = {
     "http",                                              // scheme
     false,                                               // secure_connect
     "code.google.com",                                   // domain_name
-     80,                                                  // port
+     "80",                                                // port
     "/p/googletest/wiki/Primer/",                        // path
    },
    {
@@ -124,7 +124,7 @@ ParseUrlTests parse_url_tests[] = {
     "http",                     // scheme
     false,                      // secure_connect
     "code.google.com",          // domain_name
-     80,                         // port
+     "80",                       // port
     "/",                        // path
    },
    {
@@ -132,7 +132,7 @@ ParseUrlTests parse_url_tests[] = {
     "http",                    // scheme
     false,                     // secure_connect
     "code.google.com",         // domain_name
-     80,                        // port
+     "80",                      // port
     "/",                       // path
    },
    {
@@ -140,7 +140,7 @@ ParseUrlTests parse_url_tests[] = {
     "http",                         // scheme
     false,                          // secure_connect
     "10.11.12.13",                  // domain_name
-     8888,                           // port
+     "8888",                         // port
     "/drm",                         // path
    },
    {
@@ -148,7 +148,7 @@ ParseUrlTests parse_url_tests[] = {
     "http",                     // scheme
     false,                      // secure_connect
     "10.11.12.13",              // domain_name
-     8888,                       // port
+     "8888",                     // port
     "/",                        // path
    },
    {
@@ -156,7 +156,7 @@ ParseUrlTests parse_url_tests[] = {
     "https",                     // scheme
     true,                        // secure_connect
     "10.11.12.13",               // domain_name
-     8888,                        // port
+     "8888",                      // port
     "/",                         // path
    },
    {NULL, NULL, false, NULL, 0, NULL}  // list terminator
@@ -166,7 +166,7 @@ TEST_F(HttpSocketTest, ParseUrlTest) {
  std::string scheme;
  bool secure_connect;
  std::string domain_name;
-  int port;
+  std::string port;
  std::string path;
  ParseUrlTests* test = NULL;

--- a/core/test/test_printers.cpp
+++ b/core/test/test_printers.cpp
@@ -100,7 +100,7 @@ void PrintTo(const enum CdmResponseType& value, ::std::ostream* os) {
      break;
    case EMPTY_LICENSE_RESPONSE_2: *os             << "EMPTY_LICENSE_RESPONSE_2";
      break;
-    case EMPTY_PROVISIONING_CERTIFICATE: *os       << "EMPTY_PROVISIONING_CERTIFICATE";
+    case EMPTY_PROVISIONING_CERTIFICATE_1: *os     << "EMPTY_PROVISIONING_CERTIFICATE_1";
      break;
    case EMPTY_PROVISIONING_RESPONSE: *os          << "EMPTY_PROVISIONING_RESPONSE";
      break;
@@ -337,6 +337,7 @@ void PrintTo(const enum CdmResponseType& value, ::std::ostream* os) {
      break;
    case EMPTY_LICENSE_REQUEST: *os                << "EMPTY_LICENSE_REQUEST";
      break;
+    case DUPLICATE_SESSION_ID_SPECIFIED: *os       << "DUPLICATE_SESSION_ID_SPECIFIED";
    default:
      *os                                          << "Unknown CdmResponseType";
      break;