mirror of https://github.com/ARMmbed/mbed-os.git
595 lines
28 KiB
C++
Executable File
595 lines
28 KiB
C++
Executable File
/* 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.
|
|
*/
|
|
|
|
#include "mbed.h"
|
|
#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;
|
|
|
|
/*************************************************************************/
|
|
/*************************************************************************/
|
|
result_minimal = mbed_printf("hhd: %hhd\r\n", SCHAR_MIN);
|
|
result_baseline = printf("hhd: %hhd\r\n", SCHAR_MIN);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_printf("hhd: %hhd\r\n", SCHAR_MAX);
|
|
result_baseline = printf("hhd: %hhd\r\n", SCHAR_MAX);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_printf("hd: %hd\r\n", SHRT_MIN);
|
|
result_baseline = printf("hd: %hd\r\n", SHRT_MIN);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_printf("hd: %hd\r\n", SHRT_MAX);
|
|
result_baseline = printf("hd: %hd\r\n", SHRT_MAX);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_printf("d: %d\r\n", INT_MIN);
|
|
result_baseline = printf("d: %d\r\n", INT_MIN);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_printf("d: %d\r\n", INT_MAX);
|
|
result_baseline = printf("d: %d\r\n", INT_MAX);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_printf("ld: %ld\r\n", LONG_MIN);
|
|
result_baseline = printf("ld: %ld\r\n", LONG_MIN);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_printf("ld: %ld\r\n", LONG_MAX);
|
|
result_baseline = printf("ld: %ld\r\n", LONG_MAX);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_printf("lld: %lld\r\n", LLONG_MIN);
|
|
result_baseline = printf("lld: %lld\r\n", LLONG_MIN);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_printf("lld: %lld\r\n", LLONG_MAX);
|
|
result_baseline = printf("lld: %lld\r\n", LLONG_MAX);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
printf("%%jd not supported by mbed\r\n");
|
|
|
|
result_minimal = mbed_printf("jd: %jd\r\n", INT32_MIN);
|
|
result_baseline = printf("jd: %jd\r\n", INT32_MIN);
|
|
TEST_ASSERT_EQUAL_INT(18, result_minimal);
|
|
|
|
result_minimal = mbed_printf("jd: %jd\r\n", INT32_MAX);
|
|
result_baseline = printf("jd: %jd\r\n", INT32_MAX);
|
|
TEST_ASSERT_EQUAL_INT(17, result_minimal);
|
|
|
|
printf("%%zd not supported by mbed\r\n");
|
|
|
|
result_minimal = mbed_printf("zd: %zd\r\n", INT32_MIN);
|
|
result_baseline = printf("zd: %zd\r\n", INT32_MIN);
|
|
TEST_ASSERT_EQUAL_INT(18, result_minimal);
|
|
|
|
result_minimal = mbed_printf("zd: %zd\r\n", INT32_MAX);
|
|
result_baseline = printf("zd: %zd\r\n", INT32_MAX);
|
|
TEST_ASSERT_EQUAL_INT(17, result_minimal);
|
|
|
|
printf("%%td not supported by mbed\r\n");
|
|
|
|
result_minimal = mbed_printf("td: %td\r\n", PTRDIFF_MIN);
|
|
result_baseline = printf("td: %td\r\n", PTRDIFF_MIN);
|
|
TEST_ASSERT_EQUAL_INT(18, result_minimal);
|
|
|
|
result_minimal = mbed_printf("td: %td\r\n", PTRDIFF_MAX);
|
|
result_baseline = printf("td: %td\r\n", PTRDIFF_MAX);
|
|
TEST_ASSERT_EQUAL_INT(17, result_minimal);
|
|
|
|
return CaseNext;
|
|
}
|
|
|
|
static control_t test_printf_u(const size_t call_count)
|
|
{
|
|
int result_baseline;
|
|
int result_minimal;
|
|
|
|
/*************************************************************************/
|
|
/*************************************************************************/
|
|
result_minimal = mbed_printf("hhu: %hhu\r\n", 0);
|
|
result_baseline = printf("hhu: %hhu\r\n", 0);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_printf("hhu: %hhu\r\n", UCHAR_MAX);
|
|
result_baseline = printf("hhu: %hhu\r\n", UCHAR_MAX);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_printf("hu: %hu\r\n", 0);
|
|
result_baseline = printf("hu: %hu\r\n", 0);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_printf("hu: %hu\r\n", USHRT_MAX);
|
|
result_baseline = printf("hu: %hu\r\n", USHRT_MAX);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_printf("u: %u\r\n", 0);
|
|
result_baseline = printf("u: %u\r\n", 0);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_printf("u: %u\r\n", UINT_MAX);
|
|
result_baseline = printf("u: %u\r\n", UINT_MAX);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_printf("lu: %lu\r\n", 0);
|
|
result_baseline = printf("lu: %lu\r\n", 0UL);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_printf("lu: %lu\r\n", ULONG_MAX);
|
|
result_baseline = printf("lu: %lu\r\n", ULONG_MAX);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_printf("llu: %llu\r\n", 0);
|
|
result_baseline = printf("llu: %llu\r\n", 0ULL);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_printf("llu: %llu\r\n", ULLONG_MAX);
|
|
result_baseline = printf("llu: %llu\r\n", ULLONG_MAX);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_printf("ju: %ju\r\n", 0);
|
|
result_baseline = printf("ju: %ju\r\n",(uintmax_t) 0);
|
|
TEST_ASSERT_EQUAL_INT(8, result_minimal);
|
|
|
|
result_minimal = mbed_printf("ju: %ju\r\n", UINTMAX_MAX);
|
|
result_baseline = printf("ju: %ju\r\n", UINTMAX_MAX);
|
|
TEST_ASSERT_EQUAL_INT(8, result_minimal);
|
|
|
|
result_minimal = mbed_printf("zu: %zu\r\n", 0);
|
|
result_baseline = printf("zu: %zu\r\n", 0);
|
|
TEST_ASSERT_EQUAL_INT(8, result_minimal);
|
|
|
|
result_minimal = mbed_printf("zu: %zu\r\n", SIZE_MAX);
|
|
result_baseline = printf("zu: %zu\r\n", SIZE_MAX);
|
|
TEST_ASSERT_EQUAL_INT(17, result_minimal);
|
|
|
|
result_minimal = mbed_printf("tu: %tu\r\n", 0);
|
|
result_baseline = printf("tu: %tu\r\n", 0);
|
|
TEST_ASSERT_EQUAL_INT(8, result_minimal);
|
|
|
|
result_minimal = mbed_printf("tu: %tu\r\n", UINTPTR_MAX);
|
|
result_baseline = printf("tu: %tu\r\n", UINTPTR_MAX);
|
|
TEST_ASSERT_EQUAL_INT(27, result_minimal);
|
|
|
|
return CaseNext;
|
|
}
|
|
|
|
static control_t test_printf_x(const size_t call_count)
|
|
{
|
|
int result_baseline;
|
|
int result_minimal;
|
|
|
|
/*************************************************************************/
|
|
/*************************************************************************/
|
|
printf("%%x always prints even characters\r\n");
|
|
|
|
result_minimal = mbed_printf("hhx: %hhx\r\n", 0);
|
|
result_baseline = printf("hhx: %hhx\r\n", 0);
|
|
TEST_ASSERT_EQUAL_INT(9, result_minimal);
|
|
|
|
result_minimal = mbed_printf("hhx: %hhx\r\n", UCHAR_MAX);
|
|
result_baseline = printf("hhx: %hhx\r\n", UCHAR_MAX);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_printf("hx: %hx\r\n", 0);
|
|
result_baseline = printf("hx: %hx\r\n", 0);
|
|
TEST_ASSERT_EQUAL_INT(9, result_minimal);
|
|
|
|
result_minimal = mbed_printf("hx: %hx\r\n", USHRT_MAX);
|
|
result_baseline = printf("hx: %hx\r\n", USHRT_MAX);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_printf("x: %x\r\n", 0);
|
|
result_baseline = printf("x: %x\r\n", 0);
|
|
TEST_ASSERT_EQUAL_INT(9, result_minimal);
|
|
|
|
result_minimal = mbed_printf("x: %x\r\n", UINT_MAX);
|
|
result_baseline = printf("x: %x\r\n", UINT_MAX);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_printf("x: %x\r\n", 0);
|
|
result_baseline = printf("x: %x\r\n", 0);
|
|
TEST_ASSERT_EQUAL_INT(9, result_minimal);
|
|
|
|
result_minimal = mbed_printf("lx: %lx\r\n", ULONG_MAX);
|
|
result_baseline = printf("lx: %lx\r\n", ULONG_MAX);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_printf("llx: %llx\r\n", 0);
|
|
result_baseline = printf("llx: %llx\r\n", 0ULL);
|
|
TEST_ASSERT_EQUAL_INT(9, result_minimal);
|
|
|
|
result_minimal = mbed_printf("llx: %llx\r\n", ULLONG_MAX);
|
|
result_baseline = printf("llx: %llx\r\n", ULLONG_MAX);
|
|
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
|
|
|
|
result_minimal = mbed_printf("jx: %jx\r\n", 0);
|
|
result_baseline = printf("jx: %jx\r\n", (uintmax_t) 0);
|
|
TEST_ASSERT_EQUAL_INT(9, result_minimal);
|
|
|
|
result_minimal = mbed_printf("jx: %jx\r\n", UINTMAX_MAX);
|
|
result_baseline = printf("jx: %jx\r\n", UINTMAX_MAX);
|
|
TEST_ASSERT_EQUAL_INT(9, result_minimal);
|
|
|
|
result_minimal = mbed_printf("zx: %zx\r\n", 0);
|
|
result_baseline = printf("zx: %zx\r\n", 0);
|
|
TEST_ASSERT_EQUAL_INT(9, result_minimal);
|
|
|
|
result_minimal = mbed_printf("zx: %zx\r\n", SIZE_MAX);
|
|
result_baseline = printf("zx: %zx\r\n", SIZE_MAX);
|
|
TEST_ASSERT_EQUAL_INT(15, result_minimal);
|
|
|
|
result_minimal = mbed_printf("tx: %tx\r\n", 0);
|
|
result_baseline = printf("tx: %tx\r\n", 0);
|
|
TEST_ASSERT_EQUAL_INT(9, result_minimal);
|
|
|
|
result_minimal = mbed_printf("tx: %tx\r\n", UINTPTR_MAX);
|
|
result_baseline = printf("tx: %tx\r\n", UINTPTR_MAX);
|
|
TEST_ASSERT_EQUAL_INT(23, result_minimal);
|
|
|
|
// result_minimal = mbed_snprintf(buffer_minimal, 1000, "hello world %d %u %X %p %s %2.5f %% %\r\n", LONG_MIN, 0, 0, buffer, "muh", -1*pi);
|
|
// mbed_printf("%s\r\n", buffer);
|
|
|
|
// mbed_printf("results: %d\r\n", result);
|
|
|
|
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);
|
|
|
|
printf("%%jd not supported by mbed\r\n");
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "jd: %jd\r\n", INT32_MIN);
|
|
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "jd: %jd\r\n", INT32_MIN);
|
|
TEST_ASSERT_EQUAL_STRING("jd: -2147483648\r\n", buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(18, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "jd: %jd\r\n", INT32_MAX);
|
|
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "jd: %jd\r\n", INT32_MAX);
|
|
TEST_ASSERT_EQUAL_STRING("jd: 2147483647\r\n", buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(17, result_minimal);
|
|
|
|
printf("%%zd not supported by mbed\r\n");
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "zd: %zd\r\n", INT32_MIN);
|
|
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "zd: %zd\r\n", INT32_MIN);
|
|
TEST_ASSERT_EQUAL_STRING("zd: -2147483648\r\n", buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(18, result_minimal);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "zd: %zd\r\n", INT32_MAX);
|
|
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "zd: %zd\r\n", INT32_MAX);
|
|
TEST_ASSERT_EQUAL_STRING("zd: 2147483647\r\n", buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(17, result_minimal);
|
|
|
|
printf("%%td not supported by mbed\r\n");
|
|
|
|
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(18, 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(17, result_minimal);
|
|
|
|
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", 0);
|
|
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", 0);
|
|
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);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "ju: %ju\r\n", 0);
|
|
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "ju: %ju\r\n", (uintmax_t) 0);
|
|
TEST_ASSERT_EQUAL_STRING("ju: 0\r\n", buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(8, 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(8, result_minimal);
|
|
|
|
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("zu: 0\r\n", buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(8, 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(17, result_minimal);
|
|
|
|
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("tu: 0\r\n", buffer_minimal);
|
|
TEST_ASSERT_EQUAL_INT(8, 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(27, result_minimal);
|
|
|
|
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;
|
|
|
|
/*************************************************************************/
|
|
/*************************************************************************/
|
|
printf("%%x always prints even characters\r\n");
|
|
|
|
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(9, 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(9, 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_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", 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(9, 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), "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(9, 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", 0);
|
|
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(9, 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);
|
|
|
|
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "jx: %jx\r\n", 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(9, 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(9, result_minimal);
|
|
|
|
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(9, 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(15, result_minimal);
|
|
|
|
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(9, 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(23, result_minimal);
|
|
|
|
// result_minimal = mbed_snprintf(buffer_minimal, 1000, "hello world %d %u %X %p %s %2.5f %% %\r\n", LONG_MIN, 0, 0, buffer, "muh", -1*pi);
|
|
// mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "%s\r\n", buffer);
|
|
|
|
// mbed_printf("results: %d\r\n", result);
|
|
|
|
return CaseNext;
|
|
}
|
|
|
|
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("printf %u", test_printf_u),
|
|
Case("printf %x", test_printf_x),
|
|
Case("snprintf %d", test_snprintf_d),
|
|
Case("snprintf %u", test_snprintf_u),
|
|
Case("snprintf %x", test_snprintf_x),
|
|
};
|
|
|
|
Specification specification(greentea_setup, cases, greentea_test_teardown_handler);
|
|
|
|
int main()
|
|
{
|
|
return !Harness::run(specification);
|
|
}
|