diff --git a/libwvdrmengine/build_and_run_all_unit_tests.sh b/libwvdrmengine/build_and_run_all_unit_tests.sh
index 9fdd61de..4f905c3f 100755
--- a/libwvdrmengine/build_and_run_all_unit_tests.sh
+++ b/libwvdrmengine/build_and_run_all_unit_tests.sh
@@ -68,6 +68,7 @@ adb push $OUT/system/bin/initialization_data_unittest /system/bin
 adb push $OUT/system/bin/device_files_unittest /system/bin
 adb push $OUT/system/bin/timer_unittest /system/bin
 adb push $OUT/system/bin/libwvdrmengine_test /system/bin
+adb push $OUT/system/bin/buffer_reader_test /system/bin
 adb install -r $OUT/system/app/MediaDrmAPITest/MediaDrmAPITest.apk
 
 cd $ANDROID_BUILD_TOP/vendor/widevine/libwvdrmengine
diff --git a/libwvdrmengine/cdm/core/include/buffer_reader.h b/libwvdrmengine/cdm/core/include/buffer_reader.h
index f098a977..9211a56c 100644
--- a/libwvdrmengine/cdm/core/include/buffer_reader.h
+++ b/libwvdrmengine/cdm/core/include/buffer_reader.h
@@ -24,9 +24,9 @@ namespace wvcdm {
 class BufferReader {
  public:
   BufferReader(const uint8_t* buf, size_t size)
-      : buf_(buf), size_(size), pos_(0) {}
+      : buf_(buf), size_(buf != NULL ? size : 0), pos_(0) {}
 
-  bool HasBytes(int count) { return (pos() + count <= size()); }
+  bool HasBytes(size_t count) { return (pos() + count <= size()); }
 
   // Read a value from the stream, performing endian correction,
   // and advance the stream pointer.
@@ -38,8 +38,8 @@ class BufferReader {
   bool Read8(uint64_t* v) WARN_UNUSED_RESULT;
   bool Read8s(int64_t* v) WARN_UNUSED_RESULT;
 
-  bool ReadString(std::string* str, int count) WARN_UNUSED_RESULT;
-  bool ReadVec(std::vector<uint8_t>* t, int count) WARN_UNUSED_RESULT;
+  bool ReadString(std::string* str, size_t count) WARN_UNUSED_RESULT;
+  bool ReadVec(std::vector<uint8_t>* t, size_t count) WARN_UNUSED_RESULT;
 
   // These variants read a 4-byte integer of the corresponding signedness and
   // store it in the 8-byte return type.
@@ -47,7 +47,7 @@ class BufferReader {
   bool Read4sInto8s(int64_t* v) WARN_UNUSED_RESULT;
 
   // Advance the stream by this many bytes.
-  bool SkipBytes(int nbytes) WARN_UNUSED_RESULT;
+  bool SkipBytes(size_t nbytes) WARN_UNUSED_RESULT;
 
   const uint8_t* data() const { return buf_; }
   size_t size() const { return size_; }
diff --git a/libwvdrmengine/cdm/core/src/buffer_reader.cpp b/libwvdrmengine/cdm/core/src/buffer_reader.cpp
index 83771881..feb5c062 100644
--- a/libwvdrmengine/cdm/core/src/buffer_reader.cpp
+++ b/libwvdrmengine/cdm/core/src/buffer_reader.cpp
@@ -7,8 +7,15 @@
 namespace wvcdm {
 
 bool BufferReader::Read1(uint8_t* v) {
+  if (v == NULL) {
+    LOGE("BufferReader::Read1 : Failure during parse: Null output parameter "
+         "when expecting non-null");
+    return false;
+  }
+
   if (!HasBytes(1)) {
-    LOGW("BufferReader::Read1 : Failure while parsing: Not enough bytes (1)");
+    LOGV("BufferReader::Read1 : Failure while parsing: "
+         "Not enough bytes (1)");
     return false;
   }
 
@@ -19,9 +26,15 @@ bool BufferReader::Read1(uint8_t* v) {
 // Internal implementation of multi-byte reads
 template <typename T>
 bool BufferReader::Read(T* v) {
+  if (v == NULL) {
+    LOGE("BufferReader::Read<T> : Failure during parse: Null output parameter "
+         "when expecting non-null (%s)", __PRETTY_FUNCTION__);
+    return false;
+  }
+
   if (!HasBytes(sizeof(T))) {
-    LOGW("BufferReader::Read<T> : Failure during parse: Not enough bytes (%u)",
-         sizeof(T));
+    LOGV("BufferReader::Read<T> : Failure during parse: "
+         "Not enough bytes (%u)", sizeof(T));
     return false;
   }
 
@@ -41,10 +54,16 @@ bool BufferReader::Read4s(int32_t* v) { return Read(v); }
 bool BufferReader::Read8(uint64_t* v) { return Read(v); }
 bool BufferReader::Read8s(int64_t* v) { return Read(v); }
 
-bool BufferReader::ReadString(std::string* str, int count) {
+bool BufferReader::ReadString(std::string* str, size_t count) {
+  if (str == NULL) {
+    LOGE("BufferReader::ReadString : Failure during parse: Null output "
+         "parameter when expecting non-null");
+    return false;
+  }
+
   if (!HasBytes(count)) {
-    LOGW("BufferReader::ReadString : Parse Failure: Not enough bytes (%d)",
-         count);
+    LOGV("BufferReader::ReadString : Parse Failure: "
+         "Not enough bytes (%d)", count);
     return false;
   }
 
@@ -53,9 +72,16 @@ bool BufferReader::ReadString(std::string* str, int count) {
   return true;
 }
 
-bool BufferReader::ReadVec(std::vector<uint8_t>* vec, int count) {
+bool BufferReader::ReadVec(std::vector<uint8_t>* vec, size_t count) {
+  if (vec == NULL) {
+    LOGE("BufferReader::ReadVec : Failure during parse: Null output parameter "
+         "when expecting non-null");
+    return false;
+  }
+
   if (!HasBytes(count)) {
-    LOGW("BufferReader::ReadVec : Parse Failure: Not enough bytes (%d)", count);
+    LOGV("BufferReader::ReadVec : Parse Failure: "
+         "Not enough bytes (%d)", count);
     return false;
   }
 
@@ -65,10 +91,10 @@ bool BufferReader::ReadVec(std::vector<uint8_t>* vec, int count) {
   return true;
 }
 
-bool BufferReader::SkipBytes(int bytes) {
+bool BufferReader::SkipBytes(size_t bytes) {
   if (!HasBytes(bytes)) {
-    LOGW("BufferReader::SkipBytes : Parse Failure: Not enough bytes (%d)",
-         bytes);
+    LOGV("BufferReader::SkipBytes : Parse Failure: "
+         "Not enough bytes (%d)", bytes);
     return false;
   }
 
@@ -77,6 +103,12 @@ bool BufferReader::SkipBytes(int bytes) {
 }
 
 bool BufferReader::Read4Into8(uint64_t* v) {
+  if (v == NULL) {
+    LOGE("BufferReader::Read4Into8 : Failure during parse: Null output "
+         "parameter when expecting non-null");
+    return false;
+  }
+
   uint32_t tmp;
   if (!Read4(&tmp)) {
     return false;
@@ -86,6 +118,12 @@ bool BufferReader::Read4Into8(uint64_t* v) {
 }
 
 bool BufferReader::Read4sInto8s(int64_t* v) {
+  if (v == NULL) {
+    LOGE("BufferReader::Read4sInto8s : Failure during parse: Null output "
+         "parameter when expecting non-null");
+    return false;
+  }
+
   // Beware of the need for sign extension.
   int32_t tmp;
   if (!Read4s(&tmp)) {
@@ -94,5 +132,4 @@ bool BufferReader::Read4sInto8s(int64_t* v) {
   *v = tmp;
   return true;
 }
-
 }  // namespace wvcdm
diff --git a/libwvdrmengine/cdm/core/src/device_files.cpp b/libwvdrmengine/cdm/core/src/device_files.cpp
index b1d88b9f..46cad569 100644
--- a/libwvdrmengine/cdm/core/src/device_files.cpp
+++ b/libwvdrmengine/cdm/core/src/device_files.cpp
@@ -16,6 +16,8 @@
 #include <CommonCrypto/CommonDigest.h>
 #define SHA256 CC_SHA256
 #define SHA256_DIGEST_LENGTH CC_SHA256_DIGEST_LENGTH
+#define MD5 CC_MD5
+#define MD5_DIGEST_LENGTH CC_MD5_DIGEST_LENGTH
 #else
 #include <openssl/sha.h>
 #include <openssl/md5.h>
diff --git a/libwvdrmengine/cdm/core/src/initialization_data.cpp b/libwvdrmengine/cdm/core/src/initialization_data.cpp
index 379b10d6..1c6c1a6e 100644
--- a/libwvdrmengine/cdm/core/src/initialization_data.cpp
+++ b/libwvdrmengine/cdm/core/src/initialization_data.cpp
@@ -61,18 +61,18 @@ bool InitializationData::ExtractWidevinePssh(const CdmInitData& init_data,
     // atom size, used for skipping.
     uint64_t size;
     if (!reader.Read4Into8(&size)) {
-      LOGW("CdmEngine::ExtractWidevinePssh: Unable to read atom size.");
+      LOGV("CdmEngine::ExtractWidevinePssh: Unable to read atom size.");
       return false;
     }
     std::vector<uint8_t> atom_type;
     if (!reader.ReadVec(&atom_type, 4)) {
-      LOGW("CdmEngine::ExtractWidevinePssh: Unable to read atom type.");
+      LOGV("CdmEngine::ExtractWidevinePssh: Unable to read atom type.");
       return false;
     }
 
     if (size == 1) {
       if (!reader.Read8(&size)) {
-        LOGW("CdmEngine::ExtractWidevinePssh: Unable to read 64-bit atom "
+        LOGV("CdmEngine::ExtractWidevinePssh: Unable to read 64-bit atom "
              "size.");
         return false;
       }
@@ -82,10 +82,10 @@ bool InitializationData::ExtractWidevinePssh(const CdmInitData& init_data,
 
     // "pssh"
     if (memcmp(&atom_type[0], "pssh", 4)) {
-      LOGW("CdmEngine::ExtractWidevinePssh: PSSH literal not present.");
+      LOGV("CdmEngine::ExtractWidevinePssh: PSSH literal not present.");
       if (!reader.SkipBytes(size - (reader.pos() - start_pos))) {
-        LOGW("CdmEngine::ExtractWidevinePssh: Unable to skip the rest of the "
-             "atom.");
+        LOGV("CdmEngine::ExtractWidevinePssh: Unable to skip the rest of "
+             "the atom.");
         return false;
       }
       continue;
@@ -94,15 +94,15 @@ bool InitializationData::ExtractWidevinePssh(const CdmInitData& init_data,
     // version
     uint8_t version;
     if (!reader.Read1(&version)) {
-      LOGW("CdmEngine::ExtractWidevinePssh: Unable to read PSSH version.");
+      LOGV("CdmEngine::ExtractWidevinePssh: Unable to read PSSH version.");
       return false;
     }
 
     if (version > 1) {
       // unrecognized version - skip.
       if (!reader.SkipBytes(size - (reader.pos() - start_pos))) {
-        LOGW("CdmEngine::ExtractWidevinePssh: Unable to skip the rest of the "
-             "atom.");
+        LOGV("CdmEngine::ExtractWidevinePssh: Unable to skip the rest of "
+             "the atom.");
         return false;
       }
       continue;
@@ -110,22 +110,22 @@ bool InitializationData::ExtractWidevinePssh(const CdmInitData& init_data,
 
     // flags
     if (!reader.SkipBytes(3)) {
-      LOGW("CdmEngine::ExtractWidevinePssh: Unable to skip the PSSH flags.");
+      LOGV("CdmEngine::ExtractWidevinePssh: Unable to skip the PSSH flags.");
       return false;
     }
 
     // system id
     std::vector<uint8_t> system_id;
     if (!reader.ReadVec(&system_id, sizeof(kWidevineSystemId))) {
-      LOGW("CdmEngine::ExtractWidevinePssh: Unable to read system ID.");
+      LOGV("CdmEngine::ExtractWidevinePssh: Unable to read system ID.");
       return false;
     }
 
     if (memcmp(&system_id[0], kWidevineSystemId, sizeof(kWidevineSystemId))) {
       // skip non-Widevine PSSH boxes.
       if (!reader.SkipBytes(size - (reader.pos() - start_pos))) {
-        LOGW("CdmEngine::ExtractWidevinePssh: Unable to skip the rest of the "
-             "atom.");
+        LOGV("CdmEngine::ExtractWidevinePssh: Unable to skip the rest of "
+             "the atom.");
         return false;
       }
       continue;
@@ -135,11 +135,11 @@ bool InitializationData::ExtractWidevinePssh(const CdmInitData& init_data,
       // v1 has additional fields for key IDs.  We can skip them.
       uint32_t num_key_ids;
       if (!reader.Read4(&num_key_ids)) {
-        LOGW("CdmEngine::ExtractWidevinePssh: Unable to read num key IDs.");
+        LOGV("CdmEngine::ExtractWidevinePssh: Unable to read num key IDs.");
         return false;
       }
       if (!reader.SkipBytes(num_key_ids * 16)) {
-        LOGW("CdmEngine::ExtractWidevinePssh: Unable to skip key IDs.");
+        LOGV("CdmEngine::ExtractWidevinePssh: Unable to skip key IDs.");
         return false;
       }
     }
@@ -147,13 +147,13 @@ bool InitializationData::ExtractWidevinePssh(const CdmInitData& init_data,
     // size of PSSH data
     uint32_t data_length;
     if (!reader.Read4(&data_length)) {
-      LOGW("CdmEngine::ExtractWidevinePssh: Unable to read PSSH data size.");
+      LOGV("CdmEngine::ExtractWidevinePssh: Unable to read PSSH data size.");
       return false;
     }
 
     output->clear();
     if (!reader.ReadString(output, data_length)) {
-      LOGW("CdmEngine::ExtractWidevinePssh: Unable to read PSSH data.");
+      LOGV("CdmEngine::ExtractWidevinePssh: Unable to read PSSH data.");
       return false;
     }
 
diff --git a/libwvdrmengine/cdm/core/test/buffer_reader_test.cpp b/libwvdrmengine/cdm/core/test/buffer_reader_test.cpp
new file mode 100644
index 00000000..4d727d07
--- /dev/null
+++ b/libwvdrmengine/cdm/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
diff --git a/libwvdrmengine/cdm/core/test/http_socket.cpp b/libwvdrmengine/cdm/core/test/http_socket.cpp
index 1926d012..f06ef484 100644
--- a/libwvdrmengine/cdm/core/test/http_socket.cpp
+++ b/libwvdrmengine/cdm/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);
diff --git a/libwvdrmengine/cdm/core/test/http_socket.h b/libwvdrmengine/cdm/core/test/http_socket.h
index 8775f0e0..eed0e50d 100644
--- a/libwvdrmengine/cdm/core/test/http_socket.h
+++ b/libwvdrmengine/cdm/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_;
 
diff --git a/libwvdrmengine/cdm/core/test/http_socket_test.cpp b/libwvdrmengine/cdm/core/test/http_socket_test.cpp
index 516b2076..06e3d966 100644
--- a/libwvdrmengine/cdm/core/test/http_socket_test.cpp
+++ b/libwvdrmengine/cdm/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;
 
@@ -205,6 +205,7 @@ TEST_F(HttpSocketTest, RoundTripTest) {
 
 int main(int argc, char** argv) {
   using namespace wvcdm;
+
   ::testing::InitGoogleTest(&argc, argv);
 
   std::string temp;
diff --git a/libwvdrmengine/cdm/src/log.cpp b/libwvdrmengine/cdm/src/log.cpp
index bc631d93..5ddb1824 100644
--- a/libwvdrmengine/cdm/src/log.cpp
+++ b/libwvdrmengine/cdm/src/log.cpp
@@ -22,6 +22,13 @@
 #include "log.h"
 #include <utils/Log.h>
 
+/*
+ * Uncomment the line below if you want to have the LOGV messages to print
+ * IMPORTANT : this will affect all of CDM
+ */
+
+// #define LOG_NDEBUG 0
+
 namespace wvcdm {
 
 LogPriority g_cutoff = LOG_VERBOSE;
diff --git a/libwvdrmengine/cdm/test/Android.mk b/libwvdrmengine/cdm/test/Android.mk
index 6eacdf1e..b952f46d 100644
--- a/libwvdrmengine/cdm/test/Android.mk
+++ b/libwvdrmengine/cdm/test/Android.mk
@@ -7,6 +7,10 @@ test_name := base64_test
 test_src_dir := ../core/test
 include $(LOCAL_PATH)/unit-test.mk
 
+test_name := buffer_reader_test
+test_src_dir := ../core/test
+include $(LOCAL_PATH)/unit-test.mk
+
 test_name := cdm_engine_test
 test_src_dir := ../core/test
 include $(LOCAL_PATH)/unit-test.mk
diff --git a/libwvdrmengine/run_all_unit_tests.sh b/libwvdrmengine/run_all_unit_tests.sh
index cced7b4b..942db0f3 100755
--- a/libwvdrmengine/run_all_unit_tests.sh
+++ b/libwvdrmengine/run_all_unit_tests.sh
@@ -53,6 +53,7 @@ adb_shell_run /system/bin/license_unittest
 adb_shell_run /system/bin/initialization_data_unittest
 adb_shell_run /system/bin/device_files_unittest
 adb_shell_run /system/bin/timer_unittest
+adb_shell_run /system/bin/buffer_reader_test
 
 library_path="/system/vendor/lib/mediadrm/ "
 adb_shell_run LD_LIBRARY_PATH=$library_path /system/bin/libwvdrmengine_test