Alawn/shadowsocks-libev
1
0
Fork 0
mirror of https://github.com/shadowsocks/shadowsocks-libev.git synced 2026-10-22 15:16:58 +00:00
Code Releases Activity

tests: port remaining C unit tests to the C++ test harness

Browse Source 
Convert acl, acl_literal, aead2022, base64, buffer, cache (legacy
reference), crypto, ipset, ipset_reference, json, netutils, ppbloom,
process, ref, ssurl and utils tests to test_helpers.hpp. ctest names are
unchanged; every assertion is kept. Build the ported sources with the
strict C++ warning set.
This commit is contained in:
Max Lv
2026-10-15 01:33:51 +08:00
parent d168986dc6
commit 678a891ef9
18 changed files with 1274 additions and 1169 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/test_base64_cpp.cpp
+52 -60
View File
@@ -1,116 +1,108 @@
#include <assert.h>
#include <string.h>
#include <stdint.h>
// SPDX-License-Identifier: GPL-3.0-or-later
// Base64 encoder/decoder (src/base64.cpp): round trips and invalid input.
#include <cstdint>
#include <cstring>
#include "base64.h"
#include "test_helpers.hpp"
static void
test_encode_decode(void)
namespace {
void test_encode_decode()
{
/* Known test vector: "Hello" */
const uint8_t input[] = "Hello";
char encoded[BASE64_SIZE(5)];
uint8_t decoded[5];
char *ret = base64_encode(encoded, sizeof(encoded), input, 5);
assert(ret != NULL);
assert(strlen(encoded) > 0);
SS_CHECK(ret != nullptr);
SS_CHECK(std::strlen(encoded) > 0);
int decoded_len = base64_decode(decoded, encoded, sizeof(decoded));
assert(decoded_len == 5);
assert(memcmp(decoded, input, 5) == 0);
SS_CHECK(decoded_len == 5);
SS_CHECK(std::memcmp(decoded, input, 5) == 0);
}
static void
test_empty_input(void)
void test_empty_input()
{
char encoded[BASE64_SIZE(0)];
char *ret = base64_encode(encoded, sizeof(encoded), (const uint8_t *)"", 0);
assert(ret != NULL);
assert(strlen(encoded) == 0);
char *ret = base64_encode(encoded, sizeof(encoded), reinterpret_cast<const uint8_t *>(""), 0);
SS_CHECK(ret != nullptr);
SS_CHECK(std::strlen(encoded) == 0);
}
static void
test_single_byte(void)
void test_single_byte()
{
const uint8_t input[] = { 0x41 }; /* 'A' */
const uint8_t input[] = { 0x41 }; // 'A'
char encoded[BASE64_SIZE(1)];
uint8_t decoded[1];
char *ret = base64_encode(encoded, sizeof(encoded), input, 1);
assert(ret != NULL);
SS_CHECK(base64_encode(encoded, sizeof(encoded), input, 1) != nullptr);
int decoded_len = base64_decode(decoded, encoded, sizeof(decoded));
assert(decoded_len == 1);
assert(decoded[0] == 0x41);
SS_CHECK(decoded_len == 1);
SS_CHECK(decoded[0] == 0x41);
}
static void
test_two_bytes(void)
void test_two_bytes()
{
const uint8_t input[] = { 0x41, 0x42 }; /* "AB" */
const uint8_t input[] = { 0x41, 0x42 }; // "AB"
char encoded[BASE64_SIZE(2)];
uint8_t decoded[2];
char *ret = base64_encode(encoded, sizeof(encoded), input, 2);
assert(ret != NULL);
SS_CHECK(base64_encode(encoded, sizeof(encoded), input, 2) != nullptr);
int decoded_len = base64_decode(decoded, encoded, sizeof(decoded));
assert(decoded_len == 2);
assert(decoded[0] == 0x41);
assert(decoded[1] == 0x42);
SS_CHECK(decoded_len == 2);
SS_CHECK(decoded[0] == 0x41);
SS_CHECK(decoded[1] == 0x42);
}
static void
test_three_bytes(void)
void test_three_bytes()
{
const uint8_t input[] = { 0x00, 0xFF, 0x80 };
char encoded[BASE64_SIZE(3)];
uint8_t decoded[3];
char *ret = base64_encode(encoded, sizeof(encoded), input, 3);
assert(ret != NULL);
SS_CHECK(base64_encode(encoded, sizeof(encoded), input, 3) != nullptr);
int decoded_len = base64_decode(decoded, encoded, sizeof(decoded));
assert(decoded_len == 3);
assert(decoded[0] == 0x00);
assert(decoded[1] == 0xFF);
assert(decoded[2] == 0x80);
SS_CHECK(decoded_len == 3);
SS_CHECK(decoded[0] == 0x00);
SS_CHECK(decoded[1] == 0xFF);
SS_CHECK(decoded[2] == 0x80);
}
static void
test_roundtrip_binary(void)
void test_roundtrip_binary()
{
const uint8_t input[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
10, 11, 12, 13, 14, 15, 16 };
const uint8_t input[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
char encoded[BASE64_SIZE(17)];
uint8_t decoded[17];
char *ret = base64_encode(encoded, sizeof(encoded), input, 17);
assert(ret != NULL);
SS_CHECK(base64_encode(encoded, sizeof(encoded), input, 17) != nullptr);
int decoded_len = base64_decode(decoded, encoded, sizeof(decoded));
assert(decoded_len == 17);
assert(memcmp(decoded, input, 17) == 0);
SS_CHECK(decoded_len == 17);
SS_CHECK(std::memcmp(decoded, input, 17) == 0);
}
static void
test_invalid_chars(void)
void test_invalid_chars()
{
/* Character '!' (ASCII 33) is below the base64 range start ('+' = 43) */
int decoded_len = base64_decode((uint8_t[4]){}, "!!!!", 4);
assert(decoded_len == -1);
// Character '!' (ASCII 33) is below the base64 range start ('+' = 43).
uint8_t out[4] = {};
SS_CHECK(base64_decode(out, "!!!!", 4) == -1);
}
int
main(void)
} // namespace
int main()
{
test_encode_decode();
test_empty_input();
test_single_byte();
test_two_bytes();
test_three_bytes();
test_roundtrip_binary();
test_invalid_chars();
SS_RUN(test_encode_decode);
SS_RUN(test_empty_input);
SS_RUN(test_single_byte);
SS_RUN(test_two_bytes);
SS_RUN(test_three_bytes);
SS_RUN(test_roundtrip_binary);
SS_RUN(test_invalid_chars);
return 0;
}