nuttx-apps/testing/scanftest/scanftest_main.c

/****************************************************************************
 * apps/testing/scanftest/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 <nuttx/config.h>

#include <sys/types.h>
#include <stdint.h>
#include <stdbool.h>

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <dirent.h>
#include <limits.h>
#include <libgen.h>
#include <errno.h>
#include <debug.h>

/****************************************************************************
 * Pre-processor Definitions
 ****************************************************************************/

#define ARRAYSIZE(a) (sizeof (a) / sizeof (a)[0])

/****************************************************************************
 * Private Data
 ****************************************************************************/

/****************************************************************************
 * Name: cmd_basename
 ****************************************************************************/

static const struct
{
  FAR const char *input;
  FAR const char *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
    }
  },                           /* 55 */
  {
    "qwerty   -9.87654321", "qwerty  %f%i", 1, FLOAT,
    {
      .fvalue = -9.87654321f
    },
    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.87654321E8f
    },
    INT,
    {
      .nvalue = 0
    }
  },                           /* 58 */
  {
    "qwerty   -9.87654321e8", "qwerty  %f%i", 1, FLOAT,
    {
      .fvalue = -9.87654321E8f
    },
    INT,
    {
      .nvalue = 0
    }
  },                           /* 59 */
  {
    "qwerty   9.87654321E-8", "qwerty  %f%i", 1, FLOAT,
    {
      .fvalue = 9.87654321E-8f
    },
    INT,
    {
      .nvalue = 0
    }
  },                           /* 60 */
  {
    "qwerty   -9.87654321e-8", "qwerty  %f%i", 1, FLOAT,
    {
      .fvalue = -9.87654321E-8f
    },
    INT,
    {
      .nvalue = 0
    }
  },                           /* 61 */
  {
    "qwerty   9.87654321", "qwerty  %lf%i", 1, DOUBLE,
    {
      .dvalue = 9.87654321l
    },
    INT,
    {
      .nvalue = 0
    }
  },                           /* 62 */
  {
    "qwerty   +9.87654321", "qwerty  %lf%i", 1, DOUBLE,
    {
      .dvalue = 9.87654321l
    },
    INT,
    {
      .nvalue = 0
    }
  },                           /* 63 */
  {
    "qwerty   -9.87654321", "qwerty  %lf%i", 1, DOUBLE,
    {
      .dvalue = -9.87654321l
    },
    INT,
    {
      .nvalue = 0
    }
  },                           /* 64 */
  {
    "qwerty   9.87654321e8", "qwerty  %lf%i", 1, DOUBLE,
    {
      .dvalue = 9.87654321E8l
    },
    INT,
    {
      .nvalue = 0
    }
  },                           /* 65 */
  {
    "qwerty   +9.87654321e+8", "qwerty  %lf%i", 1, DOUBLE,
    {
      .dvalue = 9.87654321E8l
    },
    INT,
    {
      .nvalue = 0
    }
  },                           /* 66 */
  {
    "qwerty   -9.87654321E8", "qwerty  %lf%i", 1, DOUBLE,
    {
      .dvalue = -9.87654321E8l
    },
    INT,
    {
      .nvalue = 0
    }
  },                           /* 67 */
  {
    "qwerty   9.87654321e-8", "qwerty  %lf%i", 1, DOUBLE,
    {
      .dvalue = 9.87654321E-8l
    },
    INT,
    {
      .nvalue = 0
    }
  },                           /* 68 */
  {
    "qwerty   -9.87654321E-8", "qwerty  %lf%i", 1, DOUBLE,
    {
      .dvalue = -9.87654321E-8l
    },
    INT,
    {
      .nvalue = 0
    }
  },                           /* 69 */
};

/* Test the char, short, and long specification-modifiers. */

