test_base85.cpp

Go to the documentation of this file.

/* SPDX-License-Identifier: MPL-2.0 */
 
#include "testutil.hpp"
#include "testutil_unity.hpp"
 
void setUp ()
{
}
 
void tearDown ()
{
}
 
// Test vector: rfc.zeromq.org/spec:32/Z85
void test__zmq_z85_encode__valid__success ()
{
    static const size_t size = 8;
    static const size_t length = size * 5 / 4;
    static const uint8_t decoded[size] = {0x86, 0x4F, 0xD2, 0x6F,
                                          0xB5, 0x59, 0xF7, 0x5B};
    static const char expected[length + 1] = "HelloWorld";
    char out_encoded[length + 1] = {0};
 
    errno = 0;
    TEST_ASSERT_NOT_NULL (zmq_z85_encode (out_encoded, decoded, size));
    TEST_ASSERT_EQUAL_STRING (expected, out_encoded);
    TEST_ASSERT_EQUAL_INT (0, zmq_errno ());
}
 
// Buffer length must be evenly divisible by 4 or must fail with EINVAL.
void test__zmq_z85_encode__invalid__failure (size_t size_)
{
    errno = 0;
    TEST_ASSERT_NULL (zmq_z85_encode (NULL, NULL, size_));
    TEST_ASSERT_EQUAL_INT (EINVAL, zmq_errno ());
}
 
// Test vector: rfc.zeromq.org/spec:32/Z85
void test__zmq_z85_decode__valid__success ()
{
    static const size_t size = 10 * 4 / 5;
    static const uint8_t expected[size] = {0x86, 0x4F, 0xD2, 0x6F,
                                           0xB5, 0x59, 0xF7, 0x5B};
    static const char *encoded = "HelloWorld";
    uint8_t out_decoded[size] = {0};
 
    errno = 0;
    TEST_ASSERT_NOT_NULL (zmq_z85_decode (out_decoded, encoded));
    TEST_ASSERT_EQUAL_INT (0, zmq_errno ());
    TEST_ASSERT_EQUAL_UINT8_ARRAY (expected, out_decoded, size);
}
 
// Invalid input data must fail with EINVAL.
template <size_t SIZE>
void test__zmq_z85_decode__invalid__failure (const char (&encoded_)[SIZE])
{
    uint8_t decoded[SIZE * 4 / 5 + 1];
    errno = 0;
    TEST_ASSERT_NULL (zmq_z85_decode (decoded, encoded_));
    TEST_ASSERT_EQUAL_INT (EINVAL, zmq_errno ());
}
 
 
// call zmq_z85_encode, then zmq_z85_decode, and compare the results with the original
template <size_t SIZE>
void test__zmq_z85_encode__zmq_z85_decode__roundtrip (
  const uint8_t (&test_data_)[SIZE])
{
    char test_data_z85[SIZE * 5 / 4 + 1];
    const char *const res1 = zmq_z85_encode (test_data_z85, test_data_, SIZE);
    TEST_ASSERT_NOT_NULL (res1);
 
    uint8_t test_data_decoded[SIZE];
    const uint8_t *const res2 =
      zmq_z85_decode (test_data_decoded, test_data_z85);
    TEST_ASSERT_NOT_NULL (res2);
 
    TEST_ASSERT_EQUAL_UINT8_ARRAY (test_data_, test_data_decoded, SIZE);
}
 
// call zmq_z85_encode, then zmq_z85_decode, and compare the results with the original
template <size_t SIZE>
void test__zmq_z85_decode__zmq_z85_encode__roundtrip (
  const char (&test_data_)[SIZE])
{
    const size_t decoded_size = (SIZE - 1) * 4 / 5;
    uint8_t test_data_decoded[decoded_size];
    const uint8_t *const res1 = zmq_z85_decode (test_data_decoded, test_data_);
    TEST_ASSERT_NOT_NULL (res1);
 
    char test_data_z85[SIZE];
    const char *const res2 =
      zmq_z85_encode (test_data_z85, test_data_decoded, decoded_size);
    TEST_ASSERT_NOT_NULL (res2);
 
    TEST_ASSERT_EQUAL_UINT8_ARRAY (test_data_, test_data_z85, SIZE);
}
 
