uclibc-ng-test/test/locale-mbwc/tst_types.h

/*
 *  TEST SUITE FOR MB/WC FUNCTIONS IN C LIBRARY
 *
 *	 FILE:	tst_types.h
 *
 *	 Definitions of data types for each test function
 */


#ifndef TST_TYPES_H
#define TST_TYPES_H

#include <stdio.h>
#include <wchar.h>
#include <wctype.h>
#include "tst_funcs.h"
#include "tgn_funcdef.h"

#define MBSSIZE		   24
#define WCSSIZE		   12
#define MONFMTSIZE	   16
#define MONSIZE		   64
#define USE_MBCURMAX	   99	/* well, but ... */
#define TST_DBL_EPS	   2.22153e-16
#define WCSTOK_SEQNUM	   3
#define MBLEN_SEQNUM	   3
#define MBTOWC_SEQNUM	   3
#define MBSTOWCS_SEQNUM	   3
#define WCTOMB_SEQNUM	   3
#define WCSTOMBS_SEQNUM	   3
#define MBRLEN_SEQNUM	   3
#define MBRTOWC_SEQNUM	   3
#define MBSRTOWCS_SEQNUM   3
#define WCRTOMB_SEQNUM	   3
#define WCSRTOMBS_SEQNUM   3

/* Maximum numbers of test in one of the _loc arrays.  */
#define MAX_LOC_TEST		300


/*----------------------------------------------------------------------*/
/*  FUNCTION								*/
/*----------------------------------------------------------------------*/

typedef struct
{
  char *func_str;
  int func_id;
}
TST_FID;

typedef struct
{
  int func_id;
  const char *locale;
}
TST_HEAD;

typedef struct
{
  TST_HEAD *head;
}
TST_FUNCS;


/*----------------------------------------------------------------------*/
/*  ISW*: int isw* (wchar_t wc)						*/
/*----------------------------------------------------------------------*/

TST_ISW_STRUCT (ALNUM, alnum);
TST_ISW_STRUCT (ALPHA, alpha);
TST_ISW_STRUCT (CNTRL, cntrl);
TST_ISW_STRUCT (DIGIT, digit);
TST_ISW_STRUCT (GRAPH, graph);
TST_ISW_STRUCT (LOWER, lower);
TST_ISW_STRUCT (PRINT, print);
TST_ISW_STRUCT (PUNCT, punct);
TST_ISW_STRUCT (SPACE, space);
TST_ISW_STRUCT (UPPER, upper);
TST_ISW_STRUCT (XDIGIT, xdigit);

typedef struct
{
  wint_t wc;
  const char *ts;
}
TIN_ISWCTYPE_REC;

typedef
TEX_ERRET_REC (int)
  TEX_ISWCTYPE_REC;
TMD_RECHEAD (ISWCTYPE);


/*----------------------------------------------------------------------*/
/*  MBLEN: int mblen (const char *s, size_t n)				*/
/*----------------------------------------------------------------------*/

typedef struct
{
  char s_flg;
  char s[MBSSIZE];
  size_t n;
}
TIN_MBLEN_REC;

typedef TEX_ERRET_REC (int) TEX_MBLEN_REC;
TMD_RECHEAD (MBLEN);


/*----------------------------------------------------------------------*/
/*  MBRLEN: size_t mbrlen (const char *s, size_t n, mbstate_t *ps)	*/
/*----------------------------------------------------------------------*/

typedef struct
{
  struct
  {
    int s_flg;
    char s[MBSSIZE];
    size_t n;
    int t_flg;
    int t_init;
  }
  seq[WCSTOK_SEQNUM];
}
TIN_MBRLEN_REC;

typedef TEX_ERRET_REC_SEQ (size_t, MBRLEN_SEQNUM) TEX_MBRLEN_REC;
TMD_RECHEAD (MBRLEN);


/*----------------------------------------------------------------------*/
/*  MBRTOWC: size_t mbrtowc (wchar_t *pwc, const char *s, size_t n,	*/
/*			     mbstate_t *ps)				*/
/*----------------------------------------------------------------------*/

typedef struct
{
  struct
  {
    int w_flg;
    int s_flg;
    char s[MBSSIZE];
    size_t n;
    int t_flg;
    int t_init;
  }
  seq[MBRTOWC_SEQNUM];
}
TIN_MBRTOWC_REC;