static const struct
{
  FAR const char *input;
  FAR const char *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
  },                           /*  1 */
  {
    "+123456789", "%hhd",
    {
      .s = (signed char)123456789L
    },
    HH_MOD_S
  },                           /*  2 */
  {
    "-123456789", "%hhd",
    {
      .s = (signed char)-123456789L
    },
    HH_MOD_S
  },                           /*  3 */
  {
    "+123456789", "%hhu",
    {
      .u = (unsigned char)123456789L
    },
    HH_MOD_U
  },                           /*  4 */
  {
    "-123456789", "%hhu",
    {
      .u = (unsigned char)-123456789L
    },
    HH_MOD_U
  },                           /*  5 */
  {
    " 123456789", "%hd",
    {
      .s = (signed short)123456789L
    },
    H_MOD_S
  },                           /*  6 */
  {
    "+123456789", "%hd",
    {
      .s = (signed short)123456789L
    },
    H_MOD_S
  },                           /*  7 */
  {
    "-123456789", "%hd",
    {
      .s = (signed short)-123456789L
    },
    H_MOD_S
  },                           /*  8 */
  {
    "+123456789", "%hu",
    {
      .u = (unsigned short)123456789L
    },
    H_MOD_U
  },                           /*  9 */
  {
    "-123456789", "%hu",
    {
      .u = (unsigned short)-123456789L
    },
    H_MOD_U
  },                           /* 10 */
  {
    " 123456789", "%d",
    {
      .s = (signed int)123456789L
    },
    NO_MOD_S
  },                           /* 11 */
  {
    "+123456789", "%d",
    {
      .s = (signed int)123456789L
    },
    NO_MOD_S
  },                           /* 12 */
  {
    "-123456789", "%d",
    {
      .s = (signed int)-123456789L
    },
    NO_MOD_S
  },                           /* 13 */
  {
    "+123456789", "%u",
    {
      .u = (unsigned int)123456789L
    },
    NO_MOD_U
  },                           /* 14 */
  {
    "-123456789", "%u",
    {
      .u = (unsigned int)-123456789L
    },
    NO_MOD_U
  },                           /* 15 */
  {
    " 123456789", "%ld",
    {
      .s = (signed long)123456789L
    },
    L_MOD_S
  },                           /* 16 */
  {
    "+123456789", "%ld",
    {
      .s = (signed long)123456789L
    },
    L_MOD_S
  },                           /* 17 */
  {
    "-123456789", "%ld",
    {
      .s = (signed long)-123456789L
    },
    L_MOD_S
  },                           /* 18 */
  {
    "+123456789", "%lu",
    {
      .u = (unsigned long)123456789L
    },
    L_MOD_U
  },                           /* 19 */
  {
    "-123456789", "%lu",
    {
      .u = (unsigned long)-123456789L
    },
    L_MOD_U
  },                           /* 20 */
  {
    " 123456789123456789", "%lld",
    {
      .s = (signed long long)123456789123456789LL
    },
    LL_MOD_S
  },                           /* 21 */
  {
    "+123456789123456789", "%lld",
    {
      .s = (signed long long)123456789123456789LL
    },
    LL_MOD_S
  },                           /* 22 */
  {
    "-123456789123456789", "%lld",
    {
      .s = (signed long long)-123456789123456789LL
    },
    LL_MOD_S
  },                           /* 23 */
  {
    "+123456789123456789", "%llu",
    {
      .u = (unsigned long long)123456789123456789LL
    },
    LL_MOD_U
  },                           /* 24 */
  {
    "-123456789123456789", "%llu",
    {
      .u = (unsigned long long)-123456789123456789LL
    },
    LL_MOD_U
  },                           /* 25 */
};

/****************************************************************************
 * Public Functions
 ****************************************************************************/

/****************************************************************************
 * scanftest_main
 ****************************************************************************/

int main(int argc, FAR char *argv[])
{
  int t;
  int i;
  int c;
  int n1 = 12345;
  int n2;
  bool ok;
  char s1[80];
  char s2[80];
  float f1;
  float f2;
  double d1;
  double d2;
  FAR FILE *fp;

  FAR const char *teststring = "teststring a";
  FAR const char *fname = "/mnt/fs/test.txt";

  /* 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++)
    {
      if (i)
        {
          char s3[3];

          printf("\nBack to Back Test...\n");

          memset(s1, '\0', sizeof s1);
          memset(s2, '\0', sizeof s2);
          memset(s3, '\0', sizeof s3);

          fp = fopen(fname, "wb");
          if (fp)
            {
              fputs(teststring, fp);
              fclose(fp);
              fp = fopen(fname, "rb");
              if (fp != NULL)
                {
                  fscanf(fp, "%s", s2);
                  fscanf(fp, "%2c", s3);
                  sprintf(s1, "%s%s", s2, s3);

                  if (strcmp(s1, teststring) != 0)
                    {
                      printf("Error %s != %s.\n", teststring, s1);
                    }
                  else
                    {
                      printf("Test PASSED.\n");
                    }
                }
              else
                {
                  printf("Error opening %s for read.\n", fname);
                }
            }
          else
            {
              printf("Error opening %s for write.\n", fname);
            }
        }

      printf("\nTesting %cscanf()'s return-value,\nconversions, and "
             "assignments...\n",
             i ? 'f' : 's');

      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);

          ok = true;

          if (i)
            {
              fp = fopen(fname, "wb");
              if (fp)
                {
                  fputs(test_data[t].input, fp);
                  fclose(fp);
                }
              else
                {
                  printf("Error opening %s for write.\n", fname);
                  break;
                }

              fp = fopen(fname, "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("Error opening %s for read.\n", fname);
                  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);
              ok = false;
            }

          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);
                  ok = false;
                }
            }
          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);
                  ok = false;
                }
            }
          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);
                  ok = false;
                }
            }
          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);
                  ok = false;
                }
            }

          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);
                  ok = false;
                }
            }
          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);
                  ok = false;
                }
            }
          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);
                  ok = false;
                }
            }
          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);
                  ok = false;
                }
            }

          if (ok)
            {
              printf("Test #%u PASSED.\n", t + 1);
            }
        }
    }

  /* Test the char, short, and long specification-modifiers. */

  printf("\nTesting 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;

      ok = true;
      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);
              ok = false;
            }
          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);
              ok = false;
            }
          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);
              ok = false;
            }
          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);
              ok = false;
            }
          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);
              ok = false;
            }
          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);
              ok = false;
            }
          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);
              ok = false;
            }
          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);
              ok = false;
            }
          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);
              ok = false;
            }
          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);
              ok = false;
            }
          break;
        }

      if (ok)
        {
          printf("Test #%u PASSED.\n", t + 1);
        }
    }

  return OK;
}