Move utils unit tests to a utils specific test dir

[ Merge of http://go/wvgerrit/85804 ]

This moves file_utils_unittest.cpp, file_store_unittest.cpp and
base64_test.cpp from core/test to utils/test.

Bug: 140639279
Test: Android unit/integration
Change-Id: I1c31e5a716a925478fc1efe9fe68b93b1514e89c

libwvdrmengine/cdm/util/test/base64_test.cpp

@@ -0,0 +1,124 @@
+// Copyright 2018 Google LLC. All Rights Reserved. This file and proprietary
+// source code may only be used and distributed under the Widevine Master
+// License Agreement.
+
+#include <utility>
+
+#include <gtest/gtest.h>
+
+#include "log.h"
+#include "string_conversions.h"
+
+namespace wvcdm {
+
+namespace {
+
+// Test vectors as suggested by http://tools.ietf.org/html/rfc4648#section-10
+const std::string kNullString("");
+const std::string kf("f");
+const std::string kfo("fo");
+const std::string kfoo("foo");
+const std::string kfoob("foob");
+const std::string kfooba("fooba");
+const std::string kfoobar("foobar");
+const std::string kfB64("Zg==");
+const std::string kfoB64("Zm8=");
+const std::string kfooB64("Zm9v");
+const std::string kfoobB64("Zm9vYg==");
+const std::string kfoobaB64("Zm9vYmE=");
+const std::string kfoobarB64("Zm9vYmFy");
+
+// Arbitrary clear test vectors
+const std::string kMultipleOf24BitsData("Good day!");
+const std::string kOneByteOverData("Hello Friend!");
+const std::string kTwoBytesOverData("Hello Friend!!");
+const std::string kTestData =
+    "\030\361\\\366\267> \331\210\360\\-\311:\324\256\376"
+    "\261\234\241\326d\326\177\346\346\223\333Y\305\214\330";
+
+// Arbitrary encoded test vectors
+const std::string kMultipleOf24BitsB64Data("R29vZCBkYXkh");
+const std::string kOneByteOverB64Data("SGVsbG8gRnJpZW5kIQ==");
+const std::string kTwoBytesOverB64Data("SGVsbG8gRnJpZW5kISE=");
+const std::string kB64TestData = "GPFc9rc+INmI8FwtyTrUrv6xnKHWZNZ/5uaT21nFjNg=";
+
+const std::pair<const std::string*, const std::string*> kBase64TestVectors[] = {
+    make_pair(&kNullString, &kNullString),
+    make_pair(&kf, &kfB64),
+    make_pair(&kfo, &kfoB64),
+    make_pair(&kfoo, &kfooB64),
+    make_pair(&kfoob, &kfoobB64),
+    make_pair(&kfooba, &kfoobaB64),
+    make_pair(&kfoobar, &kfoobarB64),
+    make_pair(&kMultipleOf24BitsData, &kMultipleOf24BitsB64Data),
+    make_pair(&kOneByteOverData, &kOneByteOverB64Data),
+    make_pair(&kTwoBytesOverData, &kTwoBytesOverB64Data),
+    make_pair(&kTestData, &kB64TestData)};
+
+const std::string kBase64ErrorVectors[] = {"Foo$sa", "Foo\x99\x23\xfa\02",
+                                           "Foo==Foo", "FooBa"};
+
+std::string ConvertToBase64WebSafe(const std::string& std_base64_string) {
+  std::string str(std_base64_string);
+  for (size_t i = 0; i < str.size(); ++i) {
+    if (str[i] == '+')
+      str[i] = '-';
+    else if (str[i] == '/')
+      str[i] = '_';
+  }
+  return str;
+}
+
+}  // namespace
+
+class Base64EncodeDecodeTest
+    : public ::testing::TestWithParam<
+          std::pair<const std::string*, const std::string*> > {};
+
+TEST_P(Base64EncodeDecodeTest, EncodeDecodeTest) {
+  std::pair<const std::string*, const std::string*> values = GetParam();
+  std::vector<uint8_t> decoded_vector = Base64Decode(values.second->data());
+  std::string decoded_string(decoded_vector.begin(), decoded_vector.end());
+  EXPECT_STREQ(values.first->data(), decoded_string.data());
+  std::string b64_string = Base64Encode(decoded_vector);
+  EXPECT_STREQ(values.second->data(), b64_string.data());
+}
+
+TEST_P(Base64EncodeDecodeTest, WebSafeEncodeDecodeTest) {
+  std::pair<const std::string*, const std::string*> values = GetParam();
+  std::string encoded_string = ConvertToBase64WebSafe(*(values.second));
+  std::vector<uint8_t> decoded_vector = Base64SafeDecode(encoded_string);
+  std::string decoded_string(decoded_vector.begin(), decoded_vector.end());
+  EXPECT_STREQ(values.first->data(), decoded_string.data());
+  std::string b64_string = Base64SafeEncode(decoded_vector);
+  EXPECT_STREQ(encoded_string.data(), b64_string.data());
+}
+
+class Base64ErrorDecodeTest : public ::testing::TestWithParam<std::string> {};
+
+TEST_P(Base64ErrorDecodeTest, EncoderErrors) {
+  std::vector<uint8_t> result = Base64Decode(GetParam());
+  EXPECT_EQ(0u, result.size());
+}
+
+INSTANTIATE_TEST_CASE_P(ExecutesBase64Test, Base64EncodeDecodeTest,
+                        ::testing::ValuesIn(kBase64TestVectors));
+
+INSTANTIATE_TEST_CASE_P(ExecutesBase64Test, Base64ErrorDecodeTest,
+                        ::testing::ValuesIn(kBase64ErrorVectors));
+
+class HtoNLL64Test : public ::testing::Test {};
+
+TEST_F(HtoNLL64Test, PositiveNumber) {
+  uint8_t data[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+  int64_t* network_byte_order = reinterpret_cast<int64_t*>(data);
+  int64_t host_byte_order = htonll64(*network_byte_order);
+  EXPECT_EQ(0x0102030405060708, host_byte_order);
+}
+TEST_F(HtoNLL64Test, NegativeNumber) {
+  uint8_t data[8] = {0xfe, 2, 3, 4, 5, 6, 7, 8};
+  int64_t* network_byte_order = reinterpret_cast<int64_t*>(data);
+  int64_t host_byte_order = htonll64(*network_byte_order);
+  EXPECT_EQ(-0x01FdFcFbFaF9F8F8, host_byte_order);
+}
+}  // namespace wvcdm