// Copyright 2013 Google Inc. All Rights Reserved.

#include "gtest/gtest.h"
#include "log.h"
#include "string_conversions.h"

namespace {
  std::string kMultipleOf24BitsData("Good day!");
  std::string kOneByteOverData("Hello Googler");
  std::string kTwoBytesOverData("Hello Googlers");
  std::string kMultipleOf24BitsB64Data("R29vZCBkYXkh");
  std::string kOneByteOverB64Data("SGVsbG8gR29vZ2xlcg==");
  std::string kTwoBytesOverB64Data("SGVsbG8gR29vZ2xlcnM=");
  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";
  std::string kB64TestData = "GPFc9rc-INmI8FwtyTrUrv6xnKHWZNZ_5uaT21nFjNg=";
  std::string kB64ShortString("r-LpoZcbbr2KtoPaFnuWTVBh4Gup1k8vn0ClW2qm32A=");
  std::string kB64LongString =
    "CrAJYTyIdLPiA2jBzMskbE_gFQj69wv23VlJ2e3MBKtK4nJwKyNYGyyluqKo"
    "TP751tvoADf86iLrf73mEzF58eSlaOjCpJRf2R3dojbNeSTy3JICmCc8vKtMjZRX9QWTvJbq_cg"
    "yMB8FQC8enuYhOaw1yJDYyCFHgik34NrUVUfmvaKKdSKQimqAZmjXi6P0znAn-XdPtz2xJVRxZp"
    "NH3QCD1bGcH_O1ercBW2JwF9KNalKFsxQrBhIwvyx-q-Ah4vf4r3M2HzY6JTHvcYGGc7dJNA3Xe"
    "WfCrYIvg0SGCP_z7Y2wICIA36VMwR3gnwNZlKkx6WGCCgsaU6IbLm4HpRBZfajuiOlasoYN4z1R"
    "lQ14Z32fdaFy8xOqLl-ZukxjWa7wv9zOSveH6JcHap1FS3R-RZ7E5WhfjxSTS0nWWZgmAjS2PkP"
    "9g4GPNsnpsrVymI39j6R6jPoc3__2EGN6qAvmp4pFKR7lQyslgNn2vYLuE0Ps5mIXVkxNiZOO3T"
    "jxgZyHaHOm1KmAZKI0EfddMATJCTt-UeLG3haqS_pYaBWcQ_xzWhoEHWU7_6ZaWrWemV8CVCg6s"
    "OB1SRI5MrkRBBSV0r8UKddLJGthZVjuTG75KK72KE9yhe86mCadvfVYe5keJ5GOC-t1EiFzBo4c"
    "4oqwkOCkkmYX_BEuZ3pOWztFp1_Br2Tl_fziw4O2vNIPCXB9yEewV6PkYPziTue3x4vRqD_mYjm"
    "1ia8fxISQnEC0vrqvrFFs9fLAHPlsvaRFnhv_XKpRwFoBdfqWTakb3k6uRz0Oh2SJ8euzFIyQNB"
    "efesMWk45DSrQjnlwlKXwZSiDKjAss0W2WwIb9F_x5LdB1Aa-CBudLVdxf62ggYaNZ57qx3YeHA"
    "jkqMGIF7Fq09D4OxM0jRsnrmXbJWKleUpJi7nHJgQGZk2ifN95gjuTNcRaGfYXMOsDoWdkrNAq0"
    "LScsPB06xEUR0DcO9vWx0zAEK7gsxxHziR7ZaYiIIkPysRR92r2NoLFPOUXf8j8ait-51jZmPKn"
    "bD6adieLy6ujSl907QsUgyGvokLs1OCsYHZr-X6vnyMjdk4G3QfmWwRepD_CMyXGvtLbTNCto7E"
    "L_M2yPZveAwYWwNlBtWK21gwIU2dgY298z7_S6jaQBc29f25sREjvN793ttYsPaeyom08qHYDnb"
    "jae3XX-2qqde6AGXlv__jO8WDZ5od6DWu2ThqV10ijVGFfGniRsSruzq0iq8zuAqTOGhmA9Dw7b"
    "rNlI95P4LpJA5pbjmNdnX7CQa2oHUuojmwlXRYuOA28PNEf-sc7ZPmMyFzedJi4EpkqzeQspEdH"
    "yNMf23iEjK6GOff7dgAaxg9vYHyprhkEml4BdmFVYwCYQy8o6KRcA0NgJb8c3tg4d3aRXWp6L-F"
    "sVhwqvq6FLOunSTNRIqhr2mOjRpU5w4mx-9GJRtk4XEcKT9YgUHGOUjGwfhQ5gBQDyZZVTddIUb"
    "MOThsSg7zr38oUCfgXeZaai3X2foKo1Bt94Q_q18dw5xNAN5e7rSwfilltHL23zbZduuhWkvp8S"
    "dag_NbO2C4IRMkzbjQBmiO9ixjXRhdqHlRRWcfR0wbQvEhD47egRVfnhKZ0W9G2-FGhyGuwJCq4"
    "CCAISEAfZ_94TqpXBImeAUzYhNr0Y48SbiwUijgIwggEKAoIBAQDRigR9nFm4mfBUh1Y3SGyOcF"
    "E-yK2NtfDiQe9l70KtkOeH4sB6MMB8g1QKPbUE8SBjPvXVJC_2DAWKjALzk4Aw-K-VmYe_Ag9CH"
    "JiS-XcfUYEGgK4jVMxadEq3LufEEREKUZnzjgQlR39dzgjFqIrC1bwfy3_99RsjPt6QpWPg36PI"
    "O4UKlmwBDTFzSOJB-4IV8Opy5Zv84BqPuyO9P5e3bXj_shRfy_XAGG2HGP_PpOCZWEfxuce0Iyu"
    "vpTPLQpTOgNw-VvUBGCWMZFoERopmqp_pQwWZ2a-EwlT_vvYY4SkuNjflBskR70xz4QzEo9665g"
    "k6I-HbHrTv29KEiAllAgMBAAEomSASgAIkKz1CSdFJVKcpO56jW0vsjKp92_cdqXBSEY3nuhzug"
    "_LFluMJx_IqATUcCOY-w6w0yKn2ezfZGE0MDIaCngEgQFI_DRoaSOBNNeirF59uYM0sK3P2eGS9"
    "G6F0l-OUXJdSO0b_LO8AbAK9LA3j7UHaajupJI1mdc4VtJfPRTsml2vIeKhDWXWaSvmeHgfF_tp"
    "-OV7oPuk6Ub26xpCp2He2rEAblCYEl25Zlz97K4DhyTOV5_xuSdSt-KbTLY9cWM5i9ncND1RzCc"
    "4qOixKarnMM5DdpZhs3B5xVj3yBAM1mVxPD2sZnqHSEN2EK7BMlHEnnyxhX0MGE36TQZR7P-I-G"
    "rUFCq8CCAESEDAxMjM0NTY3ODlBQkNERUYYspIEIo4CMIIBCgKCAQEApwA2YGXcvVRaKkC04RWU"
    "WBFPlFjd3qcfPCzgiAkpYVdnXlZ-7iePWTSaKqqdtE76p2rUyXpTwU6f4zT3PbfJEEdPKNo_zjF"
    "7_QYQ6_e-kvmv-z5o2u4aZEzzKfJznjnY9m_YsoCCcY61pPLCPs0KyrYEzZoTi1RzVCVUjL6Yem"
    "et2rNOs_qCqEpnmFZXVHHNEn_towHAaoskA5aIvpdmKrxTyYMGUVqIZRMY5Drta_FhW0zIHvTCr"
    "gheLV_4En-i_LshGDDa_kD7AcouNw7O3XaHgkYLOnePwHIHLH-dHoZb7Scp3wOXYu9E01s925xe"
    "G3s5tAttBGu7uyxfz7N6BQIDAQABKNKF2MwEEoADe9NAqNAxHpU13bMgz8LPySZJU8hY1RLwcfT"
    "UM47Xb3m-F-s2cfI7w08668f79kD45uRRzkVc8GbRIlVyzVC0WgIvtxEkYRKfgF_J7snUe2J2NN"
    "1FrkK7H3oYhcfPyYZH_SPZJr5HPoBFQTmS5A4l24U1dzQ6Z7_q-oS6uT0DiagTnzWhEg6AEnIkT"
    "sJtK3cZuKGYq3NDefZ7nslPuLXxdXl6SAEOtrk-RvCY6EBqYOuPUXgxXOEPbyM289R6aHQyPPYw"
    "qs9Pt9_E4BuMqCsbf5H5mLms9FA-wRx6mK2IaOboT4tf9_YObp3hVeL3WyxzXncETzJdE1GPGlO"
    "t_x5S_MylgJKbiWQYSdmqs3fzYExunw3wvI4tPHT_O8A_xKjyTEAvE5cBuCkfjwT716qUOzFUzF"
    "gZYLHnFiQLZekZUbUUlWY_CwU9Cv0UtxqQ6Oa835_Ug8_n1BwX6BPbmbcWe2Y19laSnDWg4JBNl"
    "F2CyP9N75jPtW9rVfjUSqKEPOwaIgwzNDkyMjM3NDcAAAA=";
}