typedef struct
{
  struct
  {
    TMD_ERRET (size_t);
    wchar_t wc;
  }
  seq[MBRTOWC_SEQNUM];
}
TEX_MBRTOWC_REC;

TMD_RECHEAD (MBRTOWC);


/*----------------------------------------------------------------------*/
/*  MBSRTOWCS: size_t mbsrtowcs (wchar_t *ws, const char **s, size_t n, */
/*				 mbstate_t *ps )			*/
/*----------------------------------------------------------------------*/

typedef struct
{
  struct
  {
    int w_flg;
    char s[MBSSIZE];
    size_t n;
    int t_flg;
    int t_init;
  }
  seq[MBSRTOWCS_SEQNUM];
}
TIN_MBSRTOWCS_REC;

typedef struct
{
  struct
  {
    TMD_ERRET (size_t);
    wchar_t ws[WCSSIZE];
  }
  seq[MBSRTOWCS_SEQNUM];
}
TEX_MBSRTOWCS_REC;

TMD_RECHEAD (MBSRTOWCS);


/*----------------------------------------------------------------------*/
/*  MBSTOWCS: size_t mbstowcs (wchar_t *ws, const char *s, size_t n)	*/
/*----------------------------------------------------------------------*/

typedef struct
{
  struct
  {
    int w_flg;
    int s_flg;
    const char *s;
    size_t n;
  }
  seq[MBSTOWCS_SEQNUM];
}
TIN_MBSTOWCS_REC;

typedef TEX_MBSRTOWCS_REC TEX_MBSTOWCS_REC;
/* MBSRTOWCS_SEQNUM == MBSTOWCS_SEQNUM */
TMD_RECHEAD (MBSTOWCS);


/*----------------------------------------------------------------------*/
/*  MBTOWC: int mbtowc (wchar_t *wc, const char *s, size_t n)		*/
/*----------------------------------------------------------------------*/

typedef TIN_MBSTOWCS_REC TIN_MBTOWC_REC;
/* MBTOWC_SEQNUM == MBSTOWCS_SEQNUM */

typedef struct
{
  struct
  {
    TMD_ERRET (int);
    wchar_t wc;
  }
  seq[MBTOWC_SEQNUM];
}
TEX_MBTOWC_REC;

TMD_RECHEAD (MBTOWC);


/*----------------------------------------------------------------------*/
/*  STRCOLL: int strcoll (const char *s1, const char *s2)		*/
/*----------------------------------------------------------------------*/

typedef struct
{
  char s1[MBSSIZE];
  char s2[MBSSIZE];
}
TIN_STRCOLL_REC;

typedef TEX_ERRET_REC (int) TEX_STRCOLL_REC;
TMD_RECHEAD (STRCOLL);


/*----------------------------------------------------------------------*/
/*  STRFMON: size_t strfmon (char *buf, size_t nbytes,			*/
/*			     const char *fmt, ... )			*/
/*----------------------------------------------------------------------*/

typedef struct
{
  int nbytes;
  char fmt[MONFMTSIZE];
  double val;
}
TIN_STRFMON_REC;

typedef struct
{
  TMD_ERRET (size_t);
  char mon[MONSIZE];
}
TEX_STRFMON_REC;

TMD_RECHEAD (STRFMON);


/*----------------------------------------------------------------------*/
/*  STRXFRM: size_t strxfrm (char *s1, const char *s2, size_t n)	*/
/*----------------------------------------------------------------------*/

typedef struct
{
  char org1[MBSSIZE];
  char org2[MBSSIZE];
  size_t n1, n2;
}
TIN_STRXFRM_REC;

typedef TEX_ERRET_REC (size_t) TEX_STRXFRM_REC;	/* only for org2[] */
TMD_RECHEAD (STRXFRM);


/*----------------------------------------------------------------------*/
/*  SWSCANF: int swscanf (const wchar_t *ws, const wchar_t *fmt, ...)	*/
/*----------------------------------------------------------------------*/

typedef struct
{
  wchar_t ws[WCSSIZE * 3];
  wchar_t fmt[WCSSIZE * 3];
  int wch;
}
TIN_SWSCANF_REC;

