From c26f0ff2e4425dffcab023fec4f49f8c959d542d Mon Sep 17 00:00:00 2001 From: Johannes Date: Thu, 14 Feb 2019 08:28:46 -0600 Subject: [PATCH] apps/testing/scanftest: Port of Greg King's scanf test (https://github.com/cc65). --- testing/scanftest/.gitignore | 12 + testing/scanftest/Kconfig | 30 + testing/scanftest/Make.defs | 39 + testing/scanftest/Makefile | 59 ++ testing/scanftest/scanftest_main.c | 1406 ++++++++++++++++++++++++++++ 5 files changed, 1546 insertions(+) create mode 100644 testing/scanftest/.gitignore create mode 100644 testing/scanftest/Kconfig create mode 100644 testing/scanftest/Make.defs create mode 100644 testing/scanftest/Makefile create mode 100644 testing/scanftest/scanftest_main.c diff --git a/testing/scanftest/.gitignore b/testing/scanftest/.gitignore new file mode 100644 index 000000000..caa9bdef2 --- /dev/null +++ b/testing/scanftest/.gitignore @@ -0,0 +1,12 @@ +/hello +/Make.dep +/.depend +/.built +/*.asm +/*.obj +/*.rel +/*.lst +/*.sym +/*.adb +/*.lib +/*.src diff --git a/testing/scanftest/Kconfig b/testing/scanftest/Kconfig new file mode 100644 index 000000000..1eb225e5e --- /dev/null +++ b/testing/scanftest/Kconfig @@ -0,0 +1,30 @@ +# +# For a description of the syntax of this configuration file, +# see the file kconfig-language.txt in the NuttX tools repository. +# + +config TESTING_SCANFTEST + tristate "sscanf() test" + default n + ---help--- + Enable sscanf() test + +if TESTING_SCANFTEST + +config TESTING_SCANFTEST_PROGNAME + string "Program name" + default "scanftest" + depends on BUILD_LOADABLE + ---help--- + This is the name of the program that will be use when the NSH ELF + program is installed. + +config TESTING_SCANFTEST_PRIORITY + int "Scanftest task priority" + default 100 + +config TESTING_SCANFTEST_STACKSIZE + int "Scanftest stack size" + default 2048 + +endif diff --git a/testing/scanftest/Make.defs b/testing/scanftest/Make.defs new file mode 100644 index 000000000..e92914e81 --- /dev/null +++ b/testing/scanftest/Make.defs @@ -0,0 +1,39 @@ +############################################################################ +# apps/testing/scanftest/Make.defs +# Adds selected applications to apps/ build +# +# Copyright (C) 2019 Gregory Nutt. All rights reserved. +# Author: Gregory Nutt +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# 1. Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in +# the documentation and/or other materials provided with the +# distribution. +# 3. Neither the name NuttX nor the names of its contributors may be +# used to endorse or promote products derived from this software +# without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS +# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED +# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. +# +############################################################################ + +ifneq ($(CONFIG_TESTING_SCANFTEST),) +CONFIGURED_APPS += testing/scanftest +endif diff --git a/testing/scanftest/Makefile b/testing/scanftest/Makefile new file mode 100644 index 000000000..f8247401f --- /dev/null +++ b/testing/scanftest/Makefile @@ -0,0 +1,59 @@ +############################################################################ +# apps/testing/scanftest/Makefile +# +# Copyright (C) 2019 Gregory Nutt. All rights reserved. +# Author: Gregory Nutt +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# 1. Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in +# the documentation and/or other materials provided with the +# distribution. +# 3. Neither the name NuttX nor the names of its contributors may be +# used to endorse or promote products derived from this software +# without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS +# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED +# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. +# +############################################################################ + +-include $(TOPDIR)/Make.defs + +# scanf() test built-in application info + +CONFIG_TESTING_SCANFTEST_PRIORITY ?= SCHED_PRIORITY_DEFAULT +CONFIG_TESTING_SCANFTEST_STACKSIZE ?= 2048 + +APPNAME = scanftest + +PRIORITY = $(CONFIG_TESTING_SCANFTEST_PRIORITY) +STACKSIZE = $(CONFIG_TESTING_SCANFTEST_STACKSIZE) + +# scanf test files + +ASRCS = +CSRCS = +MAINSRC = scanftest_main.c + +CONFIG_TESTING_SCANFTEST_PROGNAME ?= scanftest$(EXEEXT) +PROGNAME = $(CONFIG_TESTING_SCANFTEST_PROGNAME) + +MODULE = CONFIG_TESTING_SCANFTEST + +include $(APPDIR)/Application.mk diff --git a/testing/scanftest/scanftest_main.c b/testing/scanftest/scanftest_main.c new file mode 100644 index 000000000..4a8e89930 --- /dev/null +++ b/testing/scanftest/scanftest_main.c @@ -0,0 +1,1406 @@ +/**************************************************************************** + * apps/testing/scanftest_main.c + * + * Copyright (C) 2005-01-26, Greg King (https://github.com/cc65) + * + * Original License: + * This software is provided 'as-is', without any express or implied warranty. + * In no event will the authors be held liable for any damages arising from + * the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software in + * a product, an acknowledgment in the product documentation would be + * appreciated but is not required. + * + * 2. Altered source versions must be plainly marked as such, and must not + * be misrepresented as being the original software. + * + * 3. This notice may not be removed or altered from any source distribution. + * + * Modified: Johannes Schock + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * 3. Neither the name NuttX nor the names of its contributors may be + * used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + ****************************************************************************/ + +/**************************************************************************** + * Included Files + ****************************************************************************/ + +#include + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/**************************************************************************** + * Pre-processor Definitions + ****************************************************************************/ + +#define ARRAYSIZE(a) (sizeof (a) / sizeof (a)[0]) + +/**************************************************************************** + * Private Data + ****************************************************************************/ + +/**************************************************************************** + * Name: cmd_basename + ****************************************************************************/ + +static const struct +{ + const char *input, *format; + int rvalue; + enum TYPE + { + INT, + CHAR, + FLOAT, + DOUBLE + } type1; + union + { + int nvalue; + float fvalue; + double dvalue; + const char *svalue; + } v1; + enum TYPE type2; + union + { + int nvalue; + float fvalue; + double dvalue; + const char *svalue; + } v2; +} +test_data[] = +{ + /* Input sequences for character specifiers must be less than 80 characters + * ** long. These format strings are allowwed a maximum of two assignment ** + * specifications. + */ + + /* Test that literals match, and that they aren't seen as conversions. ** + * Test that integer specifiers can handle end-of-file. + */ + + { + "qwerty Dvorak", "qwerty Dvorak", 0, INT, + { + .nvalue = 0 + }, + INT, + { + .nvalue = 0 + } + }, /* 1 */ + { + "qwerty", "qwerty %d%i", EOF, INT, + { + .nvalue = 0 + }, + INT, + { + .nvalue = 0 + } + }, /* 2 */ + { + "qwerty ", "qwerty %d%i", EOF, INT, + { + .nvalue = 0 + }, + INT, + { + .nvalue = 0 + } + }, /* 3 */ + + /* Test that integer specifiers scan properly. */ + + { + "qwerty a", "qwerty %d%i", 0, INT, + { + .nvalue = 0 + }, + INT, + { + .nvalue = 0 + } + }, /* 4 */ + { + "qwerty -", "qwerty %d%i", 0, INT, + { + .nvalue = 0 + }, + INT, + { + .nvalue = 0 + } + }, /* 5 */ + { + "qwerty -9", "qwerty %d%i", 1, INT, + { + .nvalue = -9 + }, + INT, + { + .nvalue = 0 + } + }, /* 6 */ + { + "qwerty -95", "qwerty %d%i", 1, INT, + { + .nvalue = -95 + }, + INT, + { + .nvalue = 0 + } + }, /* 7 */ + { + "qwerty -95a", "qwerty %d%i", 1, INT, + { + .nvalue = -95 + }, + INT, + { + .nvalue = 0 + } + }, /* 8 */ + { + "qwerty -95a 1", "qwerty %d%i", 1, INT, + { + .nvalue = -95 + }, + INT, + { + .nvalue = 0 + } + }, /* 9 */ + { + "qwerty -a", "qwerty %d%i", 0, INT, + { + .nvalue = 0 + }, + INT, + { + .nvalue = 0 + } + }, /* 10 */ + { + "qwerty -95 1", "qwerty %d%i", 2, INT, + { + .nvalue = -95 + }, + INT, + { + .nvalue = 1 + } + }, /* 11 */ + { + "qwerty 95 2", "qwerty %i", 1, INT, + { + .nvalue = 95 + }, + INT, + { + .nvalue = 0 + } + }, /* 12 */ + { + "qwerty -95 +2", "qwerty %x%o", 2, INT, + { + .nvalue = -0x95 + }, + INT, + { + .nvalue = 2 + } + }, /* 13 */ + { + "qwerty 0x9e 02", "qwerty %i%i", 2, INT, + { + .nvalue = 0x9e + }, + INT, + { + .nvalue = 2 + } + }, /* 14 */ + { + "qwerty 095 2", "qwerty %i%i", 2, INT, + { + .nvalue = 0 + }, + INT, + { + .nvalue = 95 + } + }, /* 15 */ + { + "qwerty 0e5 2", "qwerty %i%i", 1, INT, + { + .nvalue = 0 + }, + INT, + { + .nvalue = 0 + } + }, /* 16 */ + + /* Test that character specifiers can handle end-of-file. */ + + { + "qwerty", "qwerty %s%s", EOF, CHAR, + { + .svalue = "" + }, + CHAR, + { + .svalue = "" + } + }, /* 17 */ + { + "qwerty ", "qwerty %s%s", EOF, CHAR, + { + .svalue = "" + }, + CHAR, + { + .svalue = "" + } + }, /* 18 */ + { + "qwerty", "qwerty %c%c", EOF, CHAR, + { + .svalue = "" + }, + CHAR, + { + .svalue = "" + } + }, /* 19 */ + { + "qwerty ", "qwerty %c%c", EOF, CHAR, + { + .svalue = "" + }, + CHAR, + { + .svalue = "" + } + }, /* 20 */ + { + "qwerty", "qwerty %[ a-z]%c", EOF, CHAR, + { + .svalue = "" + }, + CHAR, + { + .svalue = "" + } + }, /* 21 */ + { + "qwerty ", "qwerty %[ a-z]%c", EOF, CHAR, + { + .svalue = "" + }, + CHAR, + { + .svalue = "" + } + }, /* 22 */ + { + "qwerty ", "qwerty%s%s", EOF, CHAR, + { + .svalue = "" + }, + CHAR, + { + .svalue = "" + } + }, /* 23 */ + + /* Test that character specifiers scan properly. */ + + { + "123456qwertyasdfghzxcvbn!@#$%^QWERTYASDFGHZXCV" + "BN7890-=uiop[]\\jkl;'m,./&*()_+UIOP{}|JKL:\"M<>?", "%79s%79s", 2, CHAR, + { + .svalue = "123456qwertyasdfghzxcvbn!@#$%^QWERTYASDFGHZXCV" + "BN7890-=uiop[]\\jkl;'m,./&*()_+UIO" + }, + CHAR, + { + .svalue = "P{}|JKL:\"M<>?" + } + }, /* 24 */ + { + "qwerty ", "qwerty%c%c", 2, CHAR, + { + .svalue = " " + }, + CHAR, + { + .svalue = " " + } + }, /* 25 */ + { + "qwerty ", "qwerty%2c%c", 2, CHAR, + { + .svalue = " " + }, + CHAR, + { + .svalue = " " + } + }, /* 26 */ + { + "qwerty ", "qwerty%2c%2c", 1, CHAR, + { + .svalue = " " + }, + CHAR, + { + .svalue = " " + } + }, /* 27 */ + { + "qwerty ", "qwerty%[ a-z]%c", 1, CHAR, + { + .svalue = " " + }, + CHAR, + { + .svalue = "" + } + }, /* 28 */ + { + "qwerty q", "qwerty%[ a-z]%c", 1, CHAR, + { + .svalue = " q" + }, + CHAR, + { + .svalue = "" + } + }, /* 29 */ + { + "qwerty Q", "qwerty%[ a-z]%c", 2, CHAR, + { + .svalue = " " + }, + CHAR, + { + .svalue = "Q" + } + }, /* 30 */ + { + "qwerty-QWERTY-", "%[q-ze-]%[-A-Z]", 2, CHAR, + { + .svalue = "qwerty-" + }, + CHAR, + { + .svalue = "QWERTY-" + } + }, /* 31 */ + + /* Test the space-separation of strings. */ + + { + "qwerty qwerty", "qwerty%s%s", 1, CHAR, + { + .svalue = "qwerty" + }, + CHAR, + { + .svalue = "" + } + }, /* 32 */ + { + "qwerty qwerty Dvorak", "qwerty%s%s", 2, CHAR, + { + .svalue = "qwerty" + }, + CHAR, + { + .svalue = "Dvorak" + } + }, /* 33 */ + + /* Test the mixxing of types. */ + + { + "qwerty abc3", "qwerty%s%X", 1, CHAR, + { + .svalue = "abc3" + }, + INT, + { + .nvalue = 0 + } + }, /* 34 */ + { + "qwerty abc3", "qwerty%[ a-z]%X", 2, CHAR, + { + .svalue = " abc" + }, + INT, + { + .nvalue = 3 + } + }, /* 35 */ + { + "qwerty abc3", "qwerty%[ a-z3]%X", 1, CHAR, + { + .svalue = " abc3" + }, + INT, + { + .nvalue = 0 + } + }, /* 36 */ + { + "qwerty abc3", "qwerty%[ A-Z]%X", 2, CHAR, + { + .svalue = " " + }, + INT, + { + .nvalue = 0xabc3 + } + }, /* 37 */ + { + "qwerty 3abc", "qwerty%i%[ a-z]", 2, INT, + { + .nvalue = 3 + }, + CHAR, + { + .svalue = "abc" + } + }, /* 38 */ + { + "qwerty 3abc", "qwerty%i%[ A-Z]", 1, INT, + { + .nvalue = 3 + }, + CHAR, + { + .svalue = "" + } + }, /* 39 */ + + /* Test the character-count specifier. */ + + { + " 95 5", "%n%i", 1, INT, + { + .nvalue = 0 + }, + INT, + { + .nvalue = 95 + } + }, /* 40 */ + { + " a5 5", "%n%i", 0, INT, + { + .nvalue = 0 + }, + INT, + { + .nvalue = 0 + } + }, /* 41 */ + { + " a5 5", "%x%n", 1, INT, + { + .nvalue = 0xa5 + }, + INT, + { + .nvalue = 4 + } + }, /* 42 */ + { + " a5 5", " %4c%n", 1, CHAR, + { + .svalue = "a5 5" + }, + INT, + { + .nvalue = 6 + } + }, /* 43 */ + { + " 05a9", "%i%n", 1, INT, + { + .nvalue = 5 + }, + INT, + { + .nvalue = 3 + } + }, /* 44 */ + + /* Test assignment-suppression. */ + + { + " 95 6", "%n%*i", 0, INT, + { + .nvalue = 0 + }, + INT, + { + .nvalue = 0 + } + }, /* 45 */ + { + " a5 6", "%*x%n", 0, INT, + { + .nvalue = 4 + }, + INT, + { + .nvalue = 0 + } + }, /* 46 */ + { + " a5 6", "%*x%n%o", 1, INT, + { + .nvalue = 4 + }, + INT, + { + .nvalue = 6 + } + }, /* 47 */ + { + " a5 6", " %*4c%d", 0, CHAR, + { + .svalue = "" + }, + INT, + { + .nvalue = 0 + } + }, /* 48 */ + { + "The first number is 7. The second number is 8.\n", + "%*[ .A-Za-z]%d%*[ .A-Za-z]%d", 2, INT, + { + .nvalue = 7 + }, + INT, + { + .nvalue = 8 + } + }, /* 49 */ + + /* Test that float specifiers can handle end-of-file. */ + + { + "qwerty", "qwerty %f%i", EOF, FLOAT, + { + .fvalue = 0 + }, + INT, + { + .nvalue = 0 + } + }, /* 50 */ + { + "qwerty ", "qwerty %f%i", EOF, FLOAT, + { + .fvalue = 0 + }, + INT, + { + .nvalue = 0 + } + }, /* 51 */ + + /* Test that float specifiers scan properly. */ + + { + "qwerty a", "qwerty %f%i", 0, FLOAT, + { + .fvalue = 0 + }, + INT, + { + .nvalue = 0 + } + }, /* 52 */ + { + "qwerty -", "qwerty %f%i", 0, FLOAT, + { + .fvalue = 0 + }, + INT, + { + .nvalue = 0 + } + }, /* 53 */ + { + "qwerty 9.87654321", "qwerty %f%i", 1, FLOAT, + { + .fvalue = 9.87654321f + }, + INT, + { + .nvalue = 0 + } + }, /* 54 */ + { + "qwerty +9.87654321", "qwerty %f%i", 1, FLOAT, + { + .fvalue = 9.87654321f + }, + INT, + { + .nvalue = 0 + } + }, /* 54 */ + { + "qwerty -9.87654321", "qwerty %f%i", 1, FLOAT, + { + .fvalue = -9.87654321f + }, + INT, + { + .nvalue = 0 + } + }, /* 55 */ + { + "qwerty 9.87654321E8", "qwerty %f%i", 1, FLOAT, + { + .fvalue = 9.87654321E8f + }, + INT, + { + .nvalue = 0 + } + }, /* 56 */ + { + "qwerty +9.87654321E+8", "qwerty %f%i", 1, FLOAT, + { + .fvalue = 9.87654321E8f + }, + INT, + { + .nvalue = 0 + } + }, /* 56 */ + { + "qwerty -9.87654321e8", "qwerty %f%i", 1, FLOAT, + { + .fvalue = -9.87654321E8f + }, + INT, + { + .nvalue = 0 + } + }, /* 57 */ + { + "qwerty 9.87654321E-8", "qwerty %f%i", 1, FLOAT, + { + .fvalue = 9.87654321E-8f + }, + INT, + { + .nvalue = 0 + } + }, /* 58 */ + { + "qwerty -9.87654321e-8", "qwerty %f%i", 1, FLOAT, + { + .fvalue = -9.87654321E-8f + }, + INT, + { + .nvalue = 0 + } + }, /* 59 */ + { + "qwerty 9.87654321", "qwerty %lf%i", 1, DOUBLE, + { + .dvalue = 9.87654321l + }, + INT, + { + .nvalue = 0 + } + }, /* 60 */ + { + "qwerty +9.87654321", "qwerty %lf%i", 1, DOUBLE, + { + .dvalue = 9.87654321l + }, + INT, + { + .nvalue = 0 + } + }, /* 60 */ + { + "qwerty -9.87654321", "qwerty %lf%i", 1, DOUBLE, + { + .dvalue = -9.87654321l + }, + INT, + { + .nvalue = 0 + } + }, /* 61 */ + { + "qwerty 9.87654321e8", "qwerty %lf%i", 1, DOUBLE, + { + .dvalue = 9.87654321E8l + }, + INT, + { + .nvalue = 0 + } + }, /* 62 */ + { + "qwerty +9.87654321e+8", "qwerty %lf%i", 1, DOUBLE, + { + .dvalue = 9.87654321E8l + }, + INT, + { + .nvalue = 0 + } + }, /* 62 */ + { + "qwerty -9.87654321E8", "qwerty %lf%i", 1, DOUBLE, + { + .dvalue = -9.87654321E8l + }, + INT, + { + .nvalue = 0 + } + }, /* 63 */ + { + "qwerty 9.87654321e-8", "qwerty %lf%i", 1, DOUBLE, + { + .dvalue = 9.87654321E-8l + }, + INT, + { + .nvalue = 0 + } + }, /* 64 */ + { + "qwerty -9.87654321E-8", "qwerty %lf%i", 1, DOUBLE, + { + .dvalue = -9.87654321E-8l + }, + INT, + { + .nvalue = 0 + } + }, /* 65 */ +}; + +/* Test the char, short, and long specification-modifiers. */ + +static const struct +{ + const char *input, *format; + union + { + long long s; + unsigned long long u; + } value; + enum MODTYPE + { + HH_MOD_S, + HH_MOD_U, + H_MOD_S, + H_MOD_U, + NO_MOD_S, + NO_MOD_U, + L_MOD_S, + L_MOD_U, + LL_MOD_S, + LL_MOD_U + } type; +} +type_data[] = +{ + { + " 123456789", "%hhd", + { + .s = (signed char)123456789L + }, + HH_MOD_S + }, + { + "+123456789", "%hhd", + { + .s = (signed char)123456789L + }, + HH_MOD_S + }, + { + "-123456789", "%hhd", + { + .s = (signed char)-123456789L + }, + HH_MOD_S + }, + { + "+123456789", "%hhu", + { + .u = (unsigned char)123456789L + }, + HH_MOD_U + }, + { + "-123456789", "%hhu", + { + .u = (unsigned char)-123456789L + }, + HH_MOD_U + }, + { + " 123456789", "%hd", + { + .s = (signed short)123456789L + }, + H_MOD_S + }, + { + "+123456789", "%hd", + { + .s = (signed short)123456789L + }, + H_MOD_S + }, + { + "-123456789", "%hd", + { + .s = (signed short)-123456789L + }, + H_MOD_S + }, + { + "+123456789", "%hu", + { + .u = (unsigned short)123456789L + }, + H_MOD_U + }, + { + "-123456789", "%hu", + { + .u = (unsigned short)-123456789L + }, + H_MOD_U + }, + { + " 123456789", "%d", + { + .s = (signed int)123456789L + }, + NO_MOD_S + }, + { + "+123456789", "%d", + { + .s = (signed int)123456789L + }, + NO_MOD_S + }, + { + "-123456789", "%d", + { + .s = (signed int)-123456789L + }, + NO_MOD_S + }, + { + "+123456789", "%u", + { + .u = (unsigned int)123456789L + }, + NO_MOD_U + }, + { + "-123456789", "%u", + { + .u = (unsigned int)-123456789L + }, + NO_MOD_U + }, + { + " 123456789", "%ld", + { + .s = (signed long)123456789L + }, + L_MOD_S + }, + { + "+123456789", "%ld", + { + .s = (signed long)123456789L + }, + L_MOD_S + }, + { + "-123456789", "%ld", + { + .s = (signed long)-123456789L + }, + L_MOD_S + }, + { + "+123456789", "%lu", + { + .u = (unsigned long)123456789L + }, + L_MOD_U + }, + { + "-123456789", "%lu", + { + .u = (unsigned long)-123456789L + }, + L_MOD_U + }, + { + " 123456789123456789", "%lld", + { + .s = (signed long long)123456789123456789LL + }, + LL_MOD_S + }, + { + "+123456789123456789", "%lld", + { + .s = (signed long long)123456789123456789LL + }, + LL_MOD_S + }, + { + "-123456789123456789", "%lld", + { + .s = (signed long long)-123456789123456789LL + }, + LL_MOD_S + }, + { + "+123456789123456789", "%llu", + { + .u = (unsigned long long)123456789123456789LL + }, + LL_MOD_U + }, + { + "-123456789123456789", "%llu", + { + .u = (unsigned long long)-123456789123456789LL + }, + LL_MOD_U + }, +}; + +/**************************************************************************** + * Public Functions + ****************************************************************************/ + +/**************************************************************************** + * scanftest_main + ****************************************************************************/ + +#if defined(BUILD_MODULE) +int main(int argc, FAR char *argv[]) +#else +int scanftest_main(int argc, char *argv[]) +#endif +{ + int t; + int i; + int c, n1 = 12345, n2; + char s1[80], s2[80]; + float f1, f2; + double d1, d2; + FILE *fp; + + /* Test that scanf() can recognize percent-signs in the input. ** Test that + * integer converters skip white-space. ** Test that "%i" can scan a single + * zero digit (followed by EOF). + */ + + sscanf("% \n\f\v\t 0", "%%%i", &n1); + if (n1 != 0) + { + printf("sscanf()'s \"%%%%%%i\" couldn't scan either a \"%%\" " + "or a single zero digit.\n\n"); + } + + /* Test scanf()'s return-value: EOF if input ends before the first * + * conversion-attempt begins; an assignment-count, otherwise. * Test that + * scanf() properly converts and assigns the correct number * of arguments. + */ + + for (i = 0; i < 2; i++) + { + printf + ("Testing %cscanf()'s return-value,\nconversions, and assignments...\n", + i ? 'f' : 's'); + + if (i) + { + memset(s1, '\0', sizeof s1); + memset(s2, '\0', sizeof s2); + + fp = fopen("/mnt/fs/test.txt", "wb"); + if (fp) + { + fputs("teststring a", fp); + fclose(fp); + } + else + { + printf("Filesystem Error Write\n"); + } + + fp = fopen("/mnt/fs/test.txt", "rb"); + if (fp) + { + c = fscanf(fp, "%s", s1, s2); + c = fscanf(fp, "%2c", s2); + printf("Back to Back test: \"teststring a\" == \"%s%s\"?\n", s1, + s2); + } + else + { + printf("Filesystem Error Read\n"); + } + } + + for (t = 0; t < ARRAYSIZE(test_data); ++t) + { + /* Prefill the arguments with zeroes. */ + + f1 = f2 = d1 = d2 = n1 = n2 = 0; + memset(s1, '\0', sizeof s1); + memset(s2, '\0', sizeof s2); + + if (i) + { + fp = fopen("/mnt/fs/test.txt", "wb"); + if (fp) + { + fputs(test_data[t].input, fp); + fclose(fp); + } + else + { + printf("Filesystem Error Write\n"); + break; + } + + fp = fopen("/mnt/fs/test.txt", "rb"); + if (fp) + { + c = fscanf + (fp, test_data[t].format, + + /* Avoid warning messages about different pointer- + * types, by casting them to void-pointers. + */ + + test_data[t].type1 == INT ? (FAR void *)&n1 : + test_data[t].type1 == FLOAT ? (FAR void *)&f1 : + test_data[t].type1 == DOUBLE ? (FAR void *)&d1 : + (FAR void *)s1, + test_data[t].type2 == INT ? (FAR void *)&n2 : + test_data[t].type2 == FLOAT ? (FAR void *)&f2 : + test_data[t].type2 == DOUBLE ? (FAR void *)&d2 : + (FAR void *)s2 + ); + + fclose(fp); + } + else + { + printf("Filesystem Error Read\n"); + break; + } + } + else + { + c = sscanf + (test_data[t].input, test_data[t].format, + + /* Avoid warning messages about different pointer-types, by + * casting them to void-pointers. + */ + + test_data[t].type1 == INT ? (FAR void *)&n1 : + test_data[t].type1 == FLOAT ? (FAR void *)&f1 : + test_data[t].type1 == DOUBLE ? (FAR void *)&d1 : + (FAR void *)s1, + test_data[t].type2 == INT ? (FAR void *)&n2 : + test_data[t].type2 == FLOAT ? (FAR void *)&f2 : + test_data[t].type2 == DOUBLE ? (FAR void *)&d2 : + (FAR void *)s2 + ); + } + if (c != test_data[t].rvalue) + { + printf("Test #%u returned %d instead of %d.\n", t + 1, c, + test_data[t].rvalue); + } + + if (test_data[t].type1 == INT) + { + if (test_data[t].v1.nvalue != n1) + { + printf("Test #%u assigned %i, instead of %i,\n" + "\tto the first argument.\n\n", t + 1, n1, + test_data[t].v1.nvalue); + } + } + else if (test_data[t].type1 == FLOAT) + { + if (test_data[t].v1.fvalue != f1) + { + printf("Test #%u assigned %e, instead of %e,\n" + "\tto the first argument.\n\n", t + 1, f1, + test_data[t].v1.fvalue); + } + } + else if (test_data[t].type1 == DOUBLE) + { + if (test_data[t].v1.dvalue != d1) + { + printf("Test #%u assigned %le, instead of %le,\n" + "\tto the first argument.\n\n", t + 1, d1, + test_data[t].v1.dvalue); + } + } + else + { + /* test_data[t].type1 == CHAR */ + + if (strcmp(test_data[t].v1.svalue, s1)) + { + printf("Test #%u assigned\n\"%s\",\n" + "\tinstead of\n\"%s\",\n" + "\tto the first argument.\n\n", t + 1, s1, + test_data[t].v1.svalue); + } + } + + if (test_data[t].type2 == INT) + { + if (test_data[t].v2.nvalue != n2) + { + printf("Test #%u assigned %i, instead of %i,\n" + "\tto the second argument.\n\n", t + 1, n2, + test_data[t].v2.nvalue); + } + } + else if (test_data[t].type2 == FLOAT) + { + if (test_data[t].v2.fvalue != f2) + { + printf("Test #%u assigned %e, instead of %e,\n" + "\tto the second argument.\n\n", t + 1, f2, + test_data[t].v2.fvalue); + } + } + else if (test_data[t].type2 == DOUBLE) + { + if (test_data[t].v2.dvalue != d2) + { + printf("Test #%u assigned %le, instead of %le,\n" + "\tto the second argument.\n\n", t + 1, d2, + test_data[t].v2.dvalue); + } + } + else + { + /* test_data[t].type2 == CHAR */ + + if (strcmp(test_data[t].v2.svalue, s2)) + { + printf("Test #%u assigned\n\"%s\",\n" + "\tinstead of\n\"%s\",\n" + "\tto the second argument.\n\n", t + 1, s2, + test_data[t].v2.svalue); + } + } + } + } + + /* Test the char, short, and long specification-modifiers. */ + + printf("Testing scanf()'s type-modifiers...\n"); + for (t = 0; t < ARRAYSIZE(type_data); ++t) + { + unsigned char hhu; + unsigned short hu; + unsigned int nou; + unsigned long lu; + unsigned long long llu; + signed char hhs; + signed short hs; + signed int nos; + signed long ls; + signed long long lls; + + switch (type_data[t].type) + { + case HH_MOD_S: + hhs = 0L; + sscanf(type_data[t].input, type_data[t].format, &hhs); + if (type_data[t].value.s != hhs) + { + printf("Test #%u assigned %hhd instead of %lli.\n", t + 1, + hhs, type_data[t].value.s); + } + break; + + case HH_MOD_U: + hhu = 0L; + sscanf(type_data[t].input, type_data[t].format, &hhu); + if (type_data[t].value.u != hhu) + { + printf("Test #%u assigned %hhu instead of %lli.\n", + t + 1, hhu, type_data[t].value.u); + } + break; + + case H_MOD_S: + hs = 0L; + sscanf(type_data[t].input, type_data[t].format, &hs); + if (type_data[t].value.s != hs) + { + printf("Test #%u assigned %hd instead of %lli.\n", + t + 1, hs, type_data[t].value.s); + } + break; + + case H_MOD_U: + hu = 0L; + sscanf(type_data[t].input, type_data[t].format, &hu); + if (type_data[t].value.u != hu) + { + printf("Test #%u assigned %hu instead of %lli.\n", + t + 1, hu, type_data[t].value.u); + } + break; + + case NO_MOD_S: + nos = 0L; + sscanf(type_data[t].input, type_data[t].format, &nos); + if (type_data[t].value.s != nos) + { + printf("Test #%u assigned %d instead of %lli.\n", + t + 1, nos, type_data[t].value.s); + } + break; + + case NO_MOD_U: + nou = 0L; + sscanf(type_data[t].input, type_data[t].format, &nou); + if (type_data[t].value.u != nou) + { + printf("Test #%u assigned %nou instead of %lli.\n", + t + 1, nou, type_data[t].value.u); + } + break; + + case L_MOD_S: + ls = 0L; + sscanf(type_data[t].input, type_data[t].format, &ls); + if (type_data[t].value.s != ls) + { + printf("Test #%u assigned %ld instead of %lli.\n", + t + 1, ls, type_data[t].value.s); + } + break; + + case L_MOD_U: + lu = 0L; + sscanf(type_data[t].input, type_data[t].format, &lu); + if (type_data[t].value.u != lu) + { + printf("Test #%u assigned %lu instead of %lli.\n", + t + 1, lu, type_data[t].value.u); + } + break; + + case LL_MOD_S: + lls = 0L; + sscanf(type_data[t].input, type_data[t].format, &lls); + if (type_data[t].value.s != lls) + { + printf("Test #%u assigned %lld instead of %lli.\n", + t + 1, lls, type_data[t].value.s); + } + break; + + case LL_MOD_U: + llu = 0L; + sscanf(type_data[t].input, type_data[t].format, &llu); + if (type_data[t].value.u != llu) + { + printf("Test #%u assigned %llu instead of %lli.\n", + t + 1, llu, type_data[t].value.u); + } + break; + } + } + + return OK; +}