Electroneum
base58.cpp File Reference
#include "gtest/gtest.h"
#include <cstdint>
#include "common/base58.cpp"
#include "cryptonote_basic/cryptonote_basic_impl.h"
#include "serialization/binary_utils.h"
Include dependency graph for base58.cpp:

Go to the source code of this file.

Macros

#define MAKE_STR(arr)   std::string(arr, sizeof(arr) - 1)
 
#define TEST_uint_8be_to_64(expected, str)
 
#define TEST_uint_64_to_8be(num, expected_str)
 
#define TEST_encode_block(block, expected)
 
#define TEST_decode_block_pos(enc, expected)
 
#define TEST_decode_block_neg(enc)
 
#define TEST_encode(expected, data)
 
#define TEST_decode_pos(enc, expected)
 
#define TEST_decode_neg(enc)
 
#define TEST_encode_decode_addr(addr, tag, data)
 
#define TEST_decode_addr_neg(addr, test_name)
 

Functions

 TEST_uint_8be_to_64 (0x0000000000000001, "\")
 
 TEST_uint_8be_to_64 (0x0000000000000102, "\\")
 
 TEST_uint_8be_to_64 (0x0000000000010203, "\\\")
 
 TEST_uint_8be_to_64 (0x0000000001020304, "\\\\")
 
 TEST_uint_8be_to_64 (0x0000000102030405, "\\\\\")
 
 TEST_uint_8be_to_64 (0x0000010203040506, "\\\\\\")
 
 TEST_uint_8be_to_64 (0x0001020304050607, "\\\\\\\")
 
 TEST_uint_8be_to_64 (0x0102030405060708, "\\\\\\\\")
 
 TEST_uint_64_to_8be (0x0000000000000001, "\")
 
 TEST_uint_64_to_8be (0x0000000000000102, "\\")
 
 TEST_uint_64_to_8be (0x0000000000010203, "\\\")
 
 TEST_uint_64_to_8be (0x0000000001020304, "\\\\")
 
 TEST_uint_64_to_8be (0x0000000102030405, "\\\\\")
 
 TEST_uint_64_to_8be (0x0000010203040506, "\\\\\\")
 
 TEST_uint_64_to_8be (0x0001020304050607, "\\\\\\\")
 
 TEST_uint_64_to_8be (0x0102030405060708, "\\\\\\\\")
 
 TEST (reverse_alphabet, is_correct)
 
 TEST_encode_block ("\0", 11)
 
 TEST_encode_block ("\9", 1z)
 
 TEST_encode_block ("\F", 5Q)
 
 TEST_encode_block ("\0\0", 111)
 
 TEST_encode_block ("\0\9", 11z)
 
 TEST_encode_block ("\1\0", 15R)
 
 TEST_encode_block ("\F\F", LUv)
 
 TEST_encode_block ("\0\0\0", 11111)
 
 TEST_encode_block ("\0\0\9", 1111z)
 
 TEST_encode_block ("\1\0\0", 11LUw)
 
 TEST_encode_block ("\F\F\F", 2UzHL)
 
 TEST_encode_block ("\0\0\0\9", 11111z)
 
 TEST_encode_block ("\F\F\F\F", 7YXq9G)
 
 TEST_encode_block ("\0\0\0\0\9", 111111z)
 
 TEST_encode_block ("\F\F\F\F\F", VtB5VXc)
 
 TEST_encode_block ("\0\0\0\0\0\9", 11111111z)
 
 TEST_encode_block ("\F\F\F\F\F\F", 3CUsUpv9t)
 
 TEST_encode_block ("\0\0\0\0\0\0\9", 111111111z)
 
 TEST_encode_block ("\F\F\F\F\F\F\F", Ahg1opVcGW)
 
 TEST_encode_block ("\0\0\0\0\0\0\0\9", 1111111111z)
 
 TEST_encode_block ("\F\F\F\F\F\F\F\F", jpXCZedGfVQ)
 
 TEST_encode_block ("\0\0\0\0\0\0\0\0", 11111111111)
 
 TEST_encode_block ("\0\0\0\0\0\0\0\1", 11111111112)
 
 TEST_encode_block ("\0\0\0\0\0\0\0\8", 11111111119)
 
 TEST_encode_block ("\0\0\0\0\0\0\0\9", 1111111111A)
 
 TEST_encode_block ("\0\0\0\0\0\0\0\A", 11111111121)
 
 TEST_encode_block ("\0\F\F\F\F\F\F\F", 1Ahg1opVcGW)
 
 TEST_encode_block ("\6\5\0\3\6\8\9\7", 22222222222)
 
 TEST_encode_block ("\5\0\2\A\7\B\A\0", 1z111111111)
 
 TEST_decode_block_neg (1)
 
 TEST_decode_block_neg (z)
 
 TEST_decode_block_pos (11, "\0")
 
 TEST_decode_block_pos (5Q, "\F")
 
 TEST_decode_block_neg (5R)
 
 TEST_decode_block_neg (zz)
 
 TEST_decode_block_pos (111, "\0\0")
 
 TEST_decode_block_pos (LUv, "\F\F")
 
 TEST_decode_block_neg (LUw)
 
 TEST_decode_block_neg (zzz)
 
 TEST_decode_block_neg (1111)
 
 TEST_decode_block_neg (zzzz)
 
 TEST_decode_block_pos (11111, "\0\0\0")
 
 TEST_decode_block_pos (2UzHL, "\F\F\F")
 
 TEST_decode_block_neg (2UzHM)
 
 TEST_decode_block_neg (zzzzz)
 
 TEST_decode_block_pos (111111, "\0\0\0\0")
 
 TEST_decode_block_pos (7YXq9G, "\F\F\F\F")
 
 TEST_decode_block_neg (7YXq9H)
 
 TEST_decode_block_neg (zzzzzz)
 
 TEST_decode_block_pos (1111111, "\0\0\0\0\0")
 
 TEST_decode_block_pos (VtB5VXc, "\F\F\F\F\F")
 
 TEST_decode_block_neg (VtB5VXd)
 
 TEST_decode_block_neg (zzzzzzz)
 
 TEST_decode_block_neg (11111111)
 
 TEST_decode_block_neg (zzzzzzzz)
 
 TEST_decode_block_pos (111111111, "\0\0\0\0\0\0")
 
 TEST_decode_block_pos (3CUsUpv9t, "\F\F\F\F\F\F")
 
 TEST_decode_block_neg (3CUsUpv9u)
 
 TEST_decode_block_neg (zzzzzzzzz)
 
 TEST_decode_block_pos (1111111111, "\0\0\0\0\0\0\0")
 
 TEST_decode_block_pos (Ahg1opVcGW, "\F\F\F\F\F\F\F")
 
 TEST_decode_block_neg (Ahg1opVcGX)
 
 TEST_decode_block_neg (zzzzzzzzzz)
 
 TEST_decode_block_pos (11111111111, "\0\0\0\0\0\0\0\0")
 
 TEST_decode_block_pos (jpXCZedGfVQ, "\F\F\F\F\F\F\F\F")
 
 TEST_decode_block_neg (jpXCZedGfVR)
 
 TEST_decode_block_neg (zzzzzzzzzzz)
 
 TEST_decode_block_neg (01111111111)
 
 TEST_decode_block_neg (11111111110)
 
 TEST_decode_block_neg (11111011111)
 
 TEST_decode_block_neg (I1111111111)
 
 TEST_decode_block_neg (O1111111111)
 
 TEST_decode_block_neg (l1111111111)
 
 TEST_decode_block_neg (_1111111111)
 
 TEST_encode (11, "\0")
 
 TEST_encode (111, "\0\0")
 
 TEST_encode (11111, "\0\0\0")
 
 TEST_encode (111111, "\0\0\0\0")
 
 TEST_encode (1111111, "\0\0\0\0\0")
 
 TEST_encode (111111111, "\0\0\0\0\0\0")
 
 TEST_encode (1111111111, "\0\0\0\0\0\0\0")
 
 TEST_encode (11111111111, "\0\0\0\0\0\0\0\0")
 
 TEST_encode (1111111111111, "\0\0\0\0\0\0\0\0\0")
 
 TEST_encode (11111111111111, "\0\0\0\0\0\0\0\0\0\0")
 
 TEST_encode (1111111111111111, "\0\0\0\0\0\0\0\0\0\0\0")
 
 TEST_encode (11111111111111111, "\0\0\0\0\0\0\0\0\0\0\0\0")
 
 TEST_encode (111111111111111111, "\0\0\0\0\0\0\0\0\0\0\0\0\0")
 
 TEST_encode (11111111111111111111, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0")
 
 TEST_encode (111111111111111111111, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0")
 
 TEST_encode (1111111111111111111111, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0")
 
 TEST_encode (22222222222VtB5VXc, "\6\5\0\3\6\8\9\7\F\F\F\F\F")
 
 TEST_decode_pos (, "")
 
 TEST_decode_pos (5Q, "\F")
 
 TEST_decode_pos (LUv, "\F\F")
 
 TEST_decode_pos (2UzHL, "\F\F\F")
 
 TEST_decode_pos (7YXq9G, "\F\F\F\F")
 
 TEST_decode_pos (VtB5VXc, "\F\F\F\F\F")
 
 TEST_decode_pos (3CUsUpv9t, "\F\F\F\F\F\F")
 
 TEST_decode_pos (Ahg1opVcGW, "\F\F\F\F\F\F\F")
 
 TEST_decode_pos (jpXCZedGfVQ, "\F\F\F\F\F\F\F\F")
 
 TEST_decode_pos (jpXCZedGfVQ5Q, "\F\F\F\F\F\F\F\F\F")
 
 TEST_decode_pos (jpXCZedGfVQLUv, "\F\F\F\F\F\F\F\F\F\F")
 
 TEST_decode_pos (jpXCZedGfVQ2UzHL, "\F\F\F\F\F\F\F\F\F\F\F")
 
 TEST_decode_pos (jpXCZedGfVQ7YXq9G, "\F\F\F\F\F\F\F\F\F\F\F\F")
 
 TEST_decode_pos (jpXCZedGfVQVtB5VXc, "\F\F\F\F\F\F\F\F\F\F\F\F\F")
 
 TEST_decode_pos (jpXCZedGfVQ3CUsUpv9t, "\F\F\F\F\F\F\F\F\F\F\F\F\F\F")
 
 TEST_decode_pos (jpXCZedGfVQAhg1opVcGW, "\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F")
 
 TEST_decode_pos (jpXCZedGfVQjpXCZedGfVQ, "\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F")
 
 TEST_decode_neg (1)
 
 TEST_decode_neg (z)
 
 TEST_decode_neg (1111)
 
 TEST_decode_neg (zzzz)
 
 TEST_decode_neg (11111111)
 
 TEST_decode_neg (zzzzzzzz)
 
 TEST_decode_neg (123456789AB1)
 
 TEST_decode_neg (123456789ABz)
 
 TEST_decode_neg (123456789AB1111)
 
 TEST_decode_neg (123456789ABzzzz)
 
 TEST_decode_neg (123456789AB11111111)
 
 TEST_decode_neg (123456789ABzzzzzzzz)
 
 TEST_decode_neg (5R)
 
 TEST_decode_neg (zz)
 
 TEST_decode_neg (LUw)
 
 TEST_decode_neg (zzz)
 
 TEST_decode_neg (2UzHM)
 
 TEST_decode_neg (zzzzz)
 
 TEST_decode_neg (7YXq9H)
 
 TEST_decode_neg (zzzzzz)
 
 TEST_decode_neg (VtB5VXd)
 
 TEST_decode_neg (zzzzzzz)
 
 TEST_decode_neg (3CUsUpv9u)
 
 TEST_decode_neg (zzzzzzzzz)
 
 TEST_decode_neg (Ahg1opVcGX)
 
 TEST_decode_neg (zzzzzzzzzz)
 
 TEST_decode_neg (jpXCZedGfVR)
 
 TEST_decode_neg (zzzzzzzzzzz)
 
 TEST_decode_neg (123456789AB5R)
 
 TEST_decode_neg (123456789ABzz)
 
 TEST_decode_neg (123456789ABLUw)
 
 TEST_decode_neg (123456789ABzzz)
 
 TEST_decode_neg (123456789AB2UzHM)
 
 TEST_decode_neg (123456789ABzzzzz)
 
 TEST_decode_neg (123456789AB7YXq9H)
 
 TEST_decode_neg (123456789ABzzzzzz)
 
 TEST_decode_neg (123456789ABVtB5VXd)
 
 TEST_decode_neg (123456789ABzzzzzzz)
 
 TEST_decode_neg (123456789AB3CUsUpv9u)
 
 TEST_decode_neg (123456789ABzzzzzzzzz)
 
 TEST_decode_neg (123456789ABAhg1opVcGX)
 
 TEST_decode_neg (123456789ABzzzzzzzzzz)
 
 TEST_decode_neg (123456789ABjpXCZedGfVR)
 
 TEST_decode_neg (123456789ABzzzzzzzzzzz)
 
 TEST_decode_neg (zzzzzzzzzzz11)
 
 TEST_decode_neg (10)
 
 TEST_decode_neg (11I)
 
 TEST_decode_neg (11O11)
 
 TEST_decode_neg (11l111)
 
 TEST_decode_neg (11_11111111)
 
 TEST_decode_neg (1101111111111)
 
 TEST_decode_neg (11I11111111111111)
 
 TEST_decode_neg (11O1111111111111111111)
 
 TEST_decode_neg (1111111111110)
 
 TEST_decode_neg (111111111111l1111)
 
 TEST_decode_neg (111111111111_111111111)
 
 TEST_encode_decode_addr (21D35quxec71111111111111111111111111111111111111111111111111111111111111111111111111111116Q5tCH, 6, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0")
 
 TEST_encode_decode_addr (2Aui6ejTFscjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQVqegMoV, 6, "\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F" "\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F")
 
 TEST_encode_decode_addr (1119XrkPuSmLzdHXgVgrZKjepg5hZAxffLzdHXgVgrZKjepg5hZAxffLzdHXgVgrZKjepg5hZAxffLzdHXgVgrZKVphZRvn, 0, "\0\1\2\3\4\5\6\7\8\9\A\B\C\D\E\F\0\1\2\3\4\5\6\7\8\9\A\B\C\D\E\F" "\0\1\2\3\4\5\6\7\8\9\A\B\C\D\E\F\0\1\2\3\4\5\6\7\8\9\A\B\C\D\E\F")
 
 TEST_encode_decode_addr (111111111111111111111111111111111111111111111111111111111111111111111111111111111111111115TXfiA, 0, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0")
 
 TEST_encode_decode_addr (PuT7GAdgbA83qvSEivPLYo11111111111111111111111111111111111111111111111111111111111111111111111111111169tWrH, 0x1122334455667788, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0")
 
 TEST_encode_decode_addr (PuT7GAdgbA841d7FXjswpJjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQVq4LL1v, 0x1122334455667788, "\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F" "\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F\F")
 
 TEST_encode_decode_addr (PuT7GAdgbA819VwdWVDP, 0x1122334455667788, "\1")
 
 TEST_encode_decode_addr (PuT7GAdgbA81efAfdCjPg, 0x1122334455667788, "\2\2")
 
 TEST_encode_decode_addr (PuT7GAdgbA83sryEt3YC8Q, 0x1122334455667788, "\3\3\3")
 
 TEST_encode_decode_addr (PuT7GAdgbA83tWUuc54PFP3b, 0x1122334455667788, "\4\4\4\4")
 
 TEST_encode_decode_addr (PuT7GAdgbA83u9zaKrtRKZ1J6, 0x1122334455667788, "\5\5\5\5\5")
 
 TEST_encode_decode_addr (PuT7GAdgbA83uoWF3eanGG1aRoG, 0x1122334455667788, "\6\6\6\6\6\6")
 
 TEST_encode_decode_addr (PuT7GAdgbA83vT1umSHMYJ4oNVdu, 0x1122334455667788, "\7\7\7\7\7\7\7")
 
 TEST_encode_decode_addr (PuT7GAdgbA83w6XaVDyvpoGQBEWbB, 0x1122334455667788, "\8\8\8\8\8\8\8\8")
 
 TEST_encode_decode_addr (PuT7GAdgbA83wk3FD1gW7J2KVGofA1r, 0x1122334455667788, "\9\9\9\9\9\9\9\9\9")
 
 TEST_encode_decode_addr (15p2yAV, 0, "")
 
 TEST_encode_decode_addr (FNQ3D6A, 0x7F, "")
 
 TEST_encode_decode_addr (26k9QWweu, 0x80, "")
 
 TEST_encode_decode_addr (3BzAD7n3y, 0xFF, "")
 
 TEST_encode_decode_addr (11efCaY6UjG7JrxuB, 0, "\1\2\3\4\5\6\7")
 
 TEST_encode_decode_addr (21rhHRT48LN4PriP9, 6, "\1\2\3\4\5\6\7")
 
 TEST_decode_addr_neg ("zuT7GAdgbA819VwdWVDP", decode_fails_due_overflow)
 
 TEST_decode_addr_neg ("0uT7GAdgbA819VwdWVDP", decode_fails_due_invalid_char_0)
 
 TEST_decode_addr_neg ("IuT7GAdgbA819VwdWVDP", decode_fails_due_invalid_char_I)
 
 TEST_decode_addr_neg ("OuT7GAdgbA819VwdWVDP", decode_fails_due_invalid_char_O)
 
 TEST_decode_addr_neg ("luT7GAdgbA819VwdWVDP", decode_fails_due_invalid_char_l)
 
 TEST_decode_addr_neg ("\T7GAdgbA819VwdWVDP", decode_fails_due_invalid_char_00)
 
 TEST_decode_addr_neg ("PuT7GAdgbA819VwdWVD", decode_fails_due_invalid_lenght)
 
 TEST_decode_addr_neg ("11efCaY6UjG7JrxuC", handles_invalid_checksum)
 
 TEST_decode_addr_neg ("jerj2e4mESo", handles_non_correct_tag)
 
 TEST_decode_addr_neg ("1", decode_fails_due_invalid_block_len_0)
 
 TEST_decode_addr_neg ("1111", decode_fails_due_invalid_block_len_1)
 
 TEST_decode_addr_neg ("11", decode_fails_due_address_too_short_0)
 
 TEST_decode_addr_neg ("111", decode_fails_due_address_too_short_1)
 
 TEST_decode_addr_neg ("11111", decode_fails_due_address_too_short_2)
 
 TEST_decode_addr_neg ("111111", decode_fails_due_address_too_short_3)
 
 TEST_decode_addr_neg ("999999", decode_fails_due_address_too_short_4)
 
 TEST_decode_addr_neg ("ZZZZZZ", decode_fails_due_address_too_short_5)
 
 TEST (get_account_address_as_str, works_correctly)
 
 TEST (get_account_address_from_str, handles_valid_address)
 
 TEST (get_account_address_from_str, fails_on_invalid_address_format)
 
 TEST (get_account_address_from_str, fails_on_invalid_address_prefix)
 
 TEST (get_account_address_from_str, fails_on_invalid_address_content)
 
 TEST (get_account_address_from_str, fails_on_invalid_address_spend_key)
 
 TEST (get_account_address_from_str, fails_on_invalid_address_view_key)
 
 TEST (get_account_address_from_str, parses_old_address_format)
 

Macro Definition Documentation

◆ MAKE_STR

#define MAKE_STR (   arr)    std::string(arr, sizeof(arr) - 1)

Definition at line 42 of file base58.cpp.

◆ TEST_decode_addr_neg

#define TEST_decode_addr_neg (   addr,
  test_name 
)
Value:
TEST(base58_decode_addr_neg, test_name) \
{ \
uint64_t tag; \
std::string data; \
ASSERT_FALSE(base58::decode_addr(MAKE_STR(addr), tag, data)); \
}
TEST(reverse_alphabet, is_correct)
Definition: base58.cpp:152
::std::string string
Definition: gtest-port.h:1097
bool decode_addr(const std::string &addr, uint64_t &tag, std::string &data)
Definition: base58.cpp:238
#define MAKE_STR(arr)
Definition: base58.cpp:42

Definition at line 437 of file base58.cpp.

◆ TEST_decode_block_neg

#define TEST_decode_block_neg (   enc)
Value:
TEST(base58_decode_block, handles_neg_##enc) \
{ \
do_test_decode_block_neg(#enc); \
}
TEST(reverse_alphabet, is_correct)
Definition: base58.cpp:152

Definition at line 216 of file base58.cpp.

◆ TEST_decode_block_pos

#define TEST_decode_block_pos (   enc,
  expected 
)
Value:
TEST(base58_decode_block, handles_pos_##enc) \
{ \
do_test_decode_block_pos(#enc, MAKE_STR(expected)); \
}
TEST(reverse_alphabet, is_correct)
Definition: base58.cpp:152
#define MAKE_STR(arr)
Definition: base58.cpp:42

Definition at line 210 of file base58.cpp.

◆ TEST_decode_neg

#define TEST_decode_neg (   enc)
Value:
TEST(base58_decode_neg, handles_neg_##enc) \
{ \
do_test_decode_neg(#enc); \
}
TEST(reverse_alphabet, is_correct)
Definition: base58.cpp:152

Definition at line 312 of file base58.cpp.

◆ TEST_decode_pos

#define TEST_decode_pos (   enc,
  expected 
)
Value:
TEST(base58_decode_pos, handles_pos_##enc) \
{ \
do_test_decode_pos(#enc, MAKE_STR(expected)); \
}
TEST(reverse_alphabet, is_correct)
Definition: base58.cpp:152
#define MAKE_STR(arr)
Definition: base58.cpp:42

Definition at line 306 of file base58.cpp.

◆ TEST_encode

#define TEST_encode (   expected,
  data 
)
Value:
TEST(base58_encode, handles_##expected) \
{ \
do_test_encode(MAKE_STR(data), #expected); \
}
TEST(reverse_alphabet, is_correct)
Definition: base58.cpp:152
#define MAKE_STR(arr)
Definition: base58.cpp:42

Definition at line 281 of file base58.cpp.

◆ TEST_encode_block

#define TEST_encode_block (   block,
  expected 
)
Value:
TEST(base58_encode_block, handles_##expected) \
{ \
do_test_encode_block(MAKE_STR(block), #expected); \
}
TEST(reverse_alphabet, is_correct)
Definition: base58.cpp:152
#define MAKE_STR(arr)
Definition: base58.cpp:42

Definition at line 169 of file base58.cpp.

◆ TEST_encode_decode_addr

#define TEST_encode_decode_addr (   addr,
  tag,
  data 
)
Value:
TEST(base58_encode_decode_addr, handles_##addr) \
{ \
do_test_encode_decode_addr(UINT64_C(tag), MAKE_STR(data), #addr); \
}
TEST(reverse_alphabet, is_correct)
Definition: base58.cpp:152
#define UINT64_C(val)
Definition: stdint.h:284
#define MAKE_STR(arr)
Definition: base58.cpp:42

Definition at line 396 of file base58.cpp.

◆ TEST_uint_64_to_8be

#define TEST_uint_64_to_8be (   num,
  expected_str 
)
Value:
TEST(base58_uint_64_to_8be, handles_bytes_##num) \
{ \
do_test_uint_64_to_8be(num, expected_str); \
}
TEST(reverse_alphabet, is_correct)
Definition: base58.cpp:152

Definition at line 137 of file base58.cpp.

◆ TEST_uint_8be_to_64

#define TEST_uint_8be_to_64 (   expected,
  str 
)
Value:
TEST(base58_uint_8be_to_64, handles_bytes_##expected) \
{ \
std::string data = str; \
do_test_uint_8be_to_64(expected, reinterpret_cast<const uint8_t*>(data.data()), data.size()); \
}
TEST(reverse_alphabet, is_correct)
Definition: base58.cpp:152
::std::string string
Definition: gtest-port.h:1097

Definition at line 120 of file base58.cpp.

Function Documentation

◆ TEST() [1/9]

TEST ( reverse_alphabet  ,
is_correct   
)

Definition at line 152 of file base58.cpp.

153 {
154  ASSERT_EQ(-1, base58::reverse_alphabet::instance(0));
155  ASSERT_EQ(-1, base58::reverse_alphabet::instance(std::numeric_limits<char>::min()));
156  ASSERT_EQ(-1, base58::reverse_alphabet::instance(std::numeric_limits<char>::max()));
157  ASSERT_EQ(-1, base58::reverse_alphabet::instance('1' - 1));
158  ASSERT_EQ(-1, base58::reverse_alphabet::instance('z' + 1));
159  ASSERT_EQ(-1, base58::reverse_alphabet::instance('0'));
160  ASSERT_EQ(-1, base58::reverse_alphabet::instance('I'));
161  ASSERT_EQ(-1, base58::reverse_alphabet::instance('O'));
162  ASSERT_EQ(-1, base58::reverse_alphabet::instance('l'));
163  ASSERT_EQ(0, base58::reverse_alphabet::instance('1'));
164  ASSERT_EQ(8, base58::reverse_alphabet::instance('9'));
165  ASSERT_EQ(base58::alphabet_size - 1, base58::reverse_alphabet::instance('z'));
166 }
#define ASSERT_EQ(val1, val2)
Definition: gtest.h:1956

◆ TEST() [2/9]

TEST ( get_account_address_as_str  ,
works_correctly   
)

Definition at line 474 of file base58.cpp.

475 {
477  ASSERT_TRUE(serialization::parse_binary(test_serialized_keys, addr));
479  ASSERT_EQ(addr_str, test_keys_addr_str);
480 }
std::string get_account_address_as_str(network_type nettype, bool subaddress, account_public_address const &adr)
::std::string string
Definition: gtest-port.h:1097
bool parse_binary(const std::string &blob, T &v)
Definition: binary_utils.h:41
#define ASSERT_EQ(val1, val2)
Definition: gtest.h:1956
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
Here is the call graph for this function:

◆ TEST() [3/9]

TEST ( get_account_address_from_str  ,
handles_valid_address   
)

Definition at line 482 of file base58.cpp.

483 {
486 
487  std::string blob;
489  ASSERT_EQ(blob, test_serialized_keys);
490 }
::std::string string
Definition: gtest-port.h:1097
bool dump_binary(T &v, std::string &blob)
Definition: binary_utils.h:51
#define ASSERT_EQ(val1, val2)
Definition: gtest.h:1956
CXA_THROW_INFO_T * info
Definition: stack_trace.cpp:91
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
bool get_account_address_from_str(address_parse_info &info, network_type nettype, std::string const &str)
Here is the call graph for this function:

◆ TEST() [4/9]

TEST ( get_account_address_from_str  ,
fails_on_invalid_address_format   
)

Definition at line 492 of file base58.cpp.

493 {
495  std::string addr_str = test_keys_addr_str;
496  addr_str[0] = '0';
497 
499 }
::std::string string
Definition: gtest-port.h:1097
#define ASSERT_FALSE(condition)
Definition: gtest.h:1868
CXA_THROW_INFO_T * info
Definition: stack_trace.cpp:91
bool get_account_address_from_str(address_parse_info &info, network_type nettype, std::string const &str)
Here is the call graph for this function:

◆ TEST() [5/9]

TEST ( get_account_address_from_str  ,
fails_on_invalid_address_prefix   
)

Definition at line 501 of file base58.cpp.

502 {
503  std::string addr_str = base58::encode_addr(0, test_serialized_keys);
504 
507 }
::std::string string
Definition: gtest-port.h:1097
#define ASSERT_FALSE(condition)
Definition: gtest.h:1868
std::string encode_addr(uint64_t tag, const std::string &data)
Definition: base58.cpp:228
CXA_THROW_INFO_T * info
Definition: stack_trace.cpp:91
bool get_account_address_from_str(address_parse_info &info, network_type nettype, std::string const &str)
Here is the call graph for this function:

◆ TEST() [6/9]

TEST ( get_account_address_from_str  ,
fails_on_invalid_address_content   
)

Definition at line 509 of file base58.cpp.

510 {
511  std::string addr_str = base58::encode_addr(config::CRYPTONOTE_PUBLIC_ADDRESS_BASE58_PREFIX, test_serialized_keys.substr(1));
512 
515 }
::std::string string
Definition: gtest-port.h:1097
#define ASSERT_FALSE(condition)
Definition: gtest.h:1868
std::string encode_addr(uint64_t tag, const std::string &data)
Definition: base58.cpp:228
uint64_t const CRYPTONOTE_PUBLIC_ADDRESS_BASE58_PREFIX
CXA_THROW_INFO_T * info
Definition: stack_trace.cpp:91
bool get_account_address_from_str(address_parse_info &info, network_type nettype, std::string const &str)
Here is the call graph for this function:

◆ TEST() [7/9]

TEST ( get_account_address_from_str  ,
fails_on_invalid_address_spend_key   
)

Definition at line 517 of file base58.cpp.

518 {
519  std::string serialized_keys_copy = test_serialized_keys;
520  serialized_keys_copy[0] = '\0';
522 
525 }
::std::string string
Definition: gtest-port.h:1097
#define ASSERT_FALSE(condition)
Definition: gtest.h:1868
std::string encode_addr(uint64_t tag, const std::string &data)
Definition: base58.cpp:228
uint64_t const CRYPTONOTE_PUBLIC_ADDRESS_BASE58_PREFIX
CXA_THROW_INFO_T * info
Definition: stack_trace.cpp:91
bool get_account_address_from_str(address_parse_info &info, network_type nettype, std::string const &str)
Here is the call graph for this function:

◆ TEST() [8/9]

TEST ( get_account_address_from_str  ,
fails_on_invalid_address_view_key   
)

Definition at line 527 of file base58.cpp.

528 {
529  std::string serialized_keys_copy = test_serialized_keys;
530  serialized_keys_copy.back() = '\x01';
532 
535 }
::std::string string
Definition: gtest-port.h:1097
#define ASSERT_FALSE(condition)
Definition: gtest.h:1868
std::string encode_addr(uint64_t tag, const std::string &data)
Definition: base58.cpp:228
uint64_t const CRYPTONOTE_PUBLIC_ADDRESS_BASE58_PREFIX
CXA_THROW_INFO_T * info
Definition: stack_trace.cpp:91
bool get_account_address_from_str(address_parse_info &info, network_type nettype, std::string const &str)
Here is the call graph for this function:

◆ TEST() [9/9]

TEST ( get_account_address_from_str  ,
parses_old_address_format   
)

Definition at line 537 of file base58.cpp.

538 {
540  ASSERT_TRUE(cryptonote::get_account_address_from_str(info, cryptonote::MAINNET, "002391bbbb24dea6fd95232e97594a27769d0153d053d2102b789c498f57a2b00b69cd6f2f5c529c1660f2f4a2b50178d6640c20ce71fe26373041af97c5b10236fc"));
541 }
CXA_THROW_INFO_T * info
Definition: stack_trace.cpp:91
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
bool get_account_address_from_str(address_parse_info &info, network_type nettype, std::string const &str)
Here is the call graph for this function:

◆ TEST_decode_addr_neg() [1/17]

TEST_decode_addr_neg ( "zuT7GAdgbA819VwdWVDP"  ,
decode_fails_due_overflow   
)

◆ TEST_decode_addr_neg() [2/17]

TEST_decode_addr_neg ( "0uT7GAdgbA819VwdWVDP"  ,
decode_fails_due_invalid_char_0   
)

◆ TEST_decode_addr_neg() [3/17]

TEST_decode_addr_neg ( "IuT7GAdgbA819VwdWVDP"  ,
decode_fails_due_invalid_char_I   
)

◆ TEST_decode_addr_neg() [4/17]

TEST_decode_addr_neg ( "OuT7GAdgbA819VwdWVDP"  ,
decode_fails_due_invalid_char_O   
)

◆ TEST_decode_addr_neg() [5/17]

TEST_decode_addr_neg ( "luT7GAdgbA819VwdWVDP"  ,
decode_fails_due_invalid_char_l   
)

◆ TEST_decode_addr_neg() [6/17]

TEST_decode_addr_neg ( "\GAdgbA819VwdWVDP"  ,
decode_fails_due_invalid_char_00   
)

◆ TEST_decode_addr_neg() [7/17]

TEST_decode_addr_neg ( "PuT7GAdgbA819VwdWVD"  ,
decode_fails_due_invalid_lenght   
)

◆ TEST_decode_addr_neg() [8/17]

TEST_decode_addr_neg ( "11efCaY6UjG7JrxuC"  ,
handles_invalid_checksum   
)

◆ TEST_decode_addr_neg() [9/17]

TEST_decode_addr_neg ( "jerj2e4mESo"  ,
handles_non_correct_tag   
)

◆ TEST_decode_addr_neg() [10/17]

TEST_decode_addr_neg ( "1"  ,
decode_fails_due_invalid_block_len_0   
)

◆ TEST_decode_addr_neg() [11/17]

TEST_decode_addr_neg ( "1111"  ,
decode_fails_due_invalid_block_len_1   
)

◆ TEST_decode_addr_neg() [12/17]

TEST_decode_addr_neg ( "11"  ,
decode_fails_due_address_too_short_0   
)

◆ TEST_decode_addr_neg() [13/17]

TEST_decode_addr_neg ( "111"  ,
decode_fails_due_address_too_short_1   
)

◆ TEST_decode_addr_neg() [14/17]

TEST_decode_addr_neg ( "11111"  ,
decode_fails_due_address_too_short_2   
)

◆ TEST_decode_addr_neg() [15/17]

TEST_decode_addr_neg ( "111111"  ,
decode_fails_due_address_too_short_3   
)

◆ TEST_decode_addr_neg() [16/17]

TEST_decode_addr_neg ( "999999"  ,
decode_fails_due_address_too_short_4   
)

◆ TEST_decode_addr_neg() [17/17]

TEST_decode_addr_neg ( "ZZZZZZ"  ,
decode_fails_due_address_too_short_5   
)

◆ TEST_decode_block_neg() [1/29]

TEST_decode_block_neg ( )

◆ TEST_decode_block_neg() [2/29]

TEST_decode_block_neg ( )

◆ TEST_decode_block_neg() [3/29]

TEST_decode_block_neg ( 5R  )

◆ TEST_decode_block_neg() [4/29]

TEST_decode_block_neg ( zz  )

◆ TEST_decode_block_neg() [5/29]

TEST_decode_block_neg ( LUw  )

◆ TEST_decode_block_neg() [6/29]

TEST_decode_block_neg ( zzz  )

◆ TEST_decode_block_neg() [7/29]

TEST_decode_block_neg ( 1111  )

◆ TEST_decode_block_neg() [8/29]

TEST_decode_block_neg ( zzzz  )

◆ TEST_decode_block_neg() [9/29]

TEST_decode_block_neg ( 2UzHM  )

◆ TEST_decode_block_neg() [10/29]

TEST_decode_block_neg ( zzzzz  )

◆ TEST_decode_block_neg() [11/29]

TEST_decode_block_neg ( 7YXq9H  )

◆ TEST_decode_block_neg() [12/29]

TEST_decode_block_neg ( zzzzzz  )

◆ TEST_decode_block_neg() [13/29]

TEST_decode_block_neg ( VtB5VXd  )

◆ TEST_decode_block_neg() [14/29]

TEST_decode_block_neg ( zzzzzzz  )

◆ TEST_decode_block_neg() [15/29]

TEST_decode_block_neg ( 11111111  )

◆ TEST_decode_block_neg() [16/29]

TEST_decode_block_neg ( zzzzzzzz  )

◆ TEST_decode_block_neg() [17/29]

TEST_decode_block_neg ( 3CUsUpv9u  )

◆ TEST_decode_block_neg() [18/29]

TEST_decode_block_neg ( zzzzzzzzz  )

◆ TEST_decode_block_neg() [19/29]

TEST_decode_block_neg ( Ahg1opVcGX  )

◆ TEST_decode_block_neg() [20/29]

TEST_decode_block_neg ( zzzzzzzzzz  )

◆ TEST_decode_block_neg() [21/29]

TEST_decode_block_neg ( jpXCZedGfVR  )

◆ TEST_decode_block_neg() [22/29]

TEST_decode_block_neg ( zzzzzzzzzzz  )

◆ TEST_decode_block_neg() [23/29]

TEST_decode_block_neg ( 01111111111  )

◆ TEST_decode_block_neg() [24/29]

TEST_decode_block_neg ( 11111111110  )

◆ TEST_decode_block_neg() [25/29]

TEST_decode_block_neg ( 11111011111  )

◆ TEST_decode_block_neg() [26/29]

TEST_decode_block_neg ( I1111111111  )

◆ TEST_decode_block_neg() [27/29]

TEST_decode_block_neg ( O1111111111  )

◆ TEST_decode_block_neg() [28/29]

TEST_decode_block_neg ( l1111111111  )

◆ TEST_decode_block_neg() [29/29]

TEST_decode_block_neg ( _1111111111  )

◆ TEST_decode_block_pos() [1/16]

TEST_decode_block_pos ( 11  ,
"\   
)

◆ TEST_decode_block_pos() [2/16]

TEST_decode_block_pos ( 5Q  ,
"\   
)

◆ TEST_decode_block_pos() [3/16]

TEST_decode_block_pos ( 111  ,
"\"   
)

◆ TEST_decode_block_pos() [4/16]

TEST_decode_block_pos ( LUv  ,
"\"   
)

◆ TEST_decode_block_pos() [5/16]

TEST_decode_block_pos ( 11111  ,
"\\   
)

◆ TEST_decode_block_pos() [6/16]

TEST_decode_block_pos ( 2UzHL  ,
"\\   
)

◆ TEST_decode_block_pos() [7/16]

TEST_decode_block_pos ( 111111  ,
"\\"   
)

◆ TEST_decode_block_pos() [8/16]

TEST_decode_block_pos ( 7YXq9G  ,
"\\"   
)

◆ TEST_decode_block_pos() [9/16]

TEST_decode_block_pos ( 1111111  ,
"\\\   
)

◆ TEST_decode_block_pos() [10/16]

TEST_decode_block_pos ( VtB5VXc  ,
"\\\   
)

◆ TEST_decode_block_pos() [11/16]

TEST_decode_block_pos ( 111111111  ,
"\\\"   
)

◆ TEST_decode_block_pos() [12/16]

TEST_decode_block_pos ( 3CUsUpv9t  ,
"\\\"   
)

◆ TEST_decode_block_pos() [13/16]

TEST_decode_block_pos ( 1111111111  ,
"\\\\   
)

◆ TEST_decode_block_pos() [14/16]

TEST_decode_block_pos ( Ahg1opVcGW  ,
"\\\\   
)

◆ TEST_decode_block_pos() [15/16]

TEST_decode_block_pos ( 11111111111  ,
"\\\\"   
)

◆ TEST_decode_block_pos() [16/16]

TEST_decode_block_pos ( jpXCZedGfVQ  ,
"\\\\"   
)

◆ TEST_decode_neg() [1/56]

TEST_decode_neg ( )

◆ TEST_decode_neg() [2/56]

TEST_decode_neg ( )

◆ TEST_decode_neg() [3/56]

TEST_decode_neg ( 1111  )

◆ TEST_decode_neg() [4/56]

TEST_decode_neg ( zzzz  )

◆ TEST_decode_neg() [5/56]

TEST_decode_neg ( 11111111  )

◆ TEST_decode_neg() [6/56]

TEST_decode_neg ( zzzzzzzz  )

◆ TEST_decode_neg() [7/56]

TEST_decode_neg ( 123456789AB1  )

◆ TEST_decode_neg() [8/56]

TEST_decode_neg ( 123456789ABz  )

◆ TEST_decode_neg() [9/56]

TEST_decode_neg ( 123456789AB1111  )

◆ TEST_decode_neg() [10/56]

TEST_decode_neg ( 123456789ABzzzz  )

◆ TEST_decode_neg() [11/56]

TEST_decode_neg ( 123456789AB11111111  )

◆ TEST_decode_neg() [12/56]

TEST_decode_neg ( 123456789ABzzzzzzzz  )

◆ TEST_decode_neg() [13/56]

TEST_decode_neg ( 5R  )

◆ TEST_decode_neg() [14/56]

TEST_decode_neg ( zz  )

◆ TEST_decode_neg() [15/56]

TEST_decode_neg ( LUw  )

◆ TEST_decode_neg() [16/56]

TEST_decode_neg ( zzz  )

◆ TEST_decode_neg() [17/56]

TEST_decode_neg ( 2UzHM  )

◆ TEST_decode_neg() [18/56]

TEST_decode_neg ( zzzzz  )

◆ TEST_decode_neg() [19/56]

TEST_decode_neg ( 7YXq9H  )

◆ TEST_decode_neg() [20/56]

TEST_decode_neg ( zzzzzz  )

◆ TEST_decode_neg() [21/56]

TEST_decode_neg ( VtB5VXd  )

◆ TEST_decode_neg() [22/56]

TEST_decode_neg ( zzzzzzz  )

◆ TEST_decode_neg() [23/56]

TEST_decode_neg ( 3CUsUpv9u  )

◆ TEST_decode_neg() [24/56]

TEST_decode_neg ( zzzzzzzzz  )

◆ TEST_decode_neg() [25/56]

TEST_decode_neg ( Ahg1opVcGX  )

◆ TEST_decode_neg() [26/56]

TEST_decode_neg ( zzzzzzzzzz  )

◆ TEST_decode_neg() [27/56]

TEST_decode_neg ( jpXCZedGfVR  )

◆ TEST_decode_neg() [28/56]

TEST_decode_neg ( zzzzzzzzzzz  )

◆ TEST_decode_neg() [29/56]

TEST_decode_neg ( 123456789AB5R  )

◆ TEST_decode_neg() [30/56]

TEST_decode_neg ( 123456789ABzz  )

◆ TEST_decode_neg() [31/56]

TEST_decode_neg ( 123456789ABLUw  )

◆ TEST_decode_neg() [32/56]

TEST_decode_neg ( 123456789ABzzz  )

◆ TEST_decode_neg() [33/56]

TEST_decode_neg ( 123456789AB2UzHM  )

◆ TEST_decode_neg() [34/56]

TEST_decode_neg ( 123456789ABzzzzz  )

◆ TEST_decode_neg() [35/56]

TEST_decode_neg ( 123456789AB7YXq9H  )

◆ TEST_decode_neg() [36/56]

TEST_decode_neg ( 123456789ABzzzzzz  )

◆ TEST_decode_neg() [37/56]

TEST_decode_neg ( 123456789ABVtB5VXd  )

◆ TEST_decode_neg() [38/56]

TEST_decode_neg ( 123456789ABzzzzzzz  )

◆ TEST_decode_neg() [39/56]

TEST_decode_neg ( 123456789AB3CUsUpv9u  )

◆ TEST_decode_neg() [40/56]

TEST_decode_neg ( 123456789ABzzzzzzzzz  )

◆ TEST_decode_neg() [41/56]

TEST_decode_neg ( 123456789ABAhg1opVcGX  )

◆ TEST_decode_neg() [42/56]

TEST_decode_neg ( 123456789ABzzzzzzzzzz  )

◆ TEST_decode_neg() [43/56]

TEST_decode_neg ( 123456789ABjpXCZedGfVR  )

◆ TEST_decode_neg() [44/56]

TEST_decode_neg ( 123456789ABzzzzzzzzzzz  )

◆ TEST_decode_neg() [45/56]

TEST_decode_neg ( zzzzzzzzzzz11  )

◆ TEST_decode_neg() [46/56]

TEST_decode_neg ( 10  )

◆ TEST_decode_neg() [47/56]

TEST_decode_neg ( 11I  )

◆ TEST_decode_neg() [48/56]

TEST_decode_neg ( 11O11  )

◆ TEST_decode_neg() [49/56]

TEST_decode_neg ( 11l111  )

◆ TEST_decode_neg() [50/56]

TEST_decode_neg ( 11_11111111  )

◆ TEST_decode_neg() [51/56]

TEST_decode_neg ( 1101111111111  )

◆ TEST_decode_neg() [52/56]

TEST_decode_neg ( 11I11111111111111  )

◆ TEST_decode_neg() [53/56]

TEST_decode_neg ( 11O1111111111111111111  )

◆ TEST_decode_neg() [54/56]

TEST_decode_neg ( 1111111111110  )

◆ TEST_decode_neg() [55/56]

TEST_decode_neg ( 111111111111l1111  )

◆ TEST_decode_neg() [56/56]

TEST_decode_neg ( 111111111111_111111111  )

◆ TEST_decode_pos() [1/17]

TEST_decode_pos ( ""  )

◆ TEST_decode_pos() [2/17]

TEST_decode_pos ( 5Q  ,
"\   
)

◆ TEST_decode_pos() [3/17]

TEST_decode_pos ( LUv  ,
"\"   
)

◆ TEST_decode_pos() [4/17]

TEST_decode_pos ( 2UzHL  ,
"\\   
)

◆ TEST_decode_pos() [5/17]

TEST_decode_pos ( 7YXq9G  ,
"\\"   
)

◆ TEST_decode_pos() [6/17]

TEST_decode_pos ( VtB5VXc  ,
"\\\   
)

◆ TEST_decode_pos() [7/17]

TEST_decode_pos ( 3CUsUpv9t  ,
"\\\"   
)

◆ TEST_decode_pos() [8/17]

TEST_decode_pos ( Ahg1opVcGW  ,
"\\\\   
)

◆ TEST_decode_pos() [9/17]

TEST_decode_pos ( jpXCZedGfVQ  ,
"\\\\"   
)

◆ TEST_decode_pos() [10/17]

TEST_decode_pos ( jpXCZedGfVQ5Q  ,
"\\\\\   
)

◆ TEST_decode_pos() [11/17]

TEST_decode_pos ( jpXCZedGfVQLUv  ,
"\\\\\"   
)

◆ TEST_decode_pos() [12/17]

TEST_decode_pos ( jpXCZedGfVQ2UzHL  ,
"\\\\\\   
)

◆ TEST_decode_pos() [13/17]

TEST_decode_pos ( jpXCZedGfVQ7YXq9G  ,
"\\\\\\"   
)

◆ TEST_decode_pos() [14/17]

TEST_decode_pos ( jpXCZedGfVQVtB5VXc  ,
"\\\\\\\   
)

◆ TEST_decode_pos() [15/17]

TEST_decode_pos ( jpXCZedGfVQ3CUsUpv9t  ,
"\\\\\\\"   
)

◆ TEST_decode_pos() [16/17]

TEST_decode_pos ( jpXCZedGfVQAhg1opVcGW  ,
"\\\\\\\\   
)

◆ TEST_decode_pos() [17/17]

TEST_decode_pos ( jpXCZedGfVQjpXCZedGfVQ  ,
"\\\\\\\\"   
)

◆ TEST_encode() [1/17]

TEST_encode ( 11  ,
"\   
)

◆ TEST_encode() [2/17]

TEST_encode ( 111  ,
"\"   
)

◆ TEST_encode() [3/17]

TEST_encode ( 11111  ,
"\\   
)

◆ TEST_encode() [4/17]

TEST_encode ( 111111  ,
"\\"   
)

◆ TEST_encode() [5/17]

TEST_encode ( 1111111  ,
"\\\   
)

◆ TEST_encode() [6/17]

TEST_encode ( 111111111  ,
"\\\"   
)

◆ TEST_encode() [7/17]

TEST_encode ( 1111111111  ,
"\\\\   
)

◆ TEST_encode() [8/17]

TEST_encode ( 11111111111  ,
"\\\\"   
)

◆ TEST_encode() [9/17]

TEST_encode ( 1111111111111  ,
"\\\\\   
)

◆ TEST_encode() [10/17]

TEST_encode ( 11111111111111  ,
"\\\\\"   
)

◆ TEST_encode() [11/17]

TEST_encode ( 1111111111111111  ,
"\\\\\\   
)

◆ TEST_encode() [12/17]

TEST_encode ( 11111111111111111  ,
"\\\\\\"   
)

◆ TEST_encode() [13/17]

TEST_encode ( 111111111111111111  ,
"\\\\\\\   
)

◆ TEST_encode() [14/17]

TEST_encode ( 11111111111111111111  ,
"\\\\\\\"   
)

◆ TEST_encode() [15/17]

TEST_encode ( 111111111111111111111  ,
"\\\\\\\\   
)

◆ TEST_encode() [16/17]

TEST_encode ( 1111111111111111111111  ,
"\\\\\\\\"   
)

◆ TEST_encode() [17/17]

TEST_encode ( 22222222222VtB5VXc  ,
"\\\\\\\   
)

◆ TEST_encode_block() [1/29]

TEST_encode_block ( "\  ,
11   
)

◆ TEST_encode_block() [2/29]

TEST_encode_block ( "\  ,
1z   
)

◆ TEST_encode_block() [3/29]

TEST_encode_block ( "\  ,
5Q   
)

◆ TEST_encode_block() [4/29]

TEST_encode_block ( "\"  ,
111   
)

◆ TEST_encode_block() [5/29]

TEST_encode_block ( "\"  ,
11z   
)

◆ TEST_encode_block() [6/29]

TEST_encode_block ( "\"  ,
15R   
)

◆ TEST_encode_block() [7/29]

TEST_encode_block ( "\"  ,
LUv   
)

◆ TEST_encode_block() [8/29]

TEST_encode_block ( "\\  ,
11111   
)

◆ TEST_encode_block() [9/29]

TEST_encode_block ( "\\  ,
1111z   
)

◆ TEST_encode_block() [10/29]

TEST_encode_block ( "\\  ,
11LUw   
)

◆ TEST_encode_block() [11/29]

TEST_encode_block ( "\\  ,
2UzHL   
)

◆ TEST_encode_block() [12/29]

TEST_encode_block ( "\\"  ,
11111z   
)

◆ TEST_encode_block() [13/29]

TEST_encode_block ( "\\"  ,
7YXq9G   
)

◆ TEST_encode_block() [14/29]

TEST_encode_block ( "\\\  ,
111111z   
)

◆ TEST_encode_block() [15/29]

TEST_encode_block ( "\\\  ,
VtB5VXc   
)

◆ TEST_encode_block() [16/29]

TEST_encode_block ( "\\\"  ,
11111111z   
)

◆ TEST_encode_block() [17/29]

TEST_encode_block ( "\\\"  ,
3CUsUpv9t   
)

◆ TEST_encode_block() [18/29]

TEST_encode_block ( "\\\\  ,
111111111z   
)

◆ TEST_encode_block() [19/29]

TEST_encode_block ( "\\\\  ,
Ahg1opVcGW   
)

◆ TEST_encode_block() [20/29]

TEST_encode_block ( "\\\\"  ,
1111111111z   
)

◆ TEST_encode_block() [21/29]

TEST_encode_block ( "\\\\"  ,
jpXCZedGfVQ   
)

◆ TEST_encode_block() [22/29]

TEST_encode_block ( "\\\\"  ,
11111111111   
)

◆ TEST_encode_block() [23/29]

TEST_encode_block ( "\\\\"  ,
11111111112   
)

◆ TEST_encode_block() [24/29]

TEST_encode_block ( "\\\\"  ,
11111111119   
)

◆ TEST_encode_block() [25/29]

TEST_encode_block ( "\\\\"  ,
1111111111A   
)

◆ TEST_encode_block() [26/29]

TEST_encode_block ( "\\\\"  ,
11111111121   
)

◆ TEST_encode_block() [27/29]

TEST_encode_block ( "\\\\"  ,
1Ahg1opVcGW   
)

◆ TEST_encode_block() [28/29]

TEST_encode_block ( "\\\\"  ,
22222222222   
)

◆ TEST_encode_block() [29/29]

TEST_encode_block ( "\\\\"  ,
1z111111111   
)

◆ TEST_encode_decode_addr() [1/21]

TEST_encode_decode_addr ( 21D35quxec71111111111111111111111111111111111111111111111111111111111111111111111111111116Q5tCH  ,
,
"\\\\\\\\\\\\\\\\" "\\\\\\\\\\\\\\\\"   
)

◆ TEST_encode_decode_addr() [2/21]

TEST_encode_decode_addr ( 2Aui6ejTFscjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQVqegMoV  ,
,
"\\\\\\\\\\\\\\\\" "\\\\\\\\\\\\\\\\"   
)

◆ TEST_encode_decode_addr() [3/21]

TEST_encode_decode_addr ( 1119XrkPuSmLzdHXgVgrZKjepg5hZAxffLzdHXgVgrZKjepg5hZAxffLzdHXgVgrZKjepg5hZAxffLzdHXgVgrZKVphZRvn  ,
,
"\\\\\\\\\\\\\\\\" "\\\\\\\\\\\\\\\\"   
)

◆ TEST_encode_decode_addr() [4/21]

TEST_encode_decode_addr ( 111111111111111111111111111111111111111111111111111111111111111111111111111111111111111115TXfiA  ,
,
"\\\\\\\\\\\\\\\\" "\\\\\\\\\\\\\\\\"   
)

◆ TEST_encode_decode_addr() [5/21]

TEST_encode_decode_addr ( PuT7GAdgbA83qvSEivPLYo11111111111111111111111111111111111111111111111111111111111111111111111111111169tWrH  ,
0x1122334455667788  ,
"\\\\\\\\\\\\\\\\" "\\\\\\\\\\\\\\\\"   
)

◆ TEST_encode_decode_addr() [6/21]

TEST_encode_decode_addr ( PuT7GAdgbA841d7FXjswpJjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQVq4LL1v  ,
0x1122334455667788  ,
"\\\\\\\\\\\\\\\\" "\\\\\\\\\\\\\\\\"   
)

◆ TEST_encode_decode_addr() [7/21]

TEST_encode_decode_addr ( PuT7GAdgbA819VwdWVDP  ,
0x1122334455667788  ,
"\   
)

◆ TEST_encode_decode_addr() [8/21]

TEST_encode_decode_addr ( PuT7GAdgbA81efAfdCjPg  ,
0x1122334455667788  ,
"\"   
)

◆ TEST_encode_decode_addr() [9/21]

TEST_encode_decode_addr ( PuT7GAdgbA83sryEt3YC8Q  ,
0x1122334455667788  ,
"\\   
)

◆ TEST_encode_decode_addr() [10/21]

TEST_encode_decode_addr ( PuT7GAdgbA83tWUuc54PFP3b  ,
0x1122334455667788  ,
"\\"   
)

◆ TEST_encode_decode_addr() [11/21]

TEST_encode_decode_addr ( PuT7GAdgbA83u9zaKrtRKZ1J6  ,
0x1122334455667788  ,
"\\\   
)

◆ TEST_encode_decode_addr() [12/21]

TEST_encode_decode_addr ( PuT7GAdgbA83uoWF3eanGG1aRoG  ,
0x1122334455667788  ,
"\\\"   
)

◆ TEST_encode_decode_addr() [13/21]

TEST_encode_decode_addr ( PuT7GAdgbA83vT1umSHMYJ4oNVdu  ,
0x1122334455667788  ,
"\\\\   
)

◆ TEST_encode_decode_addr() [14/21]

TEST_encode_decode_addr ( PuT7GAdgbA83w6XaVDyvpoGQBEWbB  ,
0x1122334455667788  ,
"\\\\"   
)

◆ TEST_encode_decode_addr() [15/21]

TEST_encode_decode_addr ( PuT7GAdgbA83wk3FD1gW7J2KVGofA1r  ,
0x1122334455667788  ,
"\\\\\   
)

◆ TEST_encode_decode_addr() [16/21]

TEST_encode_decode_addr ( 15p2yAV  ,
,
""   
)

◆ TEST_encode_decode_addr() [17/21]

TEST_encode_decode_addr ( FNQ3D6A  ,
0x7F  ,
""   
)

◆ TEST_encode_decode_addr() [18/21]

TEST_encode_decode_addr ( 26k9QWweu  ,
0x80  ,
""   
)

◆ TEST_encode_decode_addr() [19/21]

TEST_encode_decode_addr ( 3BzAD7n3y  ,
0xFF  ,
""   
)

◆ TEST_encode_decode_addr() [20/21]

TEST_encode_decode_addr ( 11efCaY6UjG7JrxuB  ,
,
"\\\\   
)

◆ TEST_encode_decode_addr() [21/21]

TEST_encode_decode_addr ( 21rhHRT48LN4PriP9  ,
,
"\\\\   
)

◆ TEST_uint_64_to_8be() [1/8]

TEST_uint_64_to_8be ( 0x0000000000000001  ,
"\   
)

◆ TEST_uint_64_to_8be() [2/8]

TEST_uint_64_to_8be ( 0x0000000000000102  ,
"\   
)

◆ TEST_uint_64_to_8be() [3/8]

TEST_uint_64_to_8be ( 0x0000000000010203  ,
"\   
)

◆ TEST_uint_64_to_8be() [4/8]

TEST_uint_64_to_8be ( 0x0000000001020304  ,
"\"   
)

◆ TEST_uint_64_to_8be() [5/8]

TEST_uint_64_to_8be ( 0x0000000102030405  ,
"\\   
)

◆ TEST_uint_64_to_8be() [6/8]

TEST_uint_64_to_8be ( 0x0000010203040506  ,
"\\   
)

◆ TEST_uint_64_to_8be() [7/8]

TEST_uint_64_to_8be ( 0x0001020304050607  ,
"\\   
)

◆ TEST_uint_64_to_8be() [8/8]

TEST_uint_64_to_8be ( 0x0102030405060708  ,
"\\"   
)

◆ TEST_uint_8be_to_64() [1/8]

TEST_uint_8be_to_64 ( 0x0000000000000001  ,
"\   
)

◆ TEST_uint_8be_to_64() [2/8]

TEST_uint_8be_to_64 ( 0x0000000000000102  ,
"\   
)

◆ TEST_uint_8be_to_64() [3/8]

TEST_uint_8be_to_64 ( 0x0000000000010203  ,
"\   
)

◆ TEST_uint_8be_to_64() [4/8]

TEST_uint_8be_to_64 ( 0x0000000001020304  ,
"\"   
)

◆ TEST_uint_8be_to_64() [5/8]

TEST_uint_8be_to_64 ( 0x0000000102030405  ,
"\\   
)

◆ TEST_uint_8be_to_64() [6/8]

TEST_uint_8be_to_64 ( 0x0000010203040506  ,
"\\   
)

◆ TEST_uint_8be_to_64() [7/8]

TEST_uint_8be_to_64 ( 0x0001020304050607  ,
"\\   
)

◆ TEST_uint_8be_to_64() [8/8]

TEST_uint_8be_to_64 ( 0x0102030405060708  ,
"\\"   
)