typedef struct
{
  TMD_ERRET (int);
  int val_int;		/* %d */
  unsigned val_uns;	/* %u */
  float val_flt;		/* %f */
  int val_c;		/* %c */
  char val_s[MBSSIZE * 2];	/* %s */
  wchar_t val_S[WCSSIZE * 2];	/* %lc, %ls, %C, %S */
}
TEX_SWSCANF_REC;

TMD_RECHEAD (SWSCANF);


/*----------------------------------------------------------------------*/
/*  TOWCTRANS: wint_t towctrans (wint_t wc, wctrans_t desc)		*/
/*----------------------------------------------------------------------*/

typedef TIN_ISWCTYPE_REC TIN_TOWCTRANS_REC;
typedef TEX_ERRET_REC (wint_t) TEX_TOWCTRANS_REC;
TMD_RECHEAD (TOWCTRANS);


/*----------------------------------------------------------------------*/
/*  TOW*ER: wint_t tow*er (wint_t wc)					*/
/*----------------------------------------------------------------------*/

TST_TOW_STRUCT (LOWER, lower);
TST_TOW_STRUCT (UPPER, upper);


/*----------------------------------------------------------------------*/
/*  WCRTOMB: wchar_t wcrtomb (char *s, wchar_t wc, mbstate_t *ps)	*/
/*----------------------------------------------------------------------*/

typedef struct
{
  int s_flg;
  wchar_t wc;
  int t_flg;
  int t_init;
}
TIN_WCRTOMB_REC;

typedef struct
{
  TMD_ERRET (wchar_t);
  char s[MBSSIZE];
}
TEX_WCRTOMB_REC;

TMD_RECHEAD (WCRTOMB);


/*----------------------------------------------------------------------*/
/*  WCSCAT: wchar_t *wcscat (wchar_t *ws1, wchar_t *ws2)		*/
/*----------------------------------------------------------------------*/

typedef struct
{
  wchar_t ws1[WCSSIZE];
  wchar_t ws2[WCSSIZE];
}
TIN_WCSCAT_REC;

typedef struct
{
  TMD_ERRET (wchar_t *);
  wchar_t ws[WCSSIZE];
}
TEX_WCSCAT_REC;

TMD_RECHEAD (WCSCAT);


/*----------------------------------------------------------------------*/
/*  WCSCHR: wchar_t *wcschr (wchar_t *ws, wchar_t wc);			*/
/*----------------------------------------------------------------------*/

typedef struct
{
  wchar_t ws[WCSSIZE];
  wchar_t wc;
}
TIN_WCSCHR_REC;

typedef TEX_ERRET_REC (wchar_t *) TEX_WCSCHR_REC;
TMD_RECHEAD (WCSCHR);


/*----------------------------------------------------------------------*/
/*  WCSCMP: int wcscmp (const wchar_t *ws1, const wchar_t *ws2)		*/
/*----------------------------------------------------------------------*/

typedef TIN_WCSCAT_REC TIN_WCSCMP_REC;
typedef TEX_ERRET_REC (int) TEX_WCSCMP_REC;
TMD_RECHEAD (WCSCMP);


/*----------------------------------------------------------------------*/
/*  WCSCOLL: int wcscoll (const wchar_t *ws1, const wchar_t *ws2)	*/
/*----------------------------------------------------------------------*/

typedef TIN_WCSCMP_REC TIN_WCSCOLL_REC;
typedef struct
{
  TMD_ERRET (int);
  int cmp_flg;
}
TEX_WCSCOLL_REC;
TMD_RECHEAD (WCSCOLL);


/*----------------------------------------------------------------------*/
/*  WCSCPY: wchar_t *wcscpy (wchar_t *ws1, const wchar_t *ws2)		*/
/*----------------------------------------------------------------------*/

typedef struct
{
  wchar_t ws[WCSSIZE];	/* ws2: original string */
}
TIN_WCSCPY_REC;

typedef TEX_WCSCAT_REC TEX_WCSCPY_REC;
TMD_RECHEAD (WCSCPY);


/*----------------------------------------------------------------------*/
/*  WCSCSPN: size_t wcscspn (const wchar_t *ws1, const wchar_t *ws2)	*/
/*----------------------------------------------------------------------*/

typedef TIN_WCSCAT_REC TIN_WCSCSPN_REC;
typedef TEX_ERRET_REC (size_t) TEX_WCSCSPN_REC;
TMD_RECHEAD (WCSCSPN);


/*----------------------------------------------------------------------*/
/*  WCSLEN: size_t wcslen (const wchar_t *ws)				*/
/*----------------------------------------------------------------------*/

typedef TIN_WCSCPY_REC TIN_WCSLEN_REC;
typedef TEX_ERRET_REC (size_t) TEX_WCSLEN_REC;
TMD_RECHEAD (WCSLEN);


/*----------------------------------------------------------------------*/
/*  WCSNCAT: wchar_t *wcsncat (wchar_t *ws1, const wchar_t *ws2,	*/
/*			       size_t n)				*/
/*----------------------------------------------------------------------*/

typedef struct
{
  wchar_t ws1[WCSSIZE];
  wchar_t ws2[WCSSIZE];
  size_t n;
}
TIN_WCSNCAT_REC;

typedef TEX_WCSCAT_REC TEX_WCSNCAT_REC;
TMD_RECHEAD (WCSNCAT);


/*----------------------------------------------------------------------*/
/*  WCSNCMP: int *wcsncmp (const wchar_t *ws1, const wchar_t *ws2,	*/
/*			   size_t n)					*/
/*----------------------------------------------------------------------*/

typedef TIN_WCSNCAT_REC TIN_WCSNCMP_REC;
typedef TEX_ERRET_REC (int) TEX_WCSNCMP_REC;
TMD_RECHEAD (WCSNCMP);


/*----------------------------------------------------------------------*/
/*  WCSNCPY: wchar_t *wcsncpy (wchar_t *ws1, const wchar_t *ws2,	*/
/*			       size_t n)				*/
/*----------------------------------------------------------------------*/

typedef struct
{
  wchar_t ws[WCSSIZE];	/* ws2: original string */
  size_t n;
}
TIN_WCSNCPY_REC;

typedef TEX_WCSCPY_REC TEX_WCSNCPY_REC;
TMD_RECHEAD (WCSNCPY);


/*----------------------------------------------------------------------*/
/*  WCSPBRK: wchar_t *wcspbrk (const wchar_t *ws1, const wchar_t *ws2)	*/
/*----------------------------------------------------------------------*/

typedef TIN_WCSCSPN_REC TIN_WCSPBRK_REC;

typedef struct
{
  TMD_ERRET (wchar_t *);
  wchar_t wc;
}
TEX_WCSPBRK_REC;

TMD_RECHEAD (WCSPBRK);


/*----------------------------------------------------------------------*/
/*  WCSRTOMBS: size_t wcsrtombs (char *s, const wchar_t **ws, size_t n, */
/*				 mbstate_t *ps)				*/
/*----------------------------------------------------------------------*/

typedef struct
{
  int s_flg;
  int w_flg;		/* don't need this */
  wchar_t ws[WCSSIZE];
  size_t n;
  int t_flg;
  int t_init;
}
TIN_WCSRTOMBS_REC;

typedef struct
{
  TMD_ERRET (size_t);
  char s[MBSSIZE];
}
TEX_WCSRTOMBS_REC;

TMD_RECHEAD (WCSRTOMBS);


/*----------------------------------------------------------------------*/
/*  WCSSPN: size_t wcsspn (const wchar_t *ws1, const wchar_t *ws2)	*/
/*----------------------------------------------------------------------*/

typedef TIN_WCSCSPN_REC TIN_WCSSPN_REC;
typedef TEX_WCSCSPN_REC TEX_WCSSPN_REC;
TMD_RECHEAD (WCSSPN);


/*----------------------------------------------------------------------*/
/*  WCSSTR: wchar_t *wcsstr (const wchar_t *ws1, const wchar_t *ws2)	*/
/*----------------------------------------------------------------------*/

typedef TIN_WCSCSPN_REC TIN_WCSSTR_REC;
typedef TEX_ERRET_REC (wchar_t *) TEX_WCSSTR_REC;
TMD_RECHEAD (WCSSTR);


/*----------------------------------------------------------------------*/
/*  WCSTOD: double wcstod (const wchar_t *np, wchar_t **endp)		*/
/*----------------------------------------------------------------------*/

typedef struct
{
  wchar_t np[WCSSIZE];
}
TIN_WCSTOD_REC;

typedef struct
{
  TMD_ERRET (double);
  double val;
  wchar_t fwc;
}
TEX_WCSTOD_REC;

TMD_RECHEAD (WCSTOD);