#define def_test__zmq_z85_basename(basename, name, param)                      \
    void test__zmq_z85_##basename##_##name ()                                  \
    {                                                                          \
        test__zmq_z85_##basename (param);                                      \
    }
 
#define def_test__zmq_z85_encode__invalid__failure(name, param)                \
    def_test__zmq_z85_basename (encode__invalid__failure, name, param)
 
def_test__zmq_z85_encode__invalid__failure (1, 1)
  def_test__zmq_z85_encode__invalid__failure (42, 42)
 
#define def_test__zmq_z85_decode__invalid__failure(name, param)                \
    def_test__zmq_z85_basename (decode__invalid__failure, name, param)
 
  // String length must be evenly divisible by 5 or must fail with EINVAL.
  def_test__zmq_z85_decode__invalid__failure (indivisble_by_5_multiple_chars,
                                              "01234567")
    def_test__zmq_z85_decode__invalid__failure (indivisble_by_5_one_char, "0")
 
  // decode invalid data with the maximum representable value
  def_test__zmq_z85_decode__invalid__failure (max, "#####")
 
  // decode invalid data with the minimum value beyond the limit
  // "%nSc0" is 0xffffffff
  def_test__zmq_z85_decode__invalid__failure (above_limit, "%nSc1")
 
  // decode invalid data with an invalid character in the range of valid
  // characters
  def_test__zmq_z85_decode__invalid__failure (char_within, "####\0047")
 
  // decode invalid data with an invalid character just below the range of valid
  // characters
  def_test__zmq_z85_decode__invalid__failure (char_adjacent_below, "####\0200")
 
  // decode invalid data with an invalid character just above the range of valid
  // characters
  def_test__zmq_z85_decode__invalid__failure (char_adjacent_above, "####\0037")
 
#define def_test__encode__zmq_z85_decode__roundtrip(name, param)               \
    def_test__zmq_z85_basename (encode__zmq_z85_decode__roundtrip, name, param)
 
    const uint8_t test_data_min[] = {0x00, 0x00, 0x00, 0x00};
const uint8_t test_data_max[] = {0xff, 0xff, 0xff, 0xff};
 
def_test__encode__zmq_z85_decode__roundtrip (min, test_data_min)
  def_test__encode__zmq_z85_decode__roundtrip (max, test_data_max)
 
#define def_test__decode__zmq_z85_encode__roundtrip(name, param)               \
    def_test__zmq_z85_basename (decode__zmq_z85_encode__roundtrip, name, param)
 
    const char test_data_regular[] = "r^/rM9M=rMToK)63O8dCvd9D<PY<7iGlC+{BiSnG";
 
def_test__decode__zmq_z85_encode__roundtrip (regular, test_data_regular)
 
  int main ()
{
    UNITY_BEGIN ();
    RUN_TEST (test__zmq_z85_encode__valid__success);
    RUN_TEST (test__zmq_z85_encode__invalid__failure_1);
    RUN_TEST (test__zmq_z85_encode__invalid__failure_42);
 
    RUN_TEST (test__zmq_z85_decode__valid__success);
    RUN_TEST (
      test__zmq_z85_decode__invalid__failure_indivisble_by_5_multiple_chars);
    RUN_TEST (test__zmq_z85_decode__invalid__failure_indivisble_by_5_one_char);
    RUN_TEST (test__zmq_z85_decode__invalid__failure_max);
    RUN_TEST (test__zmq_z85_decode__invalid__failure_above_limit);
    RUN_TEST (test__zmq_z85_decode__invalid__failure_char_within);
    RUN_TEST (test__zmq_z85_decode__invalid__failure_char_adjacent_below);
    RUN_TEST (test__zmq_z85_decode__invalid__failure_char_adjacent_above);
 
    RUN_TEST (test__zmq_z85_encode__zmq_z85_decode__roundtrip_min);
    RUN_TEST (test__zmq_z85_encode__zmq_z85_decode__roundtrip_max);
 
    RUN_TEST (test__zmq_z85_decode__zmq_z85_encode__roundtrip_regular);
 
    return UNITY_END ();
}