mirror of https://github.com/ARMmbed/mbed-os.git
972 lines
44 KiB
C++
972 lines
44 KiB
C++
/* mbed Microcontroller Library
|
|
* Copyright (c) 2017 ARM Limited
|
|
*
|
|
* 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;
|
|
|
|
|
|
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 = printf("hhd: %hhd\r\n", SCHAR_MIN);
|
|
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 = printf("hhd: %hhd\r\n", SCHAR_MAX);
|
|
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 = printf("hd: %hd\r\n", SHRT_MIN);
|
|
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 = printf("hd: %hd\r\n", SHRT_MAX);
|
|
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 = printf("d: %d\r\n", INT_MIN);
|
|
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 = printf("d: %d\r\n", INT_MAX);
|
|
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 = printf("ld: %ld\r\n", LONG_MIN);
|
|
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 = printf("ld: %ld\r\n", LONG_MAX);
|
|
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 = printf("lld: %lld\r\n", LLONG_MIN);
|
|
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 = printf("lld: %lld\r\n", LLONG_MAX);
|
|
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 = printf("jd: %jd\r\n", (intmax_t) INT32_MIN);
|
|
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 = printf("jd: %jd\r\n", (intmax_t) INT32_MAX);
|
|
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 = printf("zd: %zd\r\n", (ssize_t) INT32_MIN);
|
|
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 = printf("zd: %zd\r\n", (ssize_t) INT32_MAX);
|
|
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 = printf("td: %td\r\n", PTRDIFF_MIN);
|
|
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 = printf("td: %td\r\n", PTRDIFF_MAX);
|
|
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 = printf("hhu: %hhu\r\n", 0);
|
|
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 = printf("hhu: %hhu\r\n", UCHAR_MAX);
|
|
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 = printf("hu: %hu\r\n", 0);
|
|
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 = printf("hu: %hu\r\n", USHRT_MAX);
|
|
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 = printf("u: %u\r\n", 0);
|
|
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 = printf("u: %u\r\n", UINT_MAX);
|
|
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 = printf("lu: %lu\r\n", 0UL);
|
|
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 = printf("lu: %lu\r\n", ULONG_MAX);
|
|
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 = printf("llu: %llu\r\n", 0ULL);
|
|
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 = printf("llu: %llu\r\n", ULLONG_MAX);
|
|
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 = printf("ju: %ju\r\n", (uintmax_t) 0);
|
|
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 = printf("ju: %ju\r\n", UINTMAX_MAX);
|
|
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 = printf("zu: %zu\r\n", 0);
|
|
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 = printf("zu: %zu\r\n", SIZE_MAX);
|
|
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 = printf("tu: %tu\r\n", 0);
|
|
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 = printf("tu: %tu\r\n", UINTPTR_MAX);
|
|
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 = printf("hhX: %hhX\r\n", 0);
|
|
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 = printf("hhX: %hhX\r\n", UCHAR_MAX);
|
|
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 = printf("hX: %hX\r\n", 0);
|
|
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 = printf("hX: %hX\r\n", USHRT_MAX);
|
|
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 = printf("X: %X\r\n", 0);
|
|
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 = printf("X: %X\r\n", UINT_MAX);
|
|
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 = printf("lX: %lX\r\n", 0UL);
|
|
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 = printf("lX: %lX\r\n", ULONG_MAX);
|
|
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 = printf("llX: %llX\r\n", 0ULL);
|
|
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 = printf("llX: %llX\r\n", ULLONG_MAX);
|
|
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 = printf("jX: %jX\r\n", (uintmax_t) 0);
|
|
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 = printf("jX: %jX\r\n", UINTMAX_MAX);
|
|
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 = printf("zX: %zX\r\n", 0);
|
|
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 = printf("zX: %zX\r\n", SIZE_MAX);
|
|
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 = printf("tX: %tX\r\n", 0);
|
|
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 = printf("tX: %tX\r\n", UINTPTR_MAX);
|
|
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 = printf("x: %x\r\n", 11259375);
|
|
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;
|
|
|
|
result_minimal = mbed_printf("%% \r\n");
|
|
result_file = mbed_fprintf(stderr, "%% \r\n");
|
|
result_baseline = printf("%% \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_baseline[100];
|
|
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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "hhd: %hhd\r\n", SCHAR_MIN);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "hhd: %hhd\r\n", SCHAR_MAX);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "hd: %hd\r\n", SHRT_MIN);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "hd: %hd\r\n", SHRT_MAX);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "d: %d\r\n", INT_MIN);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "d: %d\r\n", INT_MAX);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "ld: %ld\r\n", LONG_MIN);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "ld: %ld\r\n", LONG_MAX);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "lld: %lld\r\n", LLONG_MIN);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "lld: %lld\r\n", LLONG_MAX);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "jd: %jd\r\n", (intmax_t) INT32_MIN);
|
|
TEST_ASSERT_EQUAL_STRING("jd: -2147483648\r\n", 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "jd: %jd\r\n", (intmax_t) INT32_MAX);
|
|
TEST_ASSERT_EQUAL_STRING("jd: 2147483647\r\n", 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "zd: %zd\r\n", (ssize_t) INT32_MIN);
|
|
TEST_ASSERT_EQUAL_STRING("zd: -2147483648\r\n", 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "zd: %zd\r\n", (ssize_t) INT32_MAX);
|
|
TEST_ASSERT_EQUAL_STRING("zd: 2147483647\r\n", 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "td: %td\r\n", PTRDIFF_MIN);
|
|
TEST_ASSERT_EQUAL_STRING("td: -2147483648\r\n", 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "td: %td\r\n", PTRDIFF_MAX);
|
|
TEST_ASSERT_EQUAL_STRING("td: 2147483647\r\n", buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
#endif
|
|
|
|
return CaseNext;
|
|
}
|
|
|
|
static control_t test_snprintf_u(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), "hhu: %hhu\r\n", 0);
|
|
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "hhu: %hhu\r\n", 0);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "hhu: %hhu\r\n", UCHAR_MAX);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "hu: %hu\r\n", 0);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "hu: %hu\r\n", USHRT_MAX);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "u: %u\r\n", 0);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "u: %u\r\n", UINT_MAX);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "lu: %lu\r\n", 0UL);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "lu: %lu\r\n", ULONG_MAX);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "llu: %llu\r\n", 0ULL);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "llu: %llu\r\n", ULLONG_MAX);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "ju: %ju\r\n", (uintmax_t) 0);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "ju: %ju\r\n", UINTMAX_MAX);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "zu: %zu\r\n", 0);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "zu: %zu\r\n", SIZE_MAX);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "tu: %tu\r\n", 0);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "tu: %tu\r\n", UINTPTR_MAX);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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_baseline[100];
|
|
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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "hhX: %hhX\r\n", 0);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "hhX: %hhX\r\n", UCHAR_MAX);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "hX: %hX\r\n", 0);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "hX: %hX\r\n", USHRT_MAX);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "X: %X\r\n", 0);
|
|
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "X: %X\r\n", 0);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "X: %X\r\n", UINT_MAX);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "lX: %lX\r\n", 0UL);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "lX: %lX\r\n", ULONG_MAX);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "llX: %llX\r\n", 0ULL);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "llX: %llX\r\n", ULLONG_MAX);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "jX: %jX\r\n", (uintmax_t) 0);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "jX: %jX\r\n", UINTMAX_MAX);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "zX: %zX\r\n", 0);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "zX: %zX\r\n", SIZE_MAX);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "tX: %tX\r\n", 0);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(buffer_baseline), "tX: %tX\r\n", UINTPTR_MAX);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, 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 = snprintf(buffer_baseline, sizeof(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)
|
|
{
|
|
int result_baseline;
|
|
int result_minimal;
|
|
|
|
/*************************************************************************/
|
|
/*************************************************************************/
|
|
|
|
double pi = 3.14159265359;
|
|
|
|
|
|
result_minimal = mbed_printf("f: %f\r\n", 3.0089);
|
|
result_baseline = printf("f: %f\r\n", 3.0089);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_printf("f: %f\r\n", 7.0);
|
|
result_baseline = printf("f: %f\r\n", 7.0);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_printf("f: %f\r\n", -1 * pi);
|
|
result_baseline = printf("f: %f\r\n", -1 * pi);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_printf("f: %f\r\n", 0.0);
|
|
result_baseline = printf("f: %f\r\n", 0.0);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_printf("f: %f\r\n", pi);
|
|
result_baseline = printf("f: %f\r\n", pi);
|
|
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;
|
|
|
|
/*************************************************************************/
|
|
/*************************************************************************/
|
|
|
|
double pi = 3.14159265359;
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "f: %f\r\n", 3.0089);
|
|
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "f: %f\r\n", 3.0089);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "f: %f\r\n", 7.0);
|
|
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "f: %f\r\n", 7.0);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "f: %f\r\n", -1 * pi);
|
|
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "f: %f\r\n", -1 * pi);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "f: %f\r\n", 0.0);
|
|
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "f: %f\r\n", 0.0);
|
|
TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "f: %f\r\n", pi);
|
|
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "f: %f\r\n", pi);
|
|
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
|
|
* Function parameters:
|
|
* 'fmt' is the format to use for sprintf
|
|
* 'data' is the data that will be printed
|
|
*/
|
|
template<typename T, size_t buf_size>
|
|
static control_t test_snprintf_buffer_overflow_generic(const char *fmt, T data)
|
|
{
|
|
char buffer_baseline[buf_size];
|
|
char buffer_minimal[buf_size];
|
|
int result_baseline;
|
|
int result_minimal;
|
|
|
|
/* empty buffer test */
|
|
result_minimal = mbed_snprintf(buffer_minimal, 0, fmt, data);
|
|
result_baseline = snprintf(buffer_baseline, 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);
|
|
result_baseline = snprintf(buffer_baseline, buf_size - 2, fmt, data);
|
|
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);
|
|
result_baseline = snprintf(buffer_baseline, buf_size - 1, fmt, data);
|
|
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);
|
|
result_baseline = snprintf(buffer_baseline, buf_size, fmt, data);
|
|
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);
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
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")>("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")>("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")>("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);
|
|
}
|