// Copyright 2020 The Pigweed Authors
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not
// use this file except in compliance with the License. You may obtain a copy of
// the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations under
// the License.

#include "pw_base64/base64.h"

#include <cstring>

#include "gtest/gtest.h"

namespace pw::base64 {
namespace {

struct EncodedData {
  const size_t binary_size;
  const char* const binary_data;
  const char* const encoded_data;
};

/* The following test data was generated by this Python 3 script.

#!/usr/bin/env python3

import base64
import random


def b64_encode(raw_data):
    encoded = base64.b64encode(raw_data).decode()
    hex_string = ''.join(r'\x{:02x}'.format(b) for b in raw_data)

    print('    {{{size}, "{raw}", "{encoded}"}},'.format(
        size=len(raw_data), raw=hex_string, encoded=encoded))


print('constexpr EncodedData kSingleCharTestData[] = {')

for i in range(256):
    b64_encode(bytes([i]))

print('};')
print()

print('constexpr EncodedData kRandomTestData[] = {')

for length in range(2, 12):
    for _ in range(10):
        b64_encode(bytes(random.randrange(256) for _ in range(length)))

print('};')
print()

*/

constexpr EncodedData kSingleCharTestData[] = {
    {1, "\x00", "AA=="}, {1, "\x01", "AQ=="}, {1, "\x02", "Ag=="},
    {1, "\x03", "Aw=="}, {1, "\x04", "BA=="}, {1, "\x05", "BQ=="},
    {1, "\x06", "Bg=="}, {1, "\x07", "Bw=="}, {1, "\x08", "CA=="},
    {1, "\x09", "CQ=="}, {1, "\x0a", "Cg=="}, {1, "\x0b", "Cw=="},
    {1, "\x0c", "DA=="}, {1, "\x0d", "DQ=="}, {1, "\x0e", "Dg=="},
    {1, "\x0f", "Dw=="}, {1, "\x10", "EA=="}, {1, "\x11", "EQ=="},
    {1, "\x12", "Eg=="}, {1, "\x13", "Ew=="}, {1, "\x14", "FA=="},
    {1, "\x15", "FQ=="}, {1, "\x16", "Fg=="}, {1, "\x17", "Fw=="},
    {1, "\x18", "GA=="}, {1, "\x19", "GQ=="}, {1, "\x1a", "Gg=="},
    {1, "\x1b", "Gw=="}, {1, "\x1c", "HA=="}, {1, "\x1d", "HQ=="},
    {1, "\x1e", "Hg=="}, {1, "\x1f", "Hw=="}, {1, "\x20", "IA=="},
    {1, "\x21", "IQ=="}, {1, "\x22", "Ig=="}, {1, "\x23", "Iw=="},
    {1, "\x24", "JA=="}, {1, "\x25", "JQ=="}, {1, "\x26", "Jg=="},
    {1, "\x27", "Jw=="}, {1, "\x28", "KA=="}, {1, "\x29", "KQ=="},
    {1, "\x2a", "Kg=="}, {1, "\x2b", "Kw=="}, {1, "\x2c", "LA=="},
    {1, "\x2d", "LQ=="}, {1, "\x2e", "Lg=="}, {1, "\x2f", "Lw=="},
    {1, "\x30", "MA=="}, {1, "\x31", "MQ=="}, {1, "\x32", "Mg=="},
    {1, "\x33", "Mw=="}, {1, "\x34", "NA=="}, {1, "\x35", "NQ=="},
    {1, "\x36", "Ng=="}, {1, "\x37", "Nw=="}, {1, "\x38", "OA=="},
    {1, "\x39", "OQ=="}, {1, "\x3a", "Og=="}, {1, "\x3b", "Ow=="},
    {1, "\x3c", "PA=="}, {1, "\x3d", "PQ=="}, {1, "\x3e", "Pg=="},
    {1, "\x3f", "Pw=="}, {1, "\x40", "QA=="}, {1, "\x41", "QQ=="},
    {1, "\x42", "Qg=="}, {1, "\x43", "Qw=="}, {1, "\x44", "RA=="},
    {1, "\x45", "RQ=="}, {1, "\x46", "Rg=="}, {1, "\x47", "Rw=="},
    {1, "\x48", "SA=="}, {1, "\x49", "SQ=="}, {1, "\x4a", "Sg=="},
    {1, "\x4b", "Sw=="}, {1, "\x4c", "TA=="}, {1, "\x4d", "TQ=="},
    {1, "\x4e", "Tg=="}, {1, "\x4f", "Tw=="}, {1, "\x50", "UA=="},
    {1, "\x51", "UQ=="}, {1, "\x52", "Ug=="}, {1, "\x53", "Uw=="},
    {1, "\x54", "VA=="}, {1, "\x55", "VQ=="}, {1, "\x56", "Vg=="},
    {1, "\x57", "Vw=="}, {1, "\x58", "WA=="}, {1, "\x59", "WQ=="},
    {1, "\x5a", "Wg=="}, {1, "\x5b", "Ww=="}, {1, "\x5c", "XA=="},
    {1, "\x5d", "XQ=="}, {1, "\x5e", "Xg=="}, {1, "\x5f", "Xw=="},
    {1, "\x60", "YA=="}, {1, "\x61", "YQ=="}, {1, "\x62", "Yg=="},
    {1, "\x63", "Yw=="}, {1, "\x64", "ZA=="}, {1, "\x65", "ZQ=="},
    {1, "\x66", "Zg=="}, {1, "\x67", "Zw=="}, {1, "\x68", "aA=="},
    {1, "\x69", "aQ=="}, {1, "\x6a", "ag=="}, {1, "\x6b", "aw=="},
    {1, "\x6c", "bA=="}, {1, "\x6d", "bQ=="}, {1, "\x6e", "bg=="},
    {1, "\x6f", "bw=="}, {1, "\x70", "cA=="}, {1, "\x71", "cQ=="},
    {1, "\x72", "cg=="}, {1, "\x73", "cw=="}, {1, "\x74", "dA=="},
    {1, "\x75", "dQ=="}, {1, "\x76", "dg=="}, {1, "\x77", "dw=="},
    {1, "\x78", "eA=="}, {1, "\x79", "eQ=="}, {1, "\x7a", "eg=="},
    {1, "\x7b", "ew=="}, {1, "\x7c", "fA=="}, {1, "\x7d", "fQ=="},
    {1, "\x7e", "fg=="}, {1, "\x7f", "fw=="}, {1, "\x80", "gA=="},
    {1, "\x81", "gQ=="}, {1, "\x82", "gg=="}, {1, "\x83", "gw=="},
    {1, "\x84", "hA=="}, {1, "\x85", "hQ=="}, {1, "\x86", "hg=="},
    {1, "\x87", "hw=="}, {1, "\x88", "iA=="}, {1, "\x89", "iQ=="},
    {1, "\x8a", "ig=="}, {1, "\x8b", "iw=="}, {1, "\x8c", "jA=="},
    {1, "\x8d", "jQ=="}, {1, "\x8e", "jg=="}, {1, "\x8f", "jw=="},
    {1, "\x90", "kA=="}, {1, "\x91", "kQ=="}, {1, "\x92", "kg=="},
    {1, "\x93", "kw=="}, {1, "\x94", "lA=="}, {1, "\x95", "lQ=="},
    {1, "\x96", "lg=="}, {1, "\x97", "lw=="}, {1, "\x98", "mA=="},
    {1, "\x99", "mQ=="}, {1, "\x9a", "mg=="}, {1, "\x9b", "mw=="},
    {1, "\x9c", "nA=="}, {1, "\x9d", "nQ=="}, {1, "\x9e", "ng=="},
    {1, "\x9f", "nw=="}, {1, "\xa0", "oA=="}, {1, "\xa1", "oQ=="},
    {1, "\xa2", "og=="}, {1, "\xa3", "ow=="}, {1, "\xa4", "pA=="},
    {1, "\xa5", "pQ=="}, {1, "\xa6", "pg=="}, {1, "\xa7", "pw=="},
    {1, "\xa8", "qA=="}, {1, "\xa9", "qQ=="}, {1, "\xaa", "qg=="},
    {1, "\xab", "qw=="}, {1, "\xac", "rA=="}, {1, "\xad", "rQ=="},
    {1, "\xae", "rg=="}, {1, "\xaf", "rw=="}, {1, "\xb0", "sA=="},
    {1, "\xb1", "sQ=="}, {1, "\xb2", "sg=="}, {1, "\xb3", "sw=="},
    {1, "\xb4", "tA=="}, {1, "\xb5", "tQ=="}, {1, "\xb6", "tg=="},
    {1, "\xb7", "tw=="}, {1, "\xb8", "uA=="}, {1, "\xb9", "uQ=="},
    {1, "\xba", "ug=="}, {1, "\xbb", "uw=="}, {1, "\xbc", "vA=="},
    {1, "\xbd", "vQ=="}, {1, "\xbe", "vg=="}, {1, "\xbf", "vw=="},
    {1, "\xc0", "wA=="}, {1, "\xc1", "wQ=="}, {1, "\xc2", "wg=="},
    {1, "\xc3", "ww=="}, {1, "\xc4", "xA=="}, {1, "\xc5", "xQ=="},
    {1, "\xc6", "xg=="}, {1, "\xc7", "xw=="}, {1, "\xc8", "yA=="},
    {1, "\xc9", "yQ=="}, {1, "\xca", "yg=="}, {1, "\xcb", "yw=="},
    {1, "\xcc", "zA=="}, {1, "\xcd", "zQ=="}, {1, "\xce", "zg=="},
    {1, "\xcf", "zw=="}, {1, "\xd0", "0A=="}, {1, "\xd1", "0Q=="},
    {1, "\xd2", "0g=="}, {1, "\xd3", "0w=="}, {1, "\xd4", "1A=="},
    {1, "\xd5", "1Q=="}, {1, "\xd6", "1g=="}, {1, "\xd7", "1w=="},
    {1, "\xd8", "2A=="}, {1, "\xd9", "2Q=="}, {1, "\xda", "2g=="},
    {1, "\xdb", "2w=="}, {1, "\xdc", "3A=="}, {1, "\xdd", "3Q=="},
    {1, "\xde", "3g=="}, {1, "\xdf", "3w=="}, {1, "\xe0", "4A=="},
    {1, "\xe1", "4Q=="}, {1, "\xe2", "4g=="}, {1, "\xe3", "4w=="},
    {1, "\xe4", "5A=="}, {1, "\xe5", "5Q=="}, {1, "\xe6", "5g=="},
    {1, "\xe7", "5w=="}, {1, "\xe8", "6A=="}, {1, "\xe9", "6Q=="},
    {1, "\xea", "6g=="}, {1, "\xeb", "6w=="}, {1, "\xec", "7A=="},
    {1, "\xed", "7Q=="}, {1, "\xee", "7g=="}, {1, "\xef", "7w=="},
    {1, "\xf0", "8A=="}, {1, "\xf1", "8Q=="}, {1, "\xf2", "8g=="},
    {1, "\xf3", "8w=="}, {1, "\xf4", "9A=="}, {1, "\xf5", "9Q=="},
    {1, "\xf6", "9g=="}, {1, "\xf7", "9w=="}, {1, "\xf8", "+A=="},
    {1, "\xf9", "+Q=="}, {1, "\xfa", "+g=="}, {1, "\xfb", "+w=="},
    {1, "\xfc", "/A=="}, {1, "\xfd", "/Q=="}, {1, "\xfe", "/g=="},
    {1, "\xff", "/w=="},
};

constexpr EncodedData kRandomTestData[] = {
    {2, "\x63\xa9", "Y6k="},
    {2, "\xa1\x49", "oUk="},
    {2, "\x14\x58", "FFg="},
    {2, "\x5d\xa2", "XaI="},
    {2, "\x7c\x80", "fIA="},
    {2, "\xc1\xbb", "wbs="},
    {2, "\x08\x00", "CAA="},
    {2, "\xd8\x88", "2Ig="},
    {2, "\x74\x6d", "dG0="},
    {2, "\x22\x86", "IoY="},
    {3, "\x69\x89\x03", "aYkD"},
    {3, "\x6c\xcb\xc5", "bMvF"},
    {3, "\x72\x36\x8b", "cjaL"},
    {3, "\xd3\xdc\xe0", "09zg"},
    {3, "\x5d\x1f\x8a", "XR+K"},
    {3, "\x0d\xc0\x5b", "DcBb"},
    {3, "\xe3\x11\x1e", "4xEe"},
    {3, "\xbc\x3c\xb9", "vDy5"},
    {3, "\xc0\xa2\x1c", "wKIc"},
    {3, "\xa9\x67\xfb", "qWf7"},
    {4, "\x80\xf5\xc8\xd4", "gPXI1A=="},
    {4, "\xa3\x54\x4a\xfa", "o1RK+g=="},
    {4, "\x69\xdb\x14\x4c", "adsUTA=="},
    {4, "\x95\x20\x23\x1a", "lSAjGg=="},
    {4, "\xb9\x2c\x00\x11", "uSwAEQ=="},
    {4, "\xef\xeb\x23\x44", "7+sjRA=="},
    {4, "\xcf\xa9\xe6\x85", "z6nmhQ=="},
    {4, "\xc5\xe0\x36\xde", "xeA23g=="},
    {4, "\x77\xe1\x63\x51", "d+FjUQ=="},
    {4, "\x7d\xa6\x8c\x5e", "faaMXg=="},
    {5, "\x6e\xb8\x91\x3f\xac", "briRP6w="},
    {5, "\xd1\x16\x7f\x1d\xef", "0RZ/He8="},  // inclusive-language: ignore
    {5, "\x42\x95\xfb\x24\xee", "QpX7JO4="},
    {5, "\x19\xfd\xe5\x96\xc1", "Gf3llsE="},
    {5, "\x42\x5a\xb3\xfe\x13", "Qlqz/hM="},
    {5, "\x2b\xf7\x1a\xcc\x13", "K/cazBM="},
    {5, "\xba\x8f\x0d\xf7\xc1", "uo8N98E="},
    {5, "\x28\xa6\x77\x2d\xfc", "KKZ3Lfw="},
    {5, "\x68\xaa\x19\x59\xd0", "aKoZWdA="},
    {5, "\x46\x73\xd3\x54\x7e", "RnPTVH4="},
    {6, "\x1f\x88\x91\xbb\xd7\x10", "H4iRu9cQ"},
    {6, "\x37\x23\x3b\x5a\x26\xe4", "NyM7Wibk"},
    {6, "\xd2\xa0\xf4\x13\x91\xe6", "0qD0E5Hm"},
    {6, "\x55\xe8\xe9\x06\x5d\xc3", "VejpBl3D"},
    {6, "\xeb\xf5\xd8\x62\x3c\x5e", "6/XYYjxe"},
    {6, "\xee\xad\x7e\xc4\x66\x83", "7q1+xGaD"},
    {6, "\xbb\x07\x2c\x26\x3f\xb7", "uwcsJj+3"},
    {6, "\xed\xf3\x34\x94\xab\x41", "7fM0lKtB"},
    {6, "\x3f\xe8\x18\x4c\xe8\xf4", "P+gYTOj0"},
    {6, "\x0a\xdd\x39\xbc\x1f\x65", "Ct05vB9l"},
    {7, "\xac\xcf\xb2\xd5\xee\xa2\x8e", "rM+y1e6ijg=="},
    {7, "\x78\x63\xeb\x3f\x07\xde\x04", "eGPrPwfeBA=="},
    {7, "\x7a\xd7\x3b\x5c\x09\xc2\x93", "etc7XAnCkw=="},
    {7, "\xd4\xe4\xda\xe3\xf3\x4d\xe9", "1OTa4/NN6Q=="},
    {7, "\xa6\xc6\x7c\x47\xd5\xbe\xd3", "psZ8R9W+0w=="},
    {7, "\x34\xad\x5d\x02\x47\xa1\x39", "NK1dAkehOQ=="},
    {7, "\x33\x98\xd7\x02\x46\x4e\xad", "M5jXAkZOrQ=="},
    {7, "\x08\x4d\x48\x48\xb1\x3d\x05", "CE1ISLE9BQ=="},
    {7, "\xc4\x5e\x4a\x6d\x4a\x04\xb6", "xF5KbUoEtg=="},
    {7, "\x12\xe9\xf4\xaa\x2e\x4c\x31", "Eun0qi5MMQ=="},
    {8, "\xff\x15\x25\x7e\x7b\xc9\x7b\x60", "/xUlfnvJe2A="},
    {8, "\xc7\xbb\x0b\x62\x5c\x62\x41\xc2", "x7sLYlxiQcI="},
    {8, "\x48\x49\x6d\x7c\xca\xb7\xae\xed", "SEltfMq3ru0="},
    {8, "\xfd\xec\x13\xd6\x93\x9f\xba\xe0", "/ewT1pOfuuA="},
    {8, "\x7e\xff\xd2\xdd\x0e\xe2\x6c\x60", "fv/S3Q7ibGA="},
    {8, "\xe5\xba\x41\x65\xa0\x46\x17\x27", "5bpBZaBGFyc="},
    {8, "\xce\xec\xd5\x68\x3a\xb7\xb4\x16", "zuzVaDq3tBY="},
    {8, "\xbe\x33\x9a\xc9\xfd\xcc\x29\xe8", "vjOayf3MKeg="},
    {8, "\x55\x8c\x60\xcc\xc4\x7d\x99\x1f", "VYxgzMR9mR8="},
    {8, "\xee\x21\x88\x2a\x0f\x7e\x76\xd7", "7iGIKg9+dtc="},
    {9, "\xd5\xab\xd9\xa6\xae\xaa\x33\x9f\x66", "1avZpq6qM59m"},
    {9, "\x6f\xe8\x06\xcf\xfd\x79\x3a\x4e\xdb", "b+gGz/15Ok7b"},
    {9, "\x61\x00\x0a\x51\xad\x5b\xf1\xf9\x37", "YQAKUa1b8fk3"},
    {9, "\x4f\x40\x0b\x79\x10\xa4\x12\x25\x3e", "T0ALeRCkEiU+"},
    {9, "\xb1\x37\xb3\x41\x5b\xd7\xe8\xa4\xda", "sTezQVvX6KTa"},
    {9, "\x82\xa5\x22\xd3\x48\xd8\xf7\x62\x7a", "gqUi00jY92J6"},
    {9, "\xfd\x05\x33\x92\x2c\xd3\x85\x29\xa2", "/QUzkizThSmi"},
    {9, "\x32\x93\x53\x06\x9c\xbb\x96\xbb\xf3", "MpNTBpy7lrvz"},
    {9, "\xba\x40\x1d\x06\x92\xce\xc2\x8a\x28", "ukAdBpLOwooo"},
    {9, "\xcc\x89\xf5\xeb\x49\x91\xa6\xa6\x88", "zIn160mRpqaI"},
    {10, "\x6b\xfd\x95\xc5\x4a\xc7\xc2\x39\x45\xdc", "a/2VxUrHwjlF3A=="},
    {10, "\x34\x50\xab\x78\xaf\x92\x47\x56\x8a\xb6", "NFCreK+SR1aKtg=="},
    {10, "\x07\x14\x0a\xe8\x49\xca\x3a\x36\x80\xb0", "BxQK6EnKOjaAsA=="},
    {10, "\xde\x79\x3d\xa7\xab\x22\xa9\xaa\xfc\x05", "3nk9p6siqar8BQ=="},
    {10, "\x73\x62\x02\x77\x41\x91\xe6\x8b\x3f\x89", "c2ICd0GR5os/iQ=="},
    {10, "\xf2\x09\xa9\x8b\x7c\x30\x26\x54\xf0\xd3", "8gmpi3wwJlTw0w=="},
    {10, "\x32\xc8\xcc\xfc\x47\xa3\xac\x20\x37\x39", "MsjM/EejrCA3OQ=="},
    {10, "\x32\x1b\x2b\x36\x07\x76\x90\xfa\xe0\x04", "MhsrNgd2kPrgBA=="},
    {10, "\x55\x6b\x11\xe4\xc2\x22\xb0\x40\x14\x53", "VWsR5MIisEAUUw=="},
    {10, "\xd3\x1e\xc4\xe5\x06\x60\x37\x51\x10\x48", "0x7E5QZgN1EQSA=="},
    {11, "\x4c\xde\xee\xb8\x68\x0d\x9c\x66\x3e\xea\x46", "TN7uuGgNnGY+6kY="},
    {11, "\x36\x79\x11\x5c\xce\xd0\xdf\x3c\xd2\xc9\x45", "NnkRXM7Q3zzSyUU="},
    {11, "\xa0\x78\xc3\xc0\x79\xaf\xa1\xc3\xef\xd5\xf3", "oHjDwHmvocPv1fM="},
    {11, "\xdd\x6b\x78\x18\x95\x80\x99\x7a\x02\x41\xe8", "3Wt4GJWAmXoCQeg="},
    {11, "\x18\xfa\x19\xe0\xce\x3b\x0a\xa1\xec\x2b\x30", "GPoZ4M47CqHsKzA="},
    {11, "\x74\xf2\x96\x90\x95\xbe\x14\x64\xbf\x10\xd9", "dPKWkJW+FGS/ENk="},
    {11, "\x7f\xe8\x18\xab\xeb\x28\x86\xf1\x7c\x75\x47", "f+gYq+sohvF8dUc="},
    {11, "\xa4\xc9\x62\x73\x0e\x89\xe1\x51\x8b\xf0\x96", "pMlicw6J4VGL8JY="},
    {11, "\x98\xae\x09\x8c\x61\x40\xbf\x77\xde\xd9\x0d", "mK4JjGFAv3fe2Q0="},
    {11, "\x86\x39\x06\xa1\xc6\xfc\xcf\x30\x21\xba\xdf", "hjkGocb8zzAhut8="},
};

void ExpectEncodeDecodeSizesMatch(const EncodedData& data) {
  const size_t actual_encoded_size = std::strlen(data.encoded_data);
  const size_t actual_raw_size = data.binary_size;

  // Encoded size.
  ASSERT_EQ(EncodedSize(data.binary_size), actual_encoded_size);
  ASSERT_EQ(PW_BASE64_ENCODED_SIZE(data.binary_size), actual_encoded_size);

  // Max decoded size. Do upper & lower bounds.
  ASSERT_GE(MaxDecodedSize(actual_encoded_size), actual_raw_size);
  ASSERT_GE(PW_BASE64_MAX_DECODED_SIZE(actual_encoded_size), actual_raw_size);
  ASSERT_LE(MaxDecodedSize(actual_encoded_size), actual_raw_size + 2);
  ASSERT_LE(PW_BASE64_MAX_DECODED_SIZE(actual_encoded_size),
            actual_raw_size + 2);
}

// Tests both the C++ constexpr variant and the C macro variant.
TEST(Base64, EncodedAndDecodedSize) {
  for (const EncodedData& data : kSingleCharTestData) {
    ExpectEncodeDecodeSizesMatch(data);
  }
  for (const EncodedData& data : kRandomTestData) {
    ExpectEncodeDecodeSizesMatch(data);
  }
}

TEST(Base64, Encode_SingleChar) {
  char output[32];
  for (const EncodedData& data : kSingleCharTestData) {
    const size_t size = EncodedSize(data.binary_size);
    ASSERT_EQ(std::strlen(data.encoded_data), size);
    Encode(std::as_bytes(std::span(data.binary_data, data.binary_size)),
           output);
    output[size] = '\0';
    EXPECT_STREQ(data.encoded_data, output);
  }
}

TEST(Base64, Encode_RandomData) {
  char output[128];
  for (const EncodedData& data : kRandomTestData) {
    const size_t size = EncodedSize(data.binary_size);
    ASSERT_EQ(std::strlen(data.encoded_data), size);
    Encode(std::as_bytes(std::span(data.binary_data, data.binary_size)),
           output);
    output[size] = '\0';
    EXPECT_STREQ(data.encoded_data, output);
  }
}

TEST(Base64, Encode_BoundaryCheck) {
  constexpr std::byte data[] = {std::byte{'h'}, std::byte{'i'}};
  char output[5] = {};

  EXPECT_EQ(0u, Encode(data, std::span(output, 3)));
  EXPECT_STREQ("", output);
  EXPECT_EQ(4u, Encode(data, std::span(output, 4)));
  EXPECT_STREQ("aGk=", output);
}

TEST(Base64, Decode_SingleChar) {
  char output[32];
  for (const EncodedData& data : kSingleCharTestData) {
    size_t binary_size = Decode(data.encoded_data, output);
    ASSERT_EQ(binary_size, data.binary_size);
    EXPECT_EQ(0, std::memcmp(data.binary_data, output, data.binary_size));
  }
}

TEST(Base64, Decode_RandomData) {
  char output[128];
  for (const EncodedData& data : kRandomTestData) {
    size_t binary_size = Decode(data.encoded_data, output);
    ASSERT_EQ(binary_size, data.binary_size);
    EXPECT_EQ(0, std::memcmp(data.binary_data, output, data.binary_size));
  }
}

TEST(Base64, Decode_BoundaryCheck) {
  constexpr const char encoded_data[] = "aGk=";
  std::byte output[4] = {};

  EXPECT_EQ(0u, Decode(encoded_data, std::span(output, 2)));
  EXPECT_STREQ("", reinterpret_cast<const char*>(output));
  EXPECT_EQ(2u, Decode(encoded_data, std::span(output, 3)));
  EXPECT_STREQ("hi", reinterpret_cast<const char*>(output));
}

TEST(Base64, Decode_InPlace) {
  constexpr const char expected[] = "This is a secret message";
  char buf[] = "VGhpcyBpcyBhIHNlY3JldCBtZXNzYWdl";
  EXPECT_EQ(sizeof(expected) - 1, Decode(buf, buf));
  EXPECT_EQ(0, std::memcmp(expected, buf, sizeof(expected) - 1));
}

TEST(Base64, Decode_UrlSafeDecode) {
  char output[9] = {};

  EXPECT_TRUE(IsValid("+f//WW8h"));
  EXPECT_TRUE(IsValid("-f__WW8h"));

  EXPECT_EQ(6u, Decode("-f__WW8h", output));
  EXPECT_STREQ("\xf9\xff\xffYo!", output);
}

TEST(Base64, Empty) {
  char buffer[] = "DO NOT TOUCH";
  EXPECT_EQ(0u, EncodedSize(0));
  Encode(std::as_bytes(std::span("Something cool!!!", 0)), buffer);
  EXPECT_STREQ("DO NOT TOUCH", buffer);

  EXPECT_EQ(0u, MaxDecodedSize(0));
  EXPECT_EQ(0u, Decode(std::string_view("nothing please", 0), buffer));
  EXPECT_STREQ("DO NOT TOUCH", buffer);
}

TEST(Base64, ExampleFromRfc3548Section7) {
  constexpr uint8_t input[] = {0x14, 0xfb, 0x9c, 0x03, 0xd9, 0x7e};
  char output[EncodedSize(sizeof(input)) + 1] = {};

  Encode(std::as_bytes(std::span(input)), output);
  EXPECT_STREQ("FPucA9l+", output);
  Encode(std::as_bytes(std::span(input, 5)), output);
  EXPECT_STREQ("FPucA9k=", output);
  Encode(std::as_bytes(std::span(input, 4)), output);
  EXPECT_STREQ("FPucAw==", output);

  EXPECT_EQ(6u, Decode("FPucA9l+", output));
  EXPECT_EQ(0, std::memcmp(input, output, 6));
  EXPECT_EQ(5u, Decode("FPucA9k=", output));
  EXPECT_EQ(0, std::memcmp(input, output, 5));
  EXPECT_EQ(4u, Decode("FPucAw==", output));
  EXPECT_EQ(0, std::memcmp(input, output, 4));
}

TEST(Base64, ExampleFromRfc4648Section9) {
  char output[EncodedSize(sizeof("foobar")) + 1] = {};
  const std::byte* foobar = reinterpret_cast<const std::byte*>("foobar");

  Encode(std::span(foobar, 0), output);
  EXPECT_STREQ("", output);
  Encode(std::span(foobar, 1), output);
  EXPECT_STREQ("Zg==", output);
  Encode(std::span(foobar, 2), output);
  EXPECT_STREQ("Zm8=", output);
  Encode(std::span(foobar, 3), output);
  EXPECT_STREQ("Zm9v", output);
  Encode(std::span(foobar, 4), output);
  EXPECT_STREQ("Zm9vYg==", output);
  Encode(std::span(foobar, 5), output);
  EXPECT_STREQ("Zm9vYmE=", output);
  Encode(std::span(foobar, 6), output);
  EXPECT_STREQ("Zm9vYmFy", output);

  std::memset(output, '\0', sizeof(output));
  EXPECT_EQ(0u, Decode("", output));
  EXPECT_STREQ("", output);
  EXPECT_EQ(1u, Decode("Zg==", output));
  EXPECT_STREQ("f", output);
  EXPECT_EQ(2u, Decode("Zm8=", output));
  EXPECT_STREQ("fo", output);
  EXPECT_EQ(3u, Decode("Zm9v", output));
  EXPECT_STREQ("foo", output);
  EXPECT_EQ(4u, Decode("Zm9vYg==", output));
  EXPECT_STREQ("foob", output);
  EXPECT_EQ(5u, Decode("Zm9vYmE=", output));
  EXPECT_STREQ("fooba", output);
  EXPECT_EQ(6u, Decode("Zm9vYmFy", output));
  EXPECT_STREQ("foobar", output);
}

// Functions that call the Base64 API from C. These are defined in
// base64_test.c; no point in having a separate header.
extern "C" {

void pw_Base64CallEncode(const void* binary_data,
                         const size_t binary_size_bytes,
                         char* output);

size_t pw_Base64CallDecode(const char* base64,
                           size_t base64_size_bytes,
                           void* output);

bool pw_Base64CallIsValid(const char* base64_data, size_t base64_size);

}  // extern "C"

constexpr const char kBase64[] = "aaaabbbbcc#%";

// Ensure that the C API works correctly from a C-only context.
TEST(Base64, IsValid_Ok) {
  EXPECT_TRUE(IsValid(std::string_view(kBase64, 4)));
  EXPECT_TRUE(IsValid(std::string_view(kBase64, 8)));
}

TEST(Base64, IsValid_IncorrectSize) {
  EXPECT_FALSE(IsValid(std::string_view(kBase64, 5)));
  EXPECT_FALSE(IsValid(std::string_view(kBase64, 6)));
  EXPECT_FALSE(IsValid(std::string_view(kBase64, 7)));
  EXPECT_FALSE(IsValid(std::string_view(kBase64, 10)));
}

TEST(Base64, IsValid_InvalidCharacters) {
  EXPECT_FALSE(IsValid(std::string_view(kBase64, 11)));
  EXPECT_FALSE(IsValid(std::string_view(kBase64, 12)));
}

TEST(Base64CLinkage, IsValid_Ok) {
  EXPECT_TRUE(pw_Base64CallIsValid(kBase64, 4));
  EXPECT_TRUE(pw_Base64CallIsValid(kBase64, 8));
}

TEST(Base64CLinkage, IsValid_IncorrectSize) {
  EXPECT_FALSE(pw_Base64CallIsValid(kBase64, 5));
  EXPECT_FALSE(pw_Base64CallIsValid(kBase64, 6));
  EXPECT_FALSE(pw_Base64CallIsValid(kBase64, 7));
  EXPECT_FALSE(pw_Base64CallIsValid(kBase64, 10));
}

TEST(Base64CLinkage, IsValid_InvalidCharacters) {
  EXPECT_FALSE(pw_Base64CallIsValid(kBase64, 11));
  EXPECT_FALSE(pw_Base64CallIsValid(kBase64, 12));
}

TEST(Base64CLinkage, Encode) {
  char output[EncodedSize(sizeof("foobar")) + 1] = {};

  pw_Base64CallEncode("", 0, output);
  EXPECT_STREQ("", output);
  pw_Base64CallEncode("f", 1, output);
  EXPECT_STREQ("Zg==", output);
  pw_Base64CallEncode("fo", 2, output);
}

TEST(Base64CLinkage, Decode) {
  char output[EncodedSize(sizeof("foobar")) + 1] = {};

  EXPECT_EQ(0u, pw_Base64CallDecode("", 0, output));
  EXPECT_STREQ("", output);
  EXPECT_EQ(1u, pw_Base64CallDecode("Zg==", 4, output));
  EXPECT_STREQ("f", output);
  EXPECT_EQ(2u, pw_Base64CallDecode("Zm8=", 4, output));
  EXPECT_STREQ("fo", output);
}

}  // namespace
}  // namespace pw::base64