mirror of https://github.com/ARMmbed/mbed-os.git
1096 lines
47 KiB
C++
1096 lines
47 KiB
C++
/* mbed Microcontroller Library
|
|
* Copyright (c) 2017 ARM Limited
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*
|
|
* 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
|
|
*
|
|
* http://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.
|
|
*/
|
|
|
|
#ifdef TARGET_LIKE_MBED
|
|
#include "mbed.h"
|
|
#endif
|
|
#include "mbed_printf.h"
|
|
|
|
#include "utest/utest.h"
|
|
#include "unity/unity.h"
|
|
#include "greentea-client/test_env.h"
|
|
|
|
#include <stdint.h>
|
|
#include <stdbool.h>
|
|
#include <limits.h>
|
|
#include <inttypes.h>
|
|
|
|
#ifndef ULLONG_MAX
|
|
#define ULLONG_MAX UINT64_MAX
|
|
#endif
|
|
|
|
#ifndef LLONG_MAX
|
|
#define LLONG_MAX INT64_MAX
|
|
#endif
|
|
|
|
#ifndef LLONG_MIN
|
|
#define LLONG_MIN INT64_MIN
|
|
#endif
|
|
|
|
using namespace utest::v1;
|
|
|
|
#define MAX_STRING_SIZE 100
|
|
// Buffer used by test cases to store a test string
|
|
static char expected_string[MAX_STRING_SIZE];
|
|
|
|
#define BASE_10 10
|
|
#define BASE_16 16
|
|
|
|
/** This function converts an integer into a string representing the integer in base 10 or base 16.
|
|
*
|
|
* @param value to be converted to a string.
|
|
* @param str is an array where to store the resulting null-terminated string.
|
|
* @param base used to represent the string.
|
|
*
|
|
* @return
|
|
* A pointer to the resulting null-terminated string, same as parameter str.
|
|
*/
|
|
static char *convert_to_string(
|
|
uint64_t value,
|
|
char str[],
|
|
int base = BASE_10,
|
|
bool is_negative = false)
|
|
{
|
|
int i = 0;
|
|
|
|
if (base != BASE_10 && base != BASE_16) {
|
|
MBED_ASSERT(0);
|
|
}
|
|
|
|
if (value == 0) {
|
|
str[0] = '0';
|
|
str[1] = '\0';
|
|
return str;
|
|
}
|
|
|
|
if (is_negative && ((long long) value < 0)) {
|
|
value = -value;
|
|
}
|
|
// Convert a value to a string stored in reverse order in memory.
|
|
while (value) {
|
|
int remainder = value % base;
|
|
str[i++] = (remainder > 9) ? (remainder - 10) + 'A' : remainder + '0';
|
|
value = value / base;
|
|
}
|
|
|
|
if (is_negative) {
|
|
str[i++] = '-';
|
|
}
|
|
|
|
str[i] = '\0';
|
|
|
|
// Reverse the string.
|
|
int start = 0;
|
|
int end = i - 1;
|
|
while (start < end) {
|
|
swap(*(str + start), *(str + end));
|
|
start++;
|
|
end--;
|
|
}
|
|
return str;
|
|
}
|
|
|
|
/** This function is using a global buffer to build the test string 'prefix + data + suffix' and
|
|
* returns its length.
|
|
*
|
|
* @param prefix is a null-terminated string.
|
|
* @param value to be converted to a string.
|
|
* @param base used to represent the string.
|
|
* @param suffix is a null-terminated string.
|
|
* @param is_negative is used to represent a positive or negative value
|
|
*
|
|
* @return
|
|
* string length
|
|
*/
|
|
static int make_test_string(
|
|
const char *prefix = nullptr,
|
|
long long value = 0,
|
|
int base = BASE_10,
|
|
const char *suffix = nullptr,
|
|
bool is_negative = false
|
|
)
|
|
{
|
|
char *exp_str = &expected_string[0];
|
|
int str_length = 0;
|
|
memset(exp_str, 0, MAX_STRING_SIZE);
|
|
if (prefix) {
|
|
str_length = strlen(prefix);
|
|
MBED_ASSERT(str_length < MAX_STRING_SIZE);
|
|
strncpy(exp_str, prefix, str_length);
|
|
}
|
|
|
|
convert_to_string(value, &exp_str[str_length], base, is_negative);
|
|
if (suffix) {
|
|
str_length = strlen(exp_str);
|
|
MBED_ASSERT(strlen(suffix) < (MAX_STRING_SIZE - str_length));
|
|
strncat(exp_str, suffix, str_length);
|
|
}
|
|
return strlen(exp_str);
|
|
}
|
|
|
|
// Extract the prefix string which is all characters until '%'.
|
|
static void extract_prefix(const char *fmt, char *prefix)
|
|
{
|
|
int i = 0;
|
|
while (fmt && prefix && fmt[i] != '%') {
|
|
prefix[i] = fmt[i];
|
|
i++;
|
|
}
|
|
}
|
|
|
|
static control_t test_printf_d(const size_t call_count)
|
|
{
|
|
int result_baseline;
|
|
int result_minimal;
|
|
int result_file;
|
|
|
|
/*************************************************************************/
|
|
/*************************************************************************/
|
|
result_minimal = mbed_printf("hhd: %hhd\r\n", SCHAR_MIN);
|
|
result_file = mbed_fprintf(stderr, "hhd: %hhd\r\n", SCHAR_MIN);
|
|
result_baseline = make_test_string("hhd: ", SCHAR_MIN, BASE_10, "\r\n", true);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
result_minimal = mbed_printf("hhd: %hhd\r\n", SCHAR_MAX);
|
|
result_file = mbed_fprintf(stderr, "hhd: %hhd\r\n", SCHAR_MAX);
|
|
result_baseline = make_test_string("hhd: ", SCHAR_MAX, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
result_minimal = mbed_printf("hd: %hd\r\n", SHRT_MIN);
|
|
result_file = mbed_fprintf(stderr, "hd: %hd\r\n", SHRT_MIN);
|
|
result_baseline = make_test_string("hd: ", SHRT_MIN, BASE_10, "\r\n", true);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
result_minimal = mbed_printf("hd: %hd\r\n", SHRT_MAX);
|
|
result_file = mbed_fprintf(stderr, "hd: %hd\r\n", SHRT_MAX);
|
|
result_baseline = make_test_string("hd: ", SHRT_MAX, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
result_minimal = mbed_printf("d: %d\r\n", INT_MIN);
|
|
result_file = mbed_fprintf(stderr, "d: %d\r\n", INT_MIN);
|
|
result_baseline = make_test_string("d: ", INT_MIN, BASE_10, "\r\n", true);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
result_minimal = mbed_printf("d: %d\r\n", INT_MAX);
|
|
result_file = mbed_fprintf(stderr, "d: %d\r\n", INT_MAX);
|
|
result_baseline = make_test_string("d: ", INT_MAX, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
result_minimal = mbed_printf("ld: %ld\r\n", LONG_MIN);
|
|
result_file = mbed_fprintf(stderr, "ld: %ld\r\n", LONG_MIN);
|
|
result_baseline = make_test_string("ld: ", LONG_MIN, BASE_10, "\r\n", true);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
result_minimal = mbed_printf("ld: %ld\r\n", LONG_MAX);
|
|
result_file = mbed_fprintf(stderr, "ld: %ld\r\n", LONG_MAX);
|
|
result_baseline = make_test_string("ld: ", LONG_MAX, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
result_minimal = mbed_printf("lld: %lld\r\n", LLONG_MIN);
|
|
result_file = mbed_fprintf(stderr, "lld: %lld\r\n", LLONG_MIN);
|
|
result_baseline = make_test_string("lld: ", LLONG_MIN, BASE_10, "\r\n", true);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
result_minimal = mbed_printf("lld: %lld\r\n", LLONG_MAX);
|
|
result_file = mbed_fprintf(stderr, "lld: %lld\r\n", LLONG_MAX);
|
|
result_baseline = make_test_string("lld: ", LLONG_MAX, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
#ifdef TARGET_LIKE_MBED
|
|
printf("%%jd not supported by mbed\r\n");
|
|
#else
|
|
result_minimal = mbed_printf("jd: %jd\r\n", INT32_MIN);
|
|
result_file = mbed_fprintf(stderr, "jd: %jd\r\n", INT32_MIN);
|
|
result_baseline = make_test_string("jd: ", (intmax_t) INT32_MIN, BASE_10, "\r\n", true);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
result_minimal = mbed_printf("jd: %jd\r\n", INT32_MAX);
|
|
result_file = mbed_fprintf(stderr, "jd: %jd\r\n", INT32_MAX);
|
|
result_baseline = make_test_string("jd: ", (intmax_t) INT32_MAX, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
#endif
|
|
|
|
#ifdef TARGET_LIKE_MBED
|
|
printf("%%zd not supported by mbed\r\n");
|
|
#else
|
|
result_minimal = mbed_printf("zd: %zd\r\n", INT32_MIN);
|
|
result_file = mbed_fprintf(stderr, "zd: %zd\r\n", INT32_MIN);
|
|
result_baseline = make_test_string("zd: ", (ssize_t) INT32_MIN, BASE_10, "\r\n", true);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
result_minimal = mbed_printf("zd: %zd\r\n", INT32_MAX);
|
|
result_file = mbed_fprintf(stderr, "zd: %zd\r\n", INT32_MAX);
|
|
result_baseline = make_test_string("zd: ", (ssize_t) INT32_MAX, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
#endif
|
|
|
|
#ifdef TARGET_LIKE_MBED
|
|
printf("%%td not supported by mbed\r\n");
|
|
#else
|
|
result_minimal = mbed_printf("td: %td\r\n", PTRDIFF_MIN);
|
|
result_file = mbed_fprintf(stderr, "td: %td\r\n", PTRDIFF_MIN);
|
|
result_baseline = make_test_string("td: ", PTRDIFF_MIN, BASE_10, "\r\n", true);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
result_minimal = mbed_printf("td: %td\r\n", PTRDIFF_MAX);
|
|
result_file = mbed_fprintf(stderr, "td: %td\r\n", PTRDIFF_MAX);
|
|
result_baseline = make_test_string("td: ", PTRDIFF_MAX, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
#endif
|
|
|
|
return CaseNext;
|
|
}
|
|
|
|
static control_t test_printf_u(const size_t call_count)
|
|
{
|
|
int result_baseline;
|
|
int result_minimal;
|
|
int result_file;
|
|
|
|
/*************************************************************************/
|
|
/*************************************************************************/
|
|
result_minimal = mbed_printf("hhu: %hhu\r\n", 0);
|
|
result_file = mbed_fprintf(stderr, "hhu: %hhu\r\n", 0);
|
|
result_baseline = make_test_string("hhu: ", 0, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
result_minimal = mbed_printf("hhu: %hhu\r\n", UCHAR_MAX);
|
|
result_file = mbed_fprintf(stderr, "hhu: %hhu\r\n", UCHAR_MAX);
|
|
result_baseline = make_test_string("hhu: ", UCHAR_MAX, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
result_minimal = mbed_printf("hu: %hu\r\n", 0);
|
|
result_file = mbed_fprintf(stderr, "hu: %hu\r\n", 0);
|
|
result_baseline = make_test_string("hu: ", 0, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
result_minimal = mbed_printf("hu: %hu\r\n", USHRT_MAX);
|
|
result_file = mbed_fprintf(stderr, "hu: %hu\r\n", USHRT_MAX);
|
|
result_baseline = make_test_string("hu: ", USHRT_MAX, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
result_minimal = mbed_printf("u: %u\r\n", 0);
|
|
result_file = mbed_fprintf(stderr, "u: %u\r\n", 0);
|
|
result_baseline = make_test_string("u: ", 0, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
result_minimal = mbed_printf("u: %u\r\n", UINT_MAX);
|
|
result_file = mbed_fprintf(stderr, "u: %u\r\n", UINT_MAX);
|
|
result_baseline = make_test_string("u: ", UINT_MAX, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
result_minimal = mbed_printf("lu: %lu\r\n", 0UL);
|
|
result_file = mbed_fprintf(stderr, "lu: %lu\r\n", 0UL);
|
|
result_baseline = make_test_string("lu: ", 0UL, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
result_minimal = mbed_printf("lu: %lu\r\n", ULONG_MAX);
|
|
result_file = mbed_fprintf(stderr, "lu: %lu\r\n", ULONG_MAX);
|
|
result_baseline = make_test_string("lu: ", ULONG_MAX, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
result_minimal = mbed_printf("llu: %llu\r\n", 0ULL);
|
|
result_file = mbed_fprintf(stderr, "llu: %llu\r\n", 0ULL);
|
|
result_baseline = make_test_string("llu: ", 0ULL, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
result_minimal = mbed_printf("llu: %llu\r\n", ULLONG_MAX);
|
|
result_file = mbed_fprintf(stderr, "llu: %llu\r\n", ULLONG_MAX);
|
|
result_baseline = make_test_string("llu: ", ULLONG_MAX, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
#ifdef TARGET_LIKE_MBED
|
|
printf("%%ju not supported by mbed\r\n");
|
|
#else
|
|
result_minimal = mbed_printf("ju: %ju\r\n", (uintmax_t) 0);
|
|
result_file = mbed_fprintf(stderr, "ju: %ju\r\n", (uintmax_t) 0);
|
|
result_baseline = make_test_string("ju: ", (uintmax_t) 0, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
result_minimal = mbed_printf("ju: %ju\r\n", UINTMAX_MAX);
|
|
result_file = mbed_fprintf(stderr, "ju: %ju\r\n", UINTMAX_MAX);
|
|
result_baseline = make_test_string("ju: ", UINTMAX_MAX, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
#endif
|
|
|
|
#ifdef TARGET_LIKE_MBED
|
|
printf("%%zu not supported by mbed\r\n");
|
|
#else
|
|
result_minimal = mbed_printf("zu: %zu\r\n", 0);
|
|
result_file = mbed_fprintf(stderr, "zu: %zu\r\n", 0);
|
|
result_baseline = make_test_string("zu: ", 0, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
result_minimal = mbed_printf("zu: %zu\r\n", SIZE_MAX);
|
|
result_file = mbed_fprintf(stderr, "zu: %zu\r\n", SIZE_MAX);
|
|
result_baseline = make_test_string("zu: ", SIZE_MAX, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
#endif
|
|
|
|
#ifdef TARGET_LIKE_MBED
|
|
printf("%%tu not supported by mbed\r\n");
|
|
#else
|
|
result_minimal = mbed_printf("tu: %tu\r\n", 0);
|
|
result_file = mbed_fprintf(stderr, "tu: %tu\r\n", 0);
|
|
result_baseline = make_test_string("tu: ", 0, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
result_minimal = mbed_printf("tu: %tu\r\n", UINTPTR_MAX);
|
|
result_file = mbed_fprintf(stderr, "tu: %tu\r\n", UINTPTR_MAX);
|
|
result_baseline = make_test_string("tu: ", UINTPTR_MAX, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
#endif
|
|
|
|
return CaseNext;
|
|
}
|
|
|
|
static control_t test_printf_x(const size_t call_count)
|
|
{
|
|
int result_baseline;
|
|
int result_minimal;
|
|
int result_file;
|
|
|
|
/*************************************************************************/
|
|
/*************************************************************************/
|
|
result_minimal = mbed_printf("hhX: %hhX\r\n", 0);
|
|
result_file = mbed_fprintf(stderr, "hhX: %hhX\r\n", 0);
|
|
result_baseline = make_test_string("hhX: ", 0, BASE_16, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
result_minimal = mbed_printf("hhX: %hhX\r\n", UCHAR_MAX);
|
|
result_file = mbed_fprintf(stderr, "hhX: %hhX\r\n", UCHAR_MAX);
|
|
result_baseline = make_test_string("hhX: ", UCHAR_MAX, BASE_16, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
result_minimal = mbed_printf("hX: %hX\r\n", 0);
|
|
result_file = mbed_fprintf(stderr, "hX: %hX\r\n", 0);
|
|
result_baseline = make_test_string("hX: ", 0, BASE_16, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
result_minimal = mbed_printf("hX: %hX\r\n", USHRT_MAX);
|
|
result_file = mbed_fprintf(stderr, "hX: %hX\r\n", USHRT_MAX);
|
|
result_baseline = make_test_string("hX: ", USHRT_MAX, BASE_16, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
result_minimal = mbed_printf("X: %X\r\n", 0);
|
|
result_file = mbed_fprintf(stderr, "X: %X\r\n", 0);
|
|
result_baseline = make_test_string("X: ", 0, BASE_16, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
result_minimal = mbed_printf("X: %X\r\n", UINT_MAX);
|
|
result_file = mbed_fprintf(stderr, "X: %X\r\n", UINT_MAX);
|
|
result_baseline = make_test_string("X: ", UINT_MAX, BASE_16, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
result_minimal = mbed_printf("lX: %lX\r\n", 0UL);
|
|
result_file = mbed_fprintf(stderr, "lX: %lX\r\n", 0UL);
|
|
result_baseline = make_test_string("lX: ", 0UL, BASE_16, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
result_minimal = mbed_printf("lX: %lX\r\n", ULONG_MAX);
|
|
result_file = mbed_fprintf(stderr, "lX: %lX\r\n", ULONG_MAX);
|
|
result_baseline = make_test_string("lX: ", ULONG_MAX, BASE_16, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
result_minimal = mbed_printf("llX: %llX\r\n", 0ULL);
|
|
result_file = mbed_fprintf(stderr, "llX: %llX\r\n", 0ULL);
|
|
result_baseline = make_test_string("llX: ", 0ULL, BASE_16, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
result_minimal = mbed_printf("llX: %llX\r\n", ULLONG_MAX);
|
|
result_file = mbed_fprintf(stderr, "llX: %llX\r\n", ULLONG_MAX);
|
|
result_baseline = make_test_string("llX: ", ULLONG_MAX, BASE_16, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
#ifdef TARGET_LIKE_MBED
|
|
printf("%%jX not supported by mbed\r\n");
|
|
#else
|
|
result_minimal = mbed_printf("jX: %jX\r\n", (uintmax_t) 0);
|
|
result_file = mbed_fprintf(stderr, "jX: %jX\r\n", (uintmax_t) 0);
|
|
result_baseline = make_test_string("jX: ", (uintmax_t) 0, BASE_16, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
result_minimal = mbed_printf("jX: %jX\r\n", UINTMAX_MAX);
|
|
result_file = mbed_fprintf(stderr, "jX: %jX\r\n", UINTMAX_MAX);
|
|
result_baseline = make_test_string("jX: ", UINTMAX_MAX, BASE_16, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
#endif
|
|
|
|
#ifdef TARGET_LIKE_MBED
|
|
printf("%%zX not supported by mbed\r\n");
|
|
#else
|
|
result_minimal = mbed_printf("zX: %zX\r\n", 0);
|
|
result_file = mbed_fprintf(stderr, "zX: %zX\r\n", 0);
|
|
result_baseline = make_test_string("zX: ", 0, BASE_16, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
result_minimal = mbed_printf("zX: %zX\r\n", SIZE_MAX);
|
|
result_file = mbed_fprintf(stderr, "zX: %zX\r\n", SIZE_MAX);
|
|
result_baseline = make_test_string("zX: ", SIZE_MAX, BASE_16, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
#endif
|
|
|
|
#ifdef TARGET_LIKE_MBED
|
|
printf("%%tX not supported by mbed\r\n");
|
|
#else
|
|
result_minimal = mbed_printf("tX: %tX\r\n", 0);
|
|
result_file = mbed_fprintf(stderr, "tX: %tX\r\n", 0);
|
|
result_baseline = make_test_string("tX: ", 0, BASE_16, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
result_minimal = mbed_printf("tX: %tX\r\n", UINTPTR_MAX);
|
|
result_file = mbed_fprintf(stderr, "tX: %tX\r\n", UINTPTR_MAX);
|
|
result_baseline = make_test_string("tX: ", UINTPTR_MAX, BASE_16, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
#endif
|
|
|
|
result_minimal = mbed_printf("x: %x\r\n", 11259375);
|
|
result_baseline = make_test_string("x: ", 11259375, BASE_16, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
return CaseNext;
|
|
}
|
|
|
|
static control_t test_printf_percent(const size_t call_count)
|
|
{
|
|
int result_baseline;
|
|
int result_minimal;
|
|
int result_file;
|
|
char buffer_baseline[100] = {0};
|
|
|
|
result_minimal = mbed_printf("%% \r\n");
|
|
result_file = mbed_fprintf(stderr, "%% \r\n");
|
|
result_baseline = sprintf(buffer_baseline, "%% \r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_file);
|
|
|
|
return CaseNext;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/* */
|
|
/* SNPRINTF */
|
|
/* */
|
|
/******************************************************************************/
|
|
|
|
static control_t test_snprintf_d(const size_t call_count)
|
|
{
|
|
char buffer_minimal[100];
|
|
int result_baseline;
|
|
int result_minimal;
|
|
|
|
/*************************************************************************/
|
|
/*************************************************************************/
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hhd: %hhd\r\n", SCHAR_MIN);
|
|
result_baseline = make_test_string("hhd: ", SCHAR_MIN, BASE_10, "\r\n", true);
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hhd: %hhd\r\n", SCHAR_MAX);
|
|
result_baseline = make_test_string("hhd: ", SCHAR_MAX, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hd: %hd\r\n", SHRT_MIN);
|
|
result_baseline = make_test_string("hd: ", SHRT_MIN, BASE_10, "\r\n", true);
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hd: %hd\r\n", SHRT_MAX);
|
|
result_baseline = make_test_string("hd: ", SHRT_MAX, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "d: %d\r\n", INT_MIN);
|
|
result_baseline = make_test_string("d: ", INT_MIN, BASE_10, "\r\n", true);
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "d: %d\r\n", INT_MAX);
|
|
result_baseline = make_test_string("d: ", INT_MAX, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "ld: %ld\r\n", LONG_MIN);
|
|
result_baseline = make_test_string("ld: ", LONG_MIN, BASE_10, "\r\n", true);
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "ld: %ld\r\n", LONG_MAX);
|
|
result_baseline = make_test_string("ld: ", LONG_MAX, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "lld: %lld\r\n", LLONG_MIN);
|
|
result_baseline = make_test_string("lld: ", LLONG_MIN, BASE_10, "\r\n", true);
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "lld: %lld\r\n", LLONG_MAX);
|
|
result_baseline = make_test_string("lld: ", LLONG_MAX, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
#ifdef TARGET_LIKE_MBED
|
|
printf("%%jd not supported by mbed\r\n");
|
|
#else
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "jd: %jd\r\n", (intmax_t) INT32_MIN);
|
|
result_baseline = make_test_string("jd: ", (intmax_t) INT32_MIN, BASE_10, "\r\n", true);
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "jd: %jd\r\n", (intmax_t) INT32_MAX);
|
|
result_baseline = make_test_string("jd: ", (intmax_t) INT32_MAX, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
#endif
|
|
|
|
#ifdef TARGET_LIKE_MBED
|
|
printf("%%zd not supported by mbed\r\n");
|
|
#else
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "zd: %zd\r\n", (ssize_t) INT32_MIN);
|
|
result_baseline = make_test_string("zd: ", (ssize_t) INT32_MIN, BASE_10, "\r\n", true);
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "zd: %zd\r\n", (ssize_t) INT32_MAX);
|
|
result_baseline = make_test_string("zd: ", (ssize_t) INT32_MAX, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
#endif
|
|
|
|
#ifdef TARGET_LIKE_MBED
|
|
printf("%%td not supported by mbed\r\n");
|
|
#else
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "td: %td\r\n", PTRDIFF_MIN);
|
|
result_baseline = make_test_string("td: ", PTRDIFF_MIN, BASE_10, "\r\n", true);
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "td: %td\r\n", PTRDIFF_MAX);
|
|
result_baseline = make_test_string("td: ", PTRDIFF_MAX, BASE_10, "\r\n", true);
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
#endif
|
|
|
|
int a = 2;
|
|
int b = 3;
|
|
result_minimal = mbed_snprintf(0, 0, "%d + %d = %d\n", a, b, a + b);
|
|
TEST_ASSERT_EQUAL_INT(10, result_minimal);
|
|
|
|
return CaseNext;
|
|
}
|
|
|
|
static control_t test_snprintf_u(const size_t call_count)
|
|
{
|
|
char buffer_minimal[100];
|
|
int result_baseline;
|
|
int result_minimal;
|
|
|
|
/*************************************************************************/
|
|
/*************************************************************************/
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hhu: %hhu\r\n", 0);
|
|
result_baseline = make_test_string("hhu: ", 0, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hhu: %hhu\r\n", UCHAR_MAX);
|
|
result_baseline = make_test_string("hhu: ", UCHAR_MAX, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hu: %hu\r\n", 0);
|
|
result_baseline = make_test_string("hu: ", 0, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hu: %hu\r\n", USHRT_MAX);
|
|
result_baseline = make_test_string("hu: ", USHRT_MAX, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "u: %u\r\n", 0);
|
|
result_baseline = make_test_string("u: ", 0, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "u: %u\r\n", UINT_MAX);
|
|
result_baseline = make_test_string("u: ", UINT_MAX, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "lu: %lu\r\n", 0UL);
|
|
result_baseline = make_test_string("lu: ", 0UL, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "lu: %lu\r\n", ULONG_MAX);
|
|
result_baseline = make_test_string("lu: ", ULONG_MAX, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "llu: %llu\r\n", 0ULL);
|
|
result_baseline = make_test_string("llu: ", 0ULL, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "llu: %llu\r\n", ULLONG_MAX);
|
|
result_baseline = make_test_string("llu: ", ULLONG_MAX, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
#ifdef TARGET_LIKE_MBED
|
|
printf("%%ju not supported by mbed\r\n");
|
|
#else
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "ju: %ju\r\n", (uintmax_t) 0);
|
|
result_baseline = make_test_string("ju: ", (uintmax_t) 0, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "ju: %ju\r\n", UINTMAX_MAX);
|
|
result_baseline = make_test_string("ju: ", UINTMAX_MAX, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
#endif
|
|
|
|
#ifdef TARGET_LIKE_MBED
|
|
printf("%%zu not supported by mbed\r\n");
|
|
#else
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "zu: %zu\r\n", 0);
|
|
result_baseline = make_test_string("zu: ", 0, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "zu: %zu\r\n", SIZE_MAX);
|
|
result_baseline = make_test_string("zu: ", SIZE_MAX, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
#endif
|
|
|
|
#ifdef TARGET_LIKE_MBED
|
|
printf("%%tu not supported by mbed\r\n");
|
|
#else
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "tu: %tu\r\n", 0);
|
|
result_baseline = make_test_string("tu: ", 0, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "tu: %tu\r\n", UINTPTR_MAX);
|
|
result_baseline = make_test_string("tu: ", UINTPTR_MAX, BASE_10, "\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
#endif
|
|
|
|
return CaseNext;
|
|
}
|
|
|
|
static control_t test_snprintf_x(const size_t call_count)
|
|
{
|
|
char buffer_minimal[100];
|
|
int result_baseline;
|
|
int result_minimal;
|
|
|
|
/*************************************************************************/
|
|
/*************************************************************************/
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hhX: %hhX\r\n", 0);
|
|
result_baseline = make_test_string("hhX: ", 0, BASE_16, "\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hhX: %hhX\r\n", UCHAR_MAX);
|
|
result_baseline = make_test_string("hhX: ", UCHAR_MAX, BASE_16, "\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hX: %hX\r\n", 0);
|
|
result_baseline = make_test_string("hX: ", 0, BASE_16, "\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hX: %hX\r\n", USHRT_MAX);
|
|
result_baseline = make_test_string("hX: ", USHRT_MAX, BASE_16, "\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "X: %X\r\n", 0);
|
|
result_baseline = make_test_string("X: ", 0, BASE_16, "\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "X: %X\r\n", UINT_MAX);
|
|
result_baseline = make_test_string("X: ", UINT_MAX, BASE_16, "\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "lX: %lX\r\n", 0UL);
|
|
result_baseline = make_test_string("lX: ", 0UL, BASE_16, "\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "lX: %lX\r\n", ULONG_MAX);
|
|
result_baseline = make_test_string("lX: ", ULONG_MAX, BASE_16, "\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "llX: %llX\r\n", 0ULL);
|
|
result_baseline = make_test_string("llX: ", 0ULL, BASE_16, "\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "llX: %llX\r\n", ULLONG_MAX);
|
|
result_baseline = make_test_string("llX: ", ULLONG_MAX, BASE_16, "\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
#ifdef TARGET_LIKE_MBED
|
|
printf("%%jX not supported by mbed\r\n");
|
|
#else
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "jX: %jX\r\n", (uintmax_t) 0);
|
|
result_baseline = make_test_string("jX: ", (uintmax_t) 0, BASE_16, "\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "jX: %jX\r\n", UINTMAX_MAX);
|
|
result_baseline = make_test_string("jX: ", UINTMAX_MAX, BASE_16, "\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
#endif
|
|
|
|
#ifdef TARGET_LIKE_MBED
|
|
printf("%%xX not supported by mbed\r\n");
|
|
#else
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "zX: %zX\r\n", 0);
|
|
result_baseline = make_test_string("zX: ", 0, BASE_16, "\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "zX: %zX\r\n", SIZE_MAX);
|
|
result_baseline = make_test_string("zX: ", SIZE_MAX, BASE_16, "\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
#endif
|
|
|
|
#ifdef TARGET_LIKE_MBED
|
|
printf("%%tX not supported by mbed\r\n");
|
|
#else
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "tX: %tX\r\n", 0);
|
|
result_baseline = make_test_string("tX: ", 0, BASE_16, "\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "tX: %tX\r\n", UINTPTR_MAX);
|
|
result_baseline = make_test_string("tX: ", UINTPTR_MAX, BASE_16, "\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
#endif
|
|
|
|
return CaseNext;
|
|
}
|
|
|
|
static control_t test_snprintf_percent(const size_t call_count)
|
|
{
|
|
char buffer_baseline[100];
|
|
char buffer_minimal[100];
|
|
int result_baseline;
|
|
int result_minimal;
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "%% \r\n");
|
|
result_baseline = sprintf(buffer_baseline, "%% \r\n");
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
return CaseNext;
|
|
}
|
|
|
|
static control_t test_snprintf_unsupported_specifier(const size_t call_count)
|
|
{
|
|
char buffer_minimal[100];
|
|
|
|
TEST_ASSERT_NOT_EQUAL(
|
|
0,
|
|
mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "%a \r\n", 5)
|
|
);
|
|
TEST_ASSERT_EQUAL_STRING("%a \r\n", buffer_minimal);
|
|
|
|
return CaseNext;
|
|
}
|
|
|
|
#if MBED_CONF_PLATFORM_MINIMAL_PRINTF_ENABLE_FLOATING_POINT
|
|
static control_t test_printf_f(const size_t call_count)
|
|
{
|
|
char buffer_baseline[100];
|
|
int result_baseline;
|
|
int result_minimal;
|
|
#define CLEAN_BUFFER memset(buffer_baseline, 0x00, sizeof(buffer_baseline))
|
|
/*************************************************************************/
|
|
/*************************************************************************/
|
|
double pi = 3.14159265359;
|
|
CLEAN_BUFFER;
|
|
result_minimal = mbed_printf("f: %f\r\n", 3.0089);
|
|
result_baseline = sprintf(buffer_baseline, "f: 3.008900\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
CLEAN_BUFFER;
|
|
result_minimal = mbed_printf("f: %f\r\n", 7.0);
|
|
result_baseline = sprintf(buffer_baseline, "f: 7.000000\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
CLEAN_BUFFER;
|
|
result_minimal = mbed_printf("f: %f\r\n", -1 * pi);
|
|
result_baseline = sprintf(buffer_baseline, "f: -3.141593\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
CLEAN_BUFFER;
|
|
result_minimal = mbed_printf("f: %f\r\n", 0.0);
|
|
result_baseline = sprintf(buffer_baseline, "f: 0.000000\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
CLEAN_BUFFER;
|
|
result_minimal = mbed_printf("f: %f\r\n", pi);
|
|
result_baseline = sprintf(buffer_baseline, "f: 3.141593\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
CLEAN_BUFFER;
|
|
result_minimal = mbed_printf("f: %f\r\n", 2.12345651);
|
|
result_baseline = sprintf(buffer_baseline, "f: 2.123457\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
CLEAN_BUFFER;
|
|
result_minimal = mbed_printf("f: %f\r\n", 2.12345649);
|
|
result_baseline = sprintf(buffer_baseline, "f: 2.123456\r\n");
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
return CaseNext;
|
|
}
|
|
|
|
static control_t test_snprintf_f(const size_t call_count)
|
|
{
|
|
char buffer_baseline[100];
|
|
char buffer_minimal[100];
|
|
int result_baseline;
|
|
int result_minimal;
|
|
#define CLEAN_BUFFER memset(buffer_baseline, 0x00, sizeof(buffer_baseline))
|
|
/*************************************************************************/
|
|
/*************************************************************************/
|
|
|
|
double pi = 3.14159265359;
|
|
CLEAN_BUFFER;
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "f: %f\r\n", 3.0089);
|
|
result_baseline = sprintf(buffer_baseline, "f: 3.008900\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
CLEAN_BUFFER;
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "f: %f\r\n", 7.0);
|
|
result_baseline = sprintf(buffer_baseline, "f: 7.000000\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
CLEAN_BUFFER;
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "f: %f\r\n", -1 * pi);
|
|
result_baseline = sprintf(buffer_baseline, "f: -3.141593\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
CLEAN_BUFFER;
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "f: %f\r\n", 0.0);
|
|
result_baseline = sprintf(buffer_baseline, "f: 0.000000\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
CLEAN_BUFFER;
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "f: %f\r\n", pi);
|
|
result_baseline = sprintf(buffer_baseline, "f: 3.141593\r\n");
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
return CaseNext;
|
|
}
|
|
#endif
|
|
|
|
|
|
/* Generic buffer overflow test function.
|
|
* Template parameters:
|
|
* 'T' is the type being tested
|
|
* 'buf_size' is the buffer size used in tests
|
|
* 'base' is used to represent data in BASE_10 or BASE_16 numeral system
|
|
* Function parameters:
|
|
* 'fmt' is the format to use for sprintf
|
|
* 'data' is the data that will be printed
|
|
* 'is_negative' is true for negative number, false for positive number
|
|
*/
|
|
template<typename T, size_t buf_size, int base = BASE_10>
|
|
static control_t test_snprintf_buffer_overflow_generic(const char *fmt, T data, bool is_negative = false)
|
|
{
|
|
char buffer_baseline[buf_size];
|
|
char buffer_minimal[buf_size];
|
|
int result_baseline;
|
|
int result_minimal;
|
|
char prefix[buf_size] = { 0 };
|
|
// fmt string has "format specifier: %format specifier"
|
|
// Extract the string preceding the first '%' from fmt.
|
|
extract_prefix(fmt, &prefix[0]);
|
|
result_baseline = make_test_string(prefix, data, base, nullptr, is_negative);
|
|
|
|
/* empty buffer test */
|
|
result_minimal = mbed_snprintf(buffer_minimal, 0, fmt, data);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
/* buffer isn't large enough, output needs to be truncated */
|
|
result_minimal = mbed_snprintf(buffer_minimal, buf_size - 2, fmt, data);
|
|
snprintf(buffer_baseline, buf_size - 2, "%s", expected_string);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
/* buffer is one byte shorter than needed, string terminator must
|
|
be written and output must be truncated */
|
|
result_minimal = mbed_snprintf(buffer_minimal, buf_size - 1, fmt, data);
|
|
snprintf(buffer_baseline, buf_size - 1, "%s", expected_string);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
/* buffer is just long enough */
|
|
result_minimal = mbed_snprintf(buffer_minimal, buf_size, fmt, data);
|
|
snprintf(buffer_baseline, buf_size, "%s", expected_string);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
return CaseNext;
|
|
}
|
|
|
|
/* Based on the generic buffer overflow function above, create tests for
|
|
each relevant data type. In each case, the buffer for printing will only
|
|
be large enough to fit the printed data. */
|
|
static control_t test_snprintf_buffer_overflow_d(const size_t call_count)
|
|
{
|
|
return test_snprintf_buffer_overflow_generic<int, sizeof("d: -1024")>("d: %d", -1024, true);
|
|
}
|
|
|
|
static control_t test_snprintf_buffer_overflow_ld(const size_t call_count)
|
|
{
|
|
return test_snprintf_buffer_overflow_generic<long, sizeof("ld: -1048576")>("ld: %ld", -1048576L, true);
|
|
}
|
|
|
|
static control_t test_snprintf_buffer_overflow_lld(const size_t call_count)
|
|
{
|
|
return test_snprintf_buffer_overflow_generic<long long, sizeof("lld: -1099511627776")>("lld: %lld", -1099511627776LL, true);
|
|
}
|
|
|
|
static control_t test_snprintf_buffer_overflow_u(const size_t call_count)
|
|
{
|
|
return test_snprintf_buffer_overflow_generic<unsigned int, sizeof("u: 1024")>("u: %u", 1024);
|
|
}
|
|
|
|
static control_t test_snprintf_buffer_overflow_lu(const size_t call_count)
|
|
{
|
|
return test_snprintf_buffer_overflow_generic<unsigned long, sizeof("lu: 1048576")>("lu: %lu", 1048576UL);
|
|
}
|
|
|
|
static control_t test_snprintf_buffer_overflow_llu(const size_t call_count)
|
|
{
|
|
return test_snprintf_buffer_overflow_generic<unsigned long long, sizeof("llu: 1099511627776")>("llu: %llu", 1099511627776ULL);
|
|
}
|
|
|
|
static control_t test_snprintf_buffer_overflow_x(const size_t call_count)
|
|
{
|
|
return test_snprintf_buffer_overflow_generic<unsigned int, sizeof("x: 0x400"), BASE_16>("x: 0x%x", 0x400);
|
|
}
|
|
|
|
static control_t test_snprintf_buffer_overflow_lx(const size_t call_count)
|
|
{
|
|
return test_snprintf_buffer_overflow_generic<unsigned long, sizeof("lx: 0x100000"), BASE_16>("lx: 0x%lx", 0x100000UL);
|
|
}
|
|
|
|
static control_t test_snprintf_buffer_overflow_llx(const size_t call_count)
|
|
{
|
|
return test_snprintf_buffer_overflow_generic<unsigned long long, sizeof("llx: 0x10000000000"), BASE_16>("llx: 0x%llx", 0x10000000000ULL);
|
|
}
|
|
|
|
utest::v1::status_t greentea_setup(const size_t number_of_cases)
|
|
{
|
|
GREENTEA_SETUP(30 * 60, "default_auto");
|
|
return greentea_test_setup_handler(number_of_cases);
|
|
}
|
|
|
|
Case cases[] = {
|
|
Case("printf %d", test_printf_d),
|
|
Case("snprintf %d", test_snprintf_d),
|
|
Case("printf %u", test_printf_u),
|
|
Case("snprintf %u", test_snprintf_u),
|
|
Case("printf %x", test_printf_x),
|
|
Case("snprintf %x", test_snprintf_x),
|
|
Case("printf %%", test_printf_percent),
|
|
Case("snprintf %%", test_snprintf_percent),
|
|
Case("snprintf unsupported specifier", test_snprintf_unsupported_specifier),
|
|
#if MBED_CONF_PLATFORM_MINIMAL_PRINTF_ENABLE_FLOATING_POINT
|
|
Case("printf %f", test_printf_f),
|
|
Case("snprintf %f", test_snprintf_f),
|
|
#endif
|
|
Case("snprintf buffer overflow %d", test_snprintf_buffer_overflow_d),
|
|
Case("snprintf buffer overflow %ld", test_snprintf_buffer_overflow_ld),
|
|
Case("snprintf buffer overflow %lld", test_snprintf_buffer_overflow_lld),
|
|
Case("snprintf buffer overflow %u", test_snprintf_buffer_overflow_u),
|
|
Case("snprintf buffer overflow %lu", test_snprintf_buffer_overflow_lu),
|
|
Case("snprintf buffer overflow %llu", test_snprintf_buffer_overflow_llu),
|
|
Case("snprintf buffer overflow %x", test_snprintf_buffer_overflow_x),
|
|
Case("snprintf buffer overflow %lx", test_snprintf_buffer_overflow_lx),
|
|
Case("snprintf buffer overflow %llx", test_snprintf_buffer_overflow_llx),
|
|
};
|
|
|
|
Specification specification(greentea_setup, cases, greentea_test_teardown_handler);
|
|
|
|
int main()
|
|
{
|
|
return !Harness::run(specification);
|
|
}
|