/*----------------------------------------------------------------------*/
/*  WCSTOK: wchar_t *wcstok (wchar_t *ws, const wchar_t *dlm,		*/
/*			     wchar_t **pt)				*/
/*----------------------------------------------------------------------*/

typedef struct
{
  struct
  {
    int w_flg;
    wchar_t ws[WCSSIZE];
    wchar_t dt[WCSSIZE];	/* delimiter */
  }
  seq[WCSTOK_SEQNUM];
}
TIN_WCSTOK_REC;

typedef struct
{
  struct
  {
    TMD_ERRET (wchar_t *);
    wchar_t ws[WCSSIZE];
  }
  seq[WCSTOK_SEQNUM];
}
TEX_WCSTOK_REC;

TMD_RECHEAD (WCSTOK);


/*----------------------------------------------------------------------*/
/*  WCSTOMBS: size_t wcstombs (char s, const wchar_t *ws, size_t n)	*/
/*----------------------------------------------------------------------*/

typedef struct
{
  int s_flg;
  int w_flg;		/* currently we don't need it. */
  wchar_t ws[WCSSIZE];
  size_t n;
}
TIN_WCSTOMBS_REC;

typedef struct
{
  TMD_ERRET (size_t);
  char s[MBSSIZE];
}
TEX_WCSTOMBS_REC;

TMD_RECHEAD (WCSTOMBS);


/*----------------------------------------------------------------------*/
/*  WCSWIDTH: int wcswidth (const wchar_t *ws, size_t n)		*/
/*----------------------------------------------------------------------*/

typedef TIN_WCSNCPY_REC TIN_WCSWIDTH_REC;
typedef TEX_ERRET_REC (int) TEX_WCSWIDTH_REC;
TMD_RECHEAD (WCSWIDTH);


/*----------------------------------------------------------------------*/
/*  WCSXFRM: size_t wcsxfrm (wchar_t *ws1, const wchar_t *ws2, size_t n)*/
/*----------------------------------------------------------------------*/

typedef struct
{
  wchar_t org1[WCSSIZE];
  wchar_t org2[WCSSIZE];
  int n1, n2;
}
TIN_WCSXFRM_REC;

typedef TEX_ERRET_REC (size_t) TEX_WCSXFRM_REC;	/* only for org2[] */
TMD_RECHEAD (WCSXFRM);


/*----------------------------------------------------------------------*/
/*  WCTOB: int wctob (wint_t wc)					*/
/*----------------------------------------------------------------------*/

typedef struct
{
  wint_t wc;
}
TIN_WCTOB_REC;

typedef TEX_ERRET_REC (int) TEX_WCTOB_REC;
TMD_RECHEAD (WCTOB);


/*----------------------------------------------------------------------*/
/*  WCTOMB: int wctomb (char *s, wchar_t wc)				*/
/*----------------------------------------------------------------------*/

typedef struct
{
  int s_flg;
  wchar_t wc;
}
TIN_WCTOMB_REC;

typedef struct
{
  TMD_ERRET (int);
  char s[MBSSIZE];
}
TEX_WCTOMB_REC;

TMD_RECHEAD (WCTOMB);


/*----------------------------------------------------------------------*/
/*  WCTRANS: wctrans_t wctrans (const char *charclass)			*/
/*----------------------------------------------------------------------*/

typedef struct
{
  char class[MBSSIZE];
}
TIN_WCTRANS_REC;

typedef TEX_ERRET_REC (wctrans_t) TEX_WCTRANS_REC;
TMD_RECHEAD (WCTRANS);


/*----------------------------------------------------------------------*/
/*  WCTYPE: wctype_t wctype (const char *class)				*/
/*----------------------------------------------------------------------*/

typedef TIN_WCTRANS_REC TIN_WCTYPE_REC;
typedef TEX_ERRET_REC (wctype_t) TEX_WCTYPE_REC;
TMD_RECHEAD (WCTYPE);


/*----------------------------------------------------------------------*/
/*  WCWIDTH: int wcwidth (wchar_t wc)					*/
/*----------------------------------------------------------------------*/

typedef struct
{
  wchar_t wc;
}
TIN_WCWIDTH_REC;

typedef TEX_ERRET_REC (int) TEX_WCWIDTH_REC;
TMD_RECHEAD (WCWIDTH);

#endif /* TST_TYPES_H */