namespace wvcdm {

class Base64Test : public testing::Test {
 public:
  Base64Test() {}
  ~Base64Test() {}

};

TEST_F(Base64Test, Base64MultipleOf24BitsTest)
{
  // encodes string
  std::vector<uint8_t> message_vector(kMultipleOf24BitsData.begin(),
                                      kMultipleOf24BitsData.end());
  std::string message_b64 = Base64SafeEncode(message_vector);

  // decodes string
  std::vector<uint8_t> result_vector = Base64SafeDecode(message_b64);
  std::string result;
  result.assign(result_vector.begin(), result_vector.end());
  EXPECT_STREQ(kMultipleOf24BitsData.data(), result.data());
}

TEST_F(Base64Test, Base64OneByteOverTest)
{
  // encodes string
  std::vector<uint8_t> message_vector(kOneByteOverData.begin(),
                                      kOneByteOverData.end());
  std::string message_b64 = Base64SafeEncode(message_vector);

  // decodes string
  std::vector<uint8_t> result_vector = Base64SafeDecode(message_b64);
  std::string result;
  result.assign(result_vector.begin(), result_vector.end());
  EXPECT_STREQ(kOneByteOverData.data(), result.data());
}

TEST_F(Base64Test, Base64TwoBytesOverTest)
{
  // encodes string
  std::vector<uint8_t> message_vector(kTwoBytesOverData.begin(),
                                      kTwoBytesOverData.end());
  std::string message_b64 = Base64SafeEncode(message_vector);

  // decodes string
  std::vector<uint8_t> result_vector = Base64SafeDecode(message_b64);
  std::string result;
  result.assign(result_vector.begin(), result_vector.end());
  EXPECT_STREQ(kTwoBytesOverData.data(), result.data());
}

TEST_F(Base64Test, Base64EncodeTest)
{
  // encodes string
  std::vector<uint8_t> message_vector(kTestData.begin(), kTestData.end());
  std::string message_b64 = Base64SafeEncode(message_vector);
  std::string result;
  result.assign(message_b64.begin(), message_b64.end());
  EXPECT_STREQ(kB64TestData.data(), result.data());

  // decodes string
  std::vector<uint8_t> result_vector = Base64SafeDecode(message_b64);
  result.clear();
  result.assign(result_vector.begin(), result_vector.end());
  EXPECT_STREQ(kTestData.data(), result.data());
}

TEST_F(Base64Test, Base64MultipleOf24BitsDecodeTest)
{
  // decodes string
  std::vector<uint8_t> decoded_vector = Base64SafeDecode(kMultipleOf24BitsB64Data);
  std::string result;
  result.assign(decoded_vector.begin(), decoded_vector.end());
  EXPECT_STREQ(kMultipleOf24BitsData.data(), result.data());

  // encodes string
  std::string b64_string = Base64SafeEncode(decoded_vector);
  EXPECT_STREQ(kMultipleOf24BitsB64Data.data(), b64_string.data());
}

TEST_F(Base64Test, Base64OneByteOverDecodeTest)
{
  // decodes string
  std::vector<uint8_t> decoded_vector = Base64SafeDecode(kOneByteOverB64Data);
  std::string result;
  result.assign(decoded_vector.begin(), decoded_vector.end());
  EXPECT_STREQ(kOneByteOverData.data(), result.data());

  // encodes string
  std::string b64_string = Base64SafeEncode(decoded_vector);
  EXPECT_STREQ(kOneByteOverB64Data.data(), b64_string.data());
}

TEST_F(Base64Test, Base64TwoBytesOverDecodeTest)
{
  // decodes string
  std::vector<uint8_t> decoded_vector = Base64SafeDecode(kTwoBytesOverB64Data);
  std::string result;
  result.assign(decoded_vector.begin(), decoded_vector.end());
  EXPECT_STREQ(kTwoBytesOverData.data(), result.data());

  // encodes string
  std::string b64_string = Base64SafeEncode(decoded_vector);
  EXPECT_STREQ(kTwoBytesOverB64Data.data(), b64_string.data());
}

TEST_F(Base64Test, Base64ShortDecodeTest)
{
  // decodes string
  std::vector<uint8_t> decoded_vector = Base64SafeDecode(kB64ShortString);

  // encodes string
  std::string b64_string = Base64SafeEncode(decoded_vector);
  EXPECT_STREQ(kB64ShortString.data(), b64_string.data());
}

TEST_F(Base64Test, Base64LongDecodeTest)
{
  // decodes string
  std::vector<uint8_t> decoded_vector = Base64SafeDecode(kB64LongString);

  // encodes string
  std::string b64_string = Base64SafeEncode(decoded_vector);
  EXPECT_STREQ(kB64LongString.data(), b64_string.data());
}

}  // namespace wvcdm