Test assertions for OpenI18N1.2 level1 - Base -

No. Testset Name # Assertions Assertion
C Language internationalization functions (Ref. [POSIX.1] and [ISO C])
1 setlocale 4 #include <locale.h>
char *setlocale (int category, const char *locale);
  1. If locale is "", verify each category of the locale is set according to the internationalization environment variables.
  2. If the string starting at locale is a string which is used to define the locale, verify each category of the locale is set according to the string starting at locale and returns the string associated with the category for the new locale.
  3. If the string starting at locale is not a string which is used to define the locale, verify this function does not change any category of the locale and returns NULL.
  4. If locale is NULL, verify this function returns the string associated with the category for the locale.
2 localeconv 18 #include <locale.h>
struct lconv *localeconv (void);
  1. Verify this function sets the struct lconv member *decimal_point according to the current locale.
  2. Verify this function sets the struct lconv member *thousands_sep according to the current locale.
  3. Verify this function sets the struct lconv member *grouping according to the current locale.
  4. Verify this function sets the struct lconv member *int_curr_symbol according to the current locale.
  5. Verify this function sets the struct lconv member *currency_symbol according to the current locale.
  6. Verify this function sets the struct lconv member *mon_decimal_point according to the current locale.
  7. Verify this function sets the struct lconv member *mon_thousands_sep according to the current locale.
  8. Verify this function sets the struct lconv member *mon_grouping according to the current locale.
  9. Verify this function sets the struct lconv member *positive_sign according to the current locale.
  10. Verify this function sets the struct lconv member *negative_sign according to the current locale.
  11. Verify this function sets the struct lconv member int_frac_digits according to the current locale.
  12. Verify this function sets the struct lconv member frac_digits according to the current locale.
  13. Verify this function sets the struct lconv member p_cs_precedes according to the current locale.
  14. Verify this function sets the struct lconv member p_sep_by_space according to the current locale.
  15. Verify this function sets the struct lconv member n_cs_precedes according to the current locale.
  16. Verify this function sets the struct lconv member n_sep_by_space according to the current locale.
  17. Verify this function sets the struct lconv member p_sign_posn according to the current locale.
  18. Verify this function sets the struct lconv member n_sign_posn according to the current locale.
3 strftime 24 #include <time.h>
size_t strftime (char *s, size_t maxsize, const char *format, const struct tm *timeptr);
  1. Verify this function replaces conversion specifier `a' with the abbreviated weekday name according to the current locale.
  2. Verify this function replaces conversion specifier `A' with the full weekday name according to the current locale.
  3. Verify this function replaces conversion specifier `b' with the abbreviated month name according to the current locale.
  4. Verify this function replaces conversion specifier `B' with the full month name according to the current locale.
  5. Verify this function replaces conversion specifier `c' with the preferred date and time representation for the current locale.
  6. Verify this function replaces conversion specifier `d' with the day of the month as a decimal number (range 01 to 31).
  7. Verify this function replaces conversion specifier `H' with the hour as a decimal number using a 24-hour clock (range 00 to 23).
  8. Verify this function replaces conversion specifier `I' with the hour as a decimal number using a 12-hour clock (range 01 to 12).
  9. Verify this function replaces conversion specifier `j' with the day of the year as a decimal number (range 001 to 366).
  10. Verify this function replaces conversion specifier `m' with the month as a decimal number (range 01 to 12).
  11. Verify this function replaces conversion specifier `M' with the minute as a decimal number (range 00 to 59).
  12. Verify this function replaces conversion specifier `p' with locale's equivalent of either a.m. or p.m.
  13. Verify this function replaces conversion specifier `S' with the second as a decimal number (range 00 to 61).
  14. Verify this function replaces conversion specifier `U' with the week number of the current year as a decimal number, range 00 to 53, starting with the first Sunday as the first day of week 01.
  15. Verify this function replaces conversion specifier `w' with the day of the week as a decimal, range 0 to 6, Sunday being 0.
  16. Verify this function replaces conversion specifier `W' with the week number of the current year as a decimal number, range 00 to 53, starting with the first Monday as the first day of week 01.
  17. Verify this function replaces conversion specifier `x' with the preferred date representation for the current locale without the time.
  18. Verify this function replaces conversion specifier `X' with the preferred time representation for the current locale without the date.
  19. Verify this function replaces conversion specifier `y' with the year as a decimal number in double figures (range 00 to 99).
  20. Verify this function replaces conversion specifier `Y' with the year as a decimal number in full figures.
  21. Verify this function replaces conversion specifier `Z' with the time zone or name or abbreviation.
  22. Verify this function replaces conversion specifier `%' with a literal % character.
  23. If the length of the string which is made with interpretation according to the format is less than or equal to maxsize, this function returns the length of the string except terminating null character and stores the string (including null terminating character) into the array pointed by s.
  24. If the length of the string which is made with interpretation according to the format is greater than maxsize, this function returns 0.
4 wcsftime 24 #include <wchar.h>
wcsftime (wchar_t *s, size_t maxsize, const wchar_t format, const struct tm *timeptr);
  1. Verify this function replaces conversion specifier `a' with the abbreviated weekday name according to the current locale.
  2. Verify this function replaces conversion specifier `A' with the full weekday name according to the current locale.
  3. Verify this function replaces conversion specifier `b' with the abbreviated month name according to the current locale.
  4. Verify this function replaces conversion specifier `B' with the full month name according to the current locale.
  5. Verify this function replaces conversion specifier `c' with the preferred date and time representation for the current locale.
  6. Verify this function replaces conversion specifier `d' with the day of the month as a decimal number (range 01 to 31).
  7. Verify this function replaces conversion specifier `H' with the hour as a decimal number using a 24-hour clock (range 00 to 23).
  8. Verify this function replaces conversion specifier `I' with the hour as a decimal number using a 12-hour clock (range 01 to 12).
  9. Verify this function replaces conversion specifier `j' with the day of the year as a decimal number (range 001 to 366).
  10. Verify this function replaces conversion specifier`m' with the month as a decimal number (range 01 to 12).
  11. Verify this function replaces conversion specifier `M' with the minute as a decimal number (range 00 to 59).
  12. Verify this function replaces conversion specifier `p' with either AM or PM according to the given time value, or the corresponding strings for the current locale.
  13. Verify this function replaces conversion specifier `S' with the second as a decimal number (range 00 to 61).
  14. Verify this function replaces conversion specifier `U' with the week number of the current year as a decimal number, range 00 to 53, starting with the first Sunday as the first day of week 01.
  15. Verify this function replaces conversion specifier `w' with the day of the week as a decimal, range 0 to 6, Sunday being 0.
  16. Verify this function replaces conversion specifier `W' with the week number of the current year as a decimal number, range 00 to 53, starting with the first Monday as the first day of week 01.
  17. Verify this function replaces conversion specifier `x' with the preferred date representation for the current locale without the time.
  18. Verify this function replaces conversion specifier `X' with the preferred time representation for the current locale without the date.
  19. Verify this function replaces conversion specifier `y' with the year as a decimal number in double figures (range 00 to 99).
  20. Verify this function replaces conversion specifier `Y' with the year as a decimal number in full figures.
  21. Verify this function replaces conversion specifier `Z' with the time zone or name or abbreviation.
  22. Verify this function replaces conversion specifier `%' with a literal % character.
  23. If the length of the wide character string which is made with interpretation according to the format is less than or equal to maxsize, verify this function returns the length of the wide character string except terminating null wide character and stores the wide character string (including null terminating character) into the array pointed by s.
  24. If the length of the wide character string which is made with interpretation according to the format is greater than maxsize, verify this function returns 0.
5 btowc 3 #include <stdio.h>
#include <wchar.h>
wint_t btowc (int c);
  1. When c is EOF, verify this function returns WEOF.
  2. When c is a valid single byte character, verify this function returns the wide character which shows as same character as the single byte character.
  3. When c is not a valid single byte character, verify this function returns WEOF.
6 wctob 2 #include <stdio.h>
#include <wchar.h>
int wctob (wint_t wc);
  1. When wc shows a character which is represented by single byte in multibyte character expression, verify this function returns a valid single byte character.
  2. When wc shows a character which is not represented by single byte in multibyte character expression, verify this function returns EOF.
7 mblen 4 #include <stdlib.h>
int mblen (const char *s, size_t n);
  1. When s is not NULL and the byte sequence starting at s shows null character, verify this function returns 0.
  2. When s is not NULL and the byte sequence starting at s contains a complete multibyte character, verify this function returns the length of bytes which are used to represent the character.
  3. When s is not NULL and the byte sequence starting at s does not contain a complete multibyte character, verify this function returns -1.
  4. When s is NULL, verify this function returns 0.
    (Strictly speaking, when s is NULL, this function should return 0 if the encode is stateless, or should return 1 if the encode has non-trivial shift state. But this time we do not test the locale whose encode is non-trivial shift state.)
8 mbtowc 4 #include <stdlib.h>
int mbtowc (wchar_t *pwc, const char *s, size_t n);
  1. When s is not NULL, and the byte sequence starting at s shows null character, verify this function returns 0 and stores null wide character at pwc.
  2. When s is not NULL and the byte sequence starting at s contains a complete multibyte character, verify this function returns the length of bytes which are used to represent the character, and stores wide character which shows as same character as the multibyte character at pwc.
  3. When s is not NULL and the byte sequence starting at s does not contain a complete multibyte character, verify this function returns -1.
  4. When s is NULL, verify this function returns 0.
    (Strictly speaking, when s is NULL, this function should return 0 if the encode is stateless, or should return 1 if the encode has non-trivial shift state. But this time we do not test the locale whose encode is non-trivial shift state.)
9 wctomb 3 #include <stdlib.h>
int wctomb (char *s, wchar_t wc);
  1. When wc shows a wide character which can be represented multibyte character expression, verify this function returns the length of bytes which are used to represent the character and stores the byte sequence at the pointer s.
  2. When wc shows a wide character which is not represented in multibyte character expression, verify this function returns -1.
  3. When s is NULL, verify this function returns 0.
    (Strictly speaking, when s is NULL, wctomb() should return 0 if the encode is stateless, or should return 1 if the encode has non-trivial shift state. But this time we do not test the locale whose encode is non-trivial shift state.)
(Besides the above, when wc is 0, it resets the shift state, only known to this function, to the initial state. But this time we do not test the locale whose encode is non-trivial shift state.)
10 mbstowcs 3 #include <stdlib.h>
size_t mbstowcs (wchar_t *pwcs, const char *s size_t n);
  1. If the byte sequence starting at s has no invalid byte which are used to represent the character in first n multibyte characters, and null character is not in that range, verify this function returns the length of the wide character sequence which shows as same characters as the first n multibyte characters at pwcs and stores the wide characters at pwcs.
  2. If the byte sequence starting at s has null character which number of position is less than n, and there is no invalid byte which are used to represent the character in the byte sequence as far as null character, verify this function stores wide character sequence which shows as same character as the multibyte characters from the first to null character at pwcs, and returns the number of which mbstowcs converted (except null character).
  3. If the byte sequence starting at s has invalid byte which are used to represent the character in the translation range, verify this function returns -1.
11 wcstombs 3 #include <stdlib.h>
size_t wcstombs (char *s const wchar_t *pwcs, size_t n);
  1. If the wide character sequence starting at pwcs has no wide character which cannot be translated to multibyte character where the length of translated multibyte character is less than or equal to n, and null wide character is not in that range, verify this function returns the length of the byte sequence which shows as same characters as the wide characters and stores the byte sequence at the s.
  2. If the wide character sequence starting at pwcs has no wide character which cannot be translated to multibyte character where the length of translated multibyte character is less than or equal to n, and null wide character is in that range, verify this function translates wide characters to multibyte characters from the first to the null wide character and returns the length of the byte sequence which shows as same characters as the wide characters and stores the byte sequence at s.
  3. If the wide character sequence starting at pwcs has a wide character which cannot be translated to multibyte character in the translation range, verify this function returns -1.
12 mbsinit 1 #include <wchar.h>
int mbsinit (const mbstate_t *ps);
  1. Verify this function returns non-zero. (Because we only provide a test for the locale which use stateless encoding.)
13 mbrlen 5 #include <wchar.h>
size_t mbrlen (const char *s, size_t n, mbstate_t *ps);
  1. When s is not NULL and the byte sequence starting at s shows null character, verify this function returns 0.
  2. When s is not NULL and the byte sequence starting at s contains a complete multibyte character, verify this function returns the length of bytes which the multibyte character has.
  3. When s is not NULL and the byte sequence starting at s contains an invalid byte which are used to represent the character, verify this function returns -1 and set errno EILSEQ.
  4. When s is not NULL and the byte sequence starting at s does not contain a complete multibyte character, verify this function returns -2.
  5. When s is NULL, verify the behavior of this function is equivalent to the behavior as mbrlen("", 1, ps).
(We assumed the conversion state always shows the initial state. Because we only provide a test for the locale which use stateless encoding.)
14 mbrtowc 5 #include <wchar.h>
size_t mbrtowc (wchar_t *pwc, const char *s, size_t n, mbstate_t *ps);
  1. When s is not NULL, and the byte sequence starting at s shows null character, verify this function returns 0 and stores null wide character at pwc.
  2. When s is not NULL and the byte sequence starting at s contains a complete multibyte character, verify this function returns the length of bytes which are used to represent the multibyte character, and stores wide character which shows as same character as the multibyte character at pwc.
  3. When s is not NULL and the multibyte sequence starting at s contain a invalid byte which are used to represent the character, verify this function returns -1 and set errno EILSEQ.
  4. When s is not NULL and the multibyte sequence starting at s does not contain a complete multibyte character, verify this function returns -2.
  5. When s is NULL, verify the behavior of this function is equivalent to the behavior as mbrtowc(NULL, "", 1, ps).
(We assumed the conversion state always shows the initial state. Because we only provide a test for the locale which use stateless encoding.)
15 wcrtomb 3 #include <wchar.h>
size_t wcrtomb (char *s, wchar_t wc, mbstate_t *ps);
  1. When wc shows a character which is able to be represented in multibyte character expression, verify this function returns the length of bytes which are used to represent the character, and stores the byte sequence which shows the character at s.
  2. When wc shows a character which is not able to be represented in multibyte character expression, verify this function returns -1 and set errno EILSEQ.
  3. When s is NULL, verify the behavior of this function is equivalent to the behavior as wcrtomb(s, L'\0', ps).
(We assumed the conversion state always shows the initial state. Because we only provide a test for the locale which use stateless encoding.)
16 mbsrtowcs 3 #include <wchar.h>
size_t mbsrtowcs (wchar_t *dst, const char **src, size_t n, mbstate_t *ps);
  1. If src has no invalid byte used to represent the character in the first n multibyte characters, and null character is not in that range, verify this function returns n, and stores wide character sequence which show as same characters as the first n multibyte characters at dst, and stores the address which points the address which is the next address storing the last converted byte at src.
  2. If src has null character whose position is less than n, and there is no invalid byte to represent the character as far as null character, verify this function stores wide character sequence which shows as same characters as the multibyte characters from first to null character at dst, and returns the length of the wide character converted by this function (except NULL wide character), and stores NULL at src.
  3. If src has invalid byte in the conversion range, verify this function stores wide character sequence which show as same characters as the multibyte characters from first to the last converted character at dst, and returns -1 and put the address which shows the byte which cannot converted at src, and set errno EILSEQ.
(We assumed the conversion state always shows the initial state. Because we only provide a test for the locale which use stateless encoding.)
17 wcsrtombs 3 #include <wchar.h>
size_t wcsrtombs (char *dst, const wchar_t **src, size_t n, mbstate_t *ps);
  1. If src has no wide character which cannot be translated to multibyte character when the length of translated multibyte character is less than or equal to n, and null wide character is not in that range, verify this function returns the byte length of translated multibyte character sequence, and stores byte sequence which shows as same characters as the wide characters at dst, and stores the address which points the next wide character of the last converted wide character at src.
  2. If src has no wide character which cannot be translated to multibyte character, and there is a null wide character in the wide characters, verify this function translates wide character to multibyte character from first to the null wide character and returns the byte length of the translated multibyte characters, and stores byte sequence which shows as same characters as the wide characters at dst, and stores the NULL at src.
  3. If src has a wide character which cannot be translated to multibyte character in the translation range, verify this function returns -1, and stores byte sequence which show as same characters as the wide characters from first to the last convertible character at dst and stores the address which point the next wide character of the last converted character at src, and set errno EILSEQ.
(We assumed the conversion state always shows the initial state. Because we only provide a test for the locale which use stateless encoding.)
18 wcscat 2 #include <wchar.h>
wchar_t *wcscat (wchar_t *s1, const wchar_t *s2);
  1. Verify this function returns s1.
  2. Verify this function concatenates two wide character strings correctly.
19 wcsncat 3 #include <wchar.h>
wchar_t *wcsncat (wchar_t *s1, const wchar_t *s2, size_t n);
  1. Verify this function returns s1.
  2. Verify this function concatenates part of two wide character strings correctly.
  3. If there is a terminating null wide character is in a position less than the nth at string the starting at s1, verify this function does not appended the wide characters which follows the null wide character.
20 wcscpy 3 #include <wchar.h>
wchar_t wcscpy (wchar_t *s1, const wchar_t *s2);
  1. Verify this function returns s1.
  2. Verify the string starting at s1 which is duplicate of the string starting at s1 have null wide character at the end of string.
  3. After calling this function, verify the string starting at s1 is same as the string starting at s2.
21 wcsncpy 4 #include <wchar.h>
wchar_t wcsncpy (wchar_t *s1, const wchar_t *s2, size_t n);
  1. Verify this function returns the pointer s1.
  2. If the length of the string starting at s2 is longer or as same as n but it has null wide character which is in a position less than the nth, verify this function does not copy the wide characters which follows the null wide character. (includes null wide character.)
  3. If the length of the string starting at s2 is shorter than n, verify this function appends the null wide character to the copy in the array pointed to by s1, until n wide character in all are written.
  4. If the length of the string starting at s2 is longer than n, verify this function copies only n wide characters in the array pointed to by s1 and does not append null wide character at the end of the array.
22 wcscmp 3 #include <wchar.h>
wchar_t wcscmp (const wchar_t *s1, const wchar_t *s2);
  1. If a wide character string starting at s1 is less than a wide character string starting at s2, verify this function returns negative value.
  2. If a wide character string starting at s1 and a wide character string starting at s2 are equal, this function returns 0.
  3. If a wide character string starting at s1 is greater than a wide character string starting at s2, this function returns positive value.
23 wcsncmp 4 #include <wchar.h>
wchar_t wcsncmp (const wchar_t *s1, const wchar_t *s2, size_t n);
  1. If n wide characters starting at s1 is less than n wide characters starting at s2, verify this function returns negative value.
  2. If n wide characters starting at s1 and n wide characters starting at s2 are equal, verify this function returns 0.
  3. If n wide characters starting at s1 is greater than n wide characters starting at s2, verify this function returns positive value.
  4. When this function compares characters, verify this function ignores the characters which are behind the null wide character.
24 wcscoll 3 #include <wchar.h>
wchar_t wcscoll (const wchar_t *s1, const wchar_t *s2);
  1. If a wide character string starting at s1 is less than a wide character string starting at s2, verify this function returns negative value. The comparison is executed according to the collating sequence of the current locale.
  2. If a wide character string starting at s1 and a wide character string starting at s2 are equal, verify this function returns 0. The comparison is executed according to the collating sequence of the current locale.
  3. If a wide character string starting at s1 is greater than a wide character string starting at s2, verify this function returns positive value. The comparison is executed according to the collating sequence of the current locale.
25 wcsxfrm 2 #include <wchar.h>
wchar_t wcsxfrm (char_t *s1, const wchar_t *s2, size_t n);
  1. Verify this function returns the length of the converted strings (Terminated null wide character is not counted).
  2. When two strings which converted from this function are compared with wcscmp(), verify the result of comparison consist with the result to compare two strings before conversion by wcscoll().
26 wcschr 2 #include <wchar.h>
wchar_t *wcschr (const wchar_t *s, wchar_t c);
  1. If the wide character string starting ats has the character whose code point is c, verify this function returns a pointer to the first occurrence of that character.
  2. If the wide character string starting at s does not have the character which code point is c, verify this function returns NULL.
27 wcsrchr 2 #include <wchar.h>
wchar_t *wcsrchr (const wchar_t *s, wchar_t c);
  1. If the wide character string starting at s has the character whose code point is c, verify this function returns a pointer to the last occurrence of that character.
  2. If the wide character string starting at s does not have the character which code point is c, verify this function returns NULL.
28 wcspbrk 2 #include <wchar.h>
wchar_t *wcspbrk (const wchar_t *s1, const wchar_t *s2);
  1. If the wide character string starting at s1 has a character which is included the wide character string starting at s2, verify this function returns a point to the first occurrence of that character.
  2. If the wide character string starting at s1 does not have the character which is included the wide character string starting at s2, verify this function returns NULL
29 wcsstr 2 #include <wchar.h>
wchar_t *wcsstr (const wchar_t *s1, const wchar_t *s2);
  1. If the wide character string starting at s1 has the string starting at s2 (except the last null wide character), verify this function returns a point to the first occurrence of that string.
  2. If the wide character string starting at s1 does not have the string starting at s2 (except the last null wide character), verify this function returns NULL.
30 wcstok 4 #include <wchar.h>
wchar_t *wcstok (const wchar_t *s1, const wchar_t *s2, wchar_t **ptr);
  1. When s1 is not NULL and the wide character string starting at s1 has the character which is not included in the string starting at s1, verify this function picks the token up correctly.
  2. When s1 is NULL, the pointer pointed by ptr has information of next token and the wide character string starting at s1 has the character which is not included in the string starting at s1, verify this function returns picks the token up correctly.
  3. If s1 is not NULL and the wide character string starting at s1 does not have the character which is not included in the string starting at s1, verify this function returns NULL.
  4. When s1 is NULL, the pointer pointed by ptr has information of next token and the wide character string starting at s1 does not have the character which is not included in the string starting at s1, verify this function returns NULL.
31 wcsspn 1 #include <wchar.h>
wchar_t *wcsspn (const wchar_t *s1, const wchar_t *s2);
  1. If the wide character string starting at s1 has characters which is included in s2 at the beginning of s1, verify this function returns the length of the characters which is a sequence of the character which is included in s2.
32 wcscspn 1 #include <wchar.h>
wchar_t *wcscspn (const wchar_t *s1, const wchar_t *s2);
  1. If the wide character string starting at s1 has characters which is not included in s2 at the beginning of s1, verify this function returns the length of the characters which is a sequence of the character which is not included in s2.
33 wcslen 1 #include <wchar.h>
size_t wcslen (const wchar_t *s);
  1. Verify this function returns the length of the string starting at s.
34 wmemchr 2 #include <wchar.h>
wchar_t *wmemchr (const wchar_t *s, wchar_t c, size_t n);
  1. If one of the wide characters, which are in the wide character sequence starting at s and its length is n, is the character which code point is c, verify this function returns a pointer to the last occurrence of that character.
  2. If each wide character, which is in the wide character sequence starting at s and its length is n, is not the character which code point is c, verify this function returns NULL.
35 wmemcmp 3 #include <wchar.h>
wchar_t *wmemcmp (const wchar_t *s, const wchar_t c, size_t n);
  1. If n wide characters starting at s1 is less than n wide characters starting at s2, verify this function returns negative value.
  2. If n wide characters starting at s1 and n wide characters starting at s2 are equal, verify this function returns 0.
  3. If n wide characters starting at s1 is greater than n wide characters starting at s2, verify this function returns positive value.
36 wmemcpy 2 #include <wchar.h>
wchar_t *wmemcpy (wchar_t *s1, const wchar_t *s2, size_t n);
  1. Verify this function returns the pointer s1.
  2. After executing this function, verify n characters starting at s1 consists with n characters starting at s1.
37 wmemmove 3 #include <wchar.h>
wchar_t *wmemmove (wchar_t *s1, const wchar_t *s2, size_t n);
  1. Verify this function returns the pointer s1.
  2. After executing this function, verify n characters starting at s1 consists with n characters starting at s1.
  3. Verify this function is able to copy correctly if the pointer of s1 is between s2 and (s2 + n).
38 wmemset 2 #include <wchar.h>
wchar_t *wmemset (wchar_t *s, wchar_t c, size_t n);
  1. Verify this function returns the pointer s.
  2. Verify this function correctly fills the array of n wide characters starting at wcs with n copies of the wide character wc.
39 wcstod 8 #include <wchar.h>
double wcstod (const wchar_t *nptr, wchar_t **endptr);
  1. Check this function skips whitespace characters which is at beginning of the starting at nptr. The whitespace character is the one whose results applied with iswspace() is true.
  2. If the string starting at nptr has two or more wide characters which shows decimal point, verify the characters behind the 2nd wide character (include the 2nd one) which shows decimal point is not target of translation.
  3. If the numerical wide character string have a floating suffix, verify this function does not interpreted as numerical symbol.
  4. If the wide character string has a possibility to convert, check this function returns the converted value and endptr points the wide character which is next to the last numerical wide character.
  5. If the wide character string has no possibility to convert, check this function returns 0 and endptr points the pointer which points the start of given string.
  6. If the numerical wide character string is bigger than the maximum value which handle by double type, this function returns the maximum value and set errno ERANGE.
  7. If the numerical wide character string is smaller than the minimum value which handle by double type, this function returns the minimum value and set errno ERANGE.
  8. If underflow is occurred with converting, verify this function returns 0 and set errno ERANGE.
40 wcstol 11 #include <wchar.h>
long int wcstol (const wchar_t *nptr, wchar_t **endptr, int base);
  1. Check this function skips whitespace characters which is at beginning of the string starting at nptr. The whitespace character is the one whose results applied with iswspace() is true.
  2. If the numerical wide character string have a integer suffix, verify this function does not interpreted as numerical symbol.
  3. If base is bigger than 9, verify some alphabets are interpreted as numeric character.
    (e.g. If base is 16, 'a', 'b', 'c', 'd', 'e', 'f' are shows respectively '10', '11', '12', '13', '14', '15'.)
  4. If base is 16, verify the numerical string may have '0x' or '0X'.
  5. If base is 0 and numerical string starts with '0', verify the string is taken as octal number.
  6. If base is 0 and numerical string starts without '0', verify the string is taken as decimal number.
  7. If base is 0 and numerical string starts with '0x' or '0X', verify the string is taken as hexaoctal number.
  8. If the wide character string has a possibility to convert, this function returns the converted value and endptr points the wide character which is next to the last numerical wide character.
  9. If the wide character string has no possibility to convert, check this function returns 0 and endptr points the pointer which points the start of given string.
  10. If the numerical wide character string is bigger than LONG_MAX, verify this function returns LONG_MAX and set errno ERANGE.
  11. If the numerical wide character string is smaller than the LONG_MIN, verify this function returns LONG_MIN and set errno ERANGE.
41 wcstoul 10 #include <wchar.h>
unsigned long int wcstol (const wchar_t *nptr, wchar_t **endptr, int base);
  1. Check this function skips whitespace characters which is at beginning of the string starting at nptr. The whitespace character is the one whose results applied with iswspace() is true.
  2. If the numeral wide character string have a integer suffix, verify this function does not interpreted as numerical symbol.
  3. If base is bigger than 9, verify some alphabets are interpreted as numerical character.
    (e.g. If base 16, 'a', 'b', 'c', 'd', 'e', 'f' are shows respectively '10', '11', '12', '13', '14', '15'.)
  4. If base is 16, verify the numerical string may have '0x' or '0X'.
  5. If base is 0 and numerical string starts with '0', verify the string is taken as octal number.
  6. If base is 0 and numerical string starts without '0', verify the string is taken as decimal number.
  7. If base is 0 and numerical string starts with '0x' or '0X', verify the string is taken as hexaoctal number.
  8. If the wide character string has a possibility to convert, check this function returns the converted value and endptr points the wide character which is next to the last numerical wide character.
  9. If the wide character string has no possibility to convert, check this function returns 0 and endptr points the pointer which points the start of given string.
  10. If the numerical wide character string is bigger than ULONG_MAX, verify this function returns ULONG_MAX and set errno ERANGE.
42 iswalnum 2 #include <wctype.h>
int iswalnum (wint_t wc);
  1. If iswalpha(wc) or iswdigit(wc) returns true, verify iswalnum(wc) returns true.
  2. If isalnum(wctob(wc)) returns true, verify iswalnum(wc) returns true.
43 iswalpha 2 #include <wctype.h>
int iswalpha (wint_t wc);
  1. If iswupper(wc) or iswlower(wc) returns true, verify iswalpha(wc) returns true.
    (But it is not strange that (iswupper(wc) || iswlower(wc)) returns false, when iswalpha(wc) returns true.)
  2. If isalpha(wctob(wc)) returns true, verify iswalpha(wc) returns true.
44 iswcntrl 2 #include <wctype.h>
int iswcntrl (wint_t wc);
  1. If wc shows control wide character, verify iswcntrl(wc) returns true.
  2. If iscntrl(wctob(wc)) returns true, verify iswcntrl(wc) returns true.
45 iswdigit 2 #include <wctype.h>
int iswdigit (wint_t wc);
  1. If wc shows decimal digit wide character, verify iswdigit(wc) returns true.
  2. If isdigit(wctob(wc)) returns true, verify iswdigit(wc) returns true.
46 iswgraph 3 #include <wctype.h>
int iswgraph (wint_t wc);
  1. If iswprint(wc) returns true and iswspace(wc) returns false, verify iswgraph(wc) returns true.
  2. If iswspace(wc) returns false and isgraph(wctob(wc)) returns true, verify iswgraph(wc) returns true.
  3. If iswspace(wc) returns true (except L' ') and isgraph(wctob(wc)) returns true, verify either iswgraph(wc) or (iswprint(wc) && iswspace(wc)) returns true.
47 iswlower 2 #include <wctype.h>
int iswlower (wint_t wc);
  1. If wc shows lowercase wide character, verify iswlower(wc) returns true.
  2. If islower(wctob(wc)) returns true, verify iswlower(wc) returns true.
48 iswprint 2 #include <wctype.h>
int iswprint (wint_t wc);
  1. If wc shows printing wide character, verify iswprint(wc) returns true.
  2. If isprint(wctob(wc)) returns true, verify iswprint(wc) returns true.
49 iswpunct 3 #include <wctype.h>
int iswpunct (wint_t wc);
  1. If iswprint(wc) returns true and iswspace(wc) and iswalnum(wc) returns false, verify iswpunct(wc) returns true.
  2. If iswspace(wc) returns false and ispunct(wctob(wc)) returns true, verify iswpunct(wc) returns true.
  3. If iswspace(wc) returns true (except L' ') and ispunct(wctob(wc)) returns true, either iswpunct(wc) or (iswprint(wc) && iswspace(wc)) returns true.
50 iswspace 2 #include <wctype.h>
int iswspace (wint_t wc);
  1. If iswalnum(wc) and iswgraph(wc) and iswpunct(wc) return false, verify iswspace(wc) returns true.
  2. If isspace(wctob(wc)) returns true, verify iswspace(wc) returns true.
51 iswupper 2 #include <wctype.h>
int iswupper (wint_t wc);
  1. If wc shows uppercase wide character, verify iswupper(wc) returns true.
  2. If isupper(wctob(wc)) returns true, verify iswupper(wc) returns true.
52 iswxdigit 2 #include <wctype.h>
int iswxdigit (wint_t wc);
  1. If wc shows hexadecimal digit wide character, verify iswxdigit(wc) returns true.
  2. If isxdigit(wctob(wc)) returns true, verify iswxdigit(wc) returns true.
53 wctype 2 #include <wctype.h>
wctype_t wctype (const char *property);
  1. If the character string starting at property is as same name as character class which is defined on the current locale, verify this function returns the value corresponded that character class (the value is non-zero).
  2. If the character string starting at property is different from character classes which is defined on the current locale, verify this function returns 0.
54 iswctype 2 #include <wctype.h>
int iswtype (wint_t wc, wctype_t desc);
  1. If wc belongs character class which shows desc, verify this function returns 1.
  2. If wc does not belong character class which shows desc, verify this function returns 0.
(About the case desc does not show character class, the behavior is undefined.)
55 towlower 2 #include <wctype.h>
wint_t towlower (wint_t wc);
  1. If iswupper(wc) returns true and wc has corresponded lowercase wide character, verify this function returns the lowercase wide character.
  2. If iswupper(wc) returns false, or iswupper(wc) returns true and wc does not have corresponded lowercase wide character, verify this function returns wc.
56 towupper 2 #include <wctype.h>
wint_t towupper (wint_t wc);
  1. If iswlower(wc) returns true and wc has uppercase wide character, verify this function returns the uppercase wide character.
  2. If iswlower(wc) returns false, or islower(wc) returns true and wc does not have corresponded uppercase wide character, verify this function returns wc.
57 wctrans 2 #include <wctype.h>
wctrans_t wctrans (const char *property);
  1. If the character string starting at property is defined string as conversion directive which is defined on the current locale, verify this function returns the value corresponded that conversion directive. (the value is non-zero)
  2. If the character string starting at property is not valid string as conversion directive which is defined on the current locale, verify this function returns 0.
58 towctrans 2 #include <wctype.h>
wint_t towctrans (wint_t wc, wctrans_t desc);
  1. If wc can change into other wide character according to the conversion directive which desc shows, verify towctrans returns wide character which translated from wc.
  2. If wc can change into other wide character according to the conversion directive which desc shows, verify towctrans returns wc.
(About the case desc does not show character class, the behavior of towctrans is undefined.)
59 fwide 4 #include <stdio.h>
#include <wchar.h>
int fwide (FILE *stream, int mode);
  1. If any I/O function does not execute after fopen opens a file (or freopen reopens a file) and mode is 0, verify this function returns 0 and does not change the stream type.
  2. If any I/O function does not execute after fopen opens a file (or freopen reopens a file) and mode is positive, verify this function returns positive and changes the stream type to wide character oriented stream.
  3. If any I/O function does not execute after fopen opens a file (or freopen reopens a file) and mode is negative, verify this function returns negative and changes the stream type to byte-oriented stream.
  4. If the stream type is already defined, verify this function does not change the stream type whatever mode is given and returns negative or positive value depending on the stream type.
60 getwc 4 #include <stdio.h>
#include <wchar.h>
wint_t getwc (FILE *stream);
  1. If the byte sequence which starts at the file position indicator stands is valid as character on the current locale, verify this function returns the wide character which is equivalent to the multibyte character.
  2. If the byte sequence starting at the file position indicator stands is invalid as character on the current locale, verify this function returns WEOF and set errno EILSEQ.
  3. If the file position indicator stands at end-of-file, verify this function returns WEOF.
  4. After executing this function correctly, verify the type of stream is changed to wide character oriented.
61 getwchar 3 #include <stdio.h>
#include <wchar.h>
wint_t getwchar (void);
  1. If the byte sequence given via standard input is valid as character on the current locale, verify this function returns the wide character which is equivalent to the multibyte character.
  2. If the byte sequence given via standard input is invalid as character on the current locale, verify this function returns WEOF and set errno EILSEQ.
  3. After executing this function correctly, the type of standard input is changed to wide character oriented.
62 fgetwc 4 #include <stdio.h>
#include <wchar.h>
wint_t fgetwc (FILE *stream);
  1. If the byte sequence which starts at the file position indicator stands is valid as a character on the current locale, verify this function returns the wide character which is equivalent to the multibyte character.
  2. If the byte sequence starting which is at the file position indicator stands is invalid as a character on the current locale, verify this function returns WEOF and set errno EILSEQ.
  3. If the file position indicator stands at end-of-file, verify this function returns WEOF.
  4. After executing this function correctly, verify the type of stream is changed to wide character oriented.
63 fgetws 4 #include <stdio.h>
#include <wchar.h>
wchar_t *fgetws (wchar_t *s, int n, FILE *stream);
  1. If the byte sequence which starts at the file position indicator stands is valid as a multibyte character string on the current locale, verify this function returns s, and sets a wide character string at s. The wide character string is equivalent to the multibyte character string and appends a null wide character at the end of the wide character string.
  2. If the byte sequence which starts at the file position indicator stands is invalid as a multibyte character string on the current locale, verify this function returns NULL.
  3. If the file position indicator stands at end-of-file, verify this function returns NULL.
  4. After executing this function correctly, verify the type of stream is changed to wide character oriented.
64 ungetwc 6 #include <stdio.h>
#include <wchar.h>
wint_t ungetwc (wint_t c, FILE *stream);
  1. Upon successful completion, verify this function returns the pushed-back character.
  2. After push back one wide character onto the stream with this function, verify the next function to read one or some characters from the stream gets the character as the first character.
  3. If c is WEOF, verify this function returns WEOF and does not influence the stream.
  4. After ungetwc is called, check the end-of-file indicator is cleared.
  5. When the file-position indicator stand at the top of a file, verify WEOF is returned by calling this function or ungotten character is can be gotten after calling this function.
  6. Verify the value of the file-position indicator for the stream when this function is called successfully is decreased before the character was pushed-back. (But the file-position indicator is 0 before the function is called, the file position indicator is not indeterminate after the call.)
65 putwc 3 #include <stdio.h>
#include <wchar.h>
wint_t putwc (wchar_t c, FILE *stream);
  1. If the wide character wc has possibility to convert a multibyte character on the current locale, verify this function writes the multibyte character to the stream and returns wc.
  2. If the wide character wc cannot be outputted for some reason, verify this function returns WEOF.
  3. After executing this function correctly, verify the type of stream is changed to wide character oriented.
66 putwchar 3 #include <stdio.h>
#include <wchar.h>
wint_t putwchar (wchar_t c);
  1. If the wide character wc has possibility to convert a multibyte character on the current locale, verify this function writes the multibyte character to standard output and returns wc.
  2. If the wide character wc cannot be outputted for some reason, verify this function returns WEOF.
  3. After executing this function correctly, verify the type of standard output is changed to wide character oriented.
67 fputwc 3 #include <stdio.h>
#include <wchar.h>
wint_t fputwc (wchar_t c, FILE *stream);
  1. If the wide character wc has possibility to convert a multibyte character on the current locale, verify this function writes the multibyte character to the stream and returns wc.
  2. If the wide character wc cannot be outputted for some reason, verify this function returns WEOF.
  3. After executing this function correctly, verify the type of stream is changed to wide character oriented.
68 fputws 3 #include <stdio.h>
#include <wchar.h>
int *fputws (const wchar_t *s, FILE *stream);
  1. If the wide character string starting at s has possibility to convert multibyte character string on the current locale, verify this function writes the multibyte character string (except terminating null wide character) to the stream and returns 0 or positive value.
  2. If the wide character string starting at s cannot be outputted for some reason, verify this function returns -1.
  3. After executing this function correctly, verify the type of stream is changed to wide character oriented.
69 wscanf 24 #include <stdio.h>
#include <wchar.h>
int wscanf (const wchar_t *format, ...);
  1. Verify a directive composed one or more whitespace wide character is executed by reading input until no more valid input can be read, or up to the first wide character which is not whitespace wide character, which remains unread.
  2. If a directive is an ordinary wide character (i.e. except for %, and whitespace wide character), verify the next character is read, and compare with the directive and the read one and when they are not equivalent, the directive fails, and the differing and subsequent wide characters remain unread.
  3. If a conversion specification has `*', verify the result of conversion is not stored any arguments.
  4. If a conversion specification has a field width, verify this function interprets the interpreted wide character in the number of the field width.
  5. If a conversion wide character is `d', verify the conversion result is the same as the results of wcstol() with the value 10 for the base argument.
  6. If a conversion wide character is `i', verify the conversion result is the same as the results of wcstol() with the value 0 for the base argument.
  7. If a conversion wide character is `o', verify the conversion result is the same as the results of wcstoul() with the value 8 for the base argument.
  8. If a conversion wide character is `u', verify the conversion result is the same as the results of wcstoul() with the value 10 for the base argument.
  9. If a conversion wide character is `x' or `X', verify the conversion result is the same as the results of wcstoul() with the value 16 for the base argument.
  10. If a conversion wide character is `e', `E', `f', `g' or `G', verify the conversion result is the same as the results of wcstod(). Especially check the radix character according to the current locale is interpreted correctly.
  11. If a conversion wide character is `c' and conversion specification does not have `l', verify this function reads a sequence of the wide characters of the number specified by the field width, and stores the multibyte character sequence as same that are made of the sequence of the wide characters by wcsrtombs() with initial conversion state.
  12. If a conversion wide character is `c' and conversion specification has `l', verify this function reads a sequence of the wide characters of the number specified by the field width, and stores them.
  13. If a conversion wide character is `s' and conversion specification does not have `l', verify this function reads a wide character string, and stores the multibyte character string as same that are made of the wide character string by wcsrtombs() with initial conversion state. Especially check the null character is stood at the end of the multibyte character string.
  14. If a conversion wide character is `s' and conversion specification has `l', verify this function reads a wide character string, and stores them. Especially check the null wide character is stood at the end of wide character string.
  15. If a conversion wide characters are `[...]', verify this function reads the wide characters which are included between `[' and ']', and stores the multibyte character sequence as same that are made of the sequence of the wide characters by wcsrtombs() with initial conversion state. Especially check the null character is stood at the end of the multibyte character string.
  16. If a conversion wide character is `l[...]', verify this function reads the wide characters which are included between `[' and ']', and stores them. Especially check the null wide character is stood at the end of the wide character string.
  17. If a conversion wide character is `[^...]', verify this function reads the wide characters which are not included between `[^' and ']', and stores the multibyte character sequence as same that are made of the sequence of the wide characters by wcsrtombs() with initial conversion state. Especially check the null character is stood at the end of the multibyte character string.
  18. If a conversion wide character is `l[^...]', verify this function reads a sequence of the wide characters which is not included between `[^' and ']', and stores them. Especially check the null character is stood at the end of the multibyte character string.
  19. If a conversion wide character is `p', verify this function stores the pointer value.
  20. If a conversion wide character is `n', verify no input is consumed, and this function stores the number of the wide character which the function has read.
  21. If a conversion wide character is `%' (i.e. the orthography is `%%', it matched a wide character %.
  22. If this function has not did any conversion by a read error, verify this function returns EOF.
  23. If this function has did one or more conversion, verify this function returns the number of the conversion.
  24. After executing this function correctly, verify standard input is changed to wide character oriented.
70 fwscanf 24 #include <stdio.h>
#include <wchar.h>
int fwscanf (FILE *stream, const wchar_t *format, ...);

  1. Verify a directive composed one or more whitespace wide character is executed by reading input until no more valid input can be read, or up to the first wide character which is not whitespace wide character, which remains unread.
  2. If a directive is an ordinary wide character (i.e. except for %, and whitespace wide character), verify the next character is read, and compare with the directive and the read one and when they are not equivalent, the directive fails, and the differing and subsequent wide characters remain unread.
  3. If a conversion specification has `*', verify the result of conversion is not stored any arguments.
  4. If a conversion specification has a field width, verify this function interprets the interpreted wide character in the number of the field width.
  5. If a conversion wide character is `d', verify the conversion result is the same as the results of wcstol() with the value 10 for the base argument.
  6. If a conversion wide character is `i', verify the conversion result is the same as the results of wcstol() with the value 0 for the base argument.
  7. If a conversion wide character is `o', verify the conversion result is the same as the results of wcstoul() with the value 8 for the base argument.
  8. If a conversion wide character is `u', verify the conversion result is the same as the results of wcstoul() with the value 10 for the base argument.
  9. If a conversion wide character is `x' and `X', verify the conversion result is the same as the results of wcstoul() with the value 16 for the base argument.
  10. If a conversion wide character is `e', `E', `f', `F', `g' and `G', verify the conversion result is the same as the results of wcstod(). Especially check the radix character according to the current locale is interpreted correctly.
  11. If a conversion wide character is `c' and conversion specification does not have `l', verify this function reads a sequence of the wide characters of the number specified by the field width, and stores the multibyte character sequence as same that are made of the sequence of the wide characters by wcsrtombs() with initial conversion state.
  12. If a conversion wide character is `c' and conversion specification has `l', verify this function reads a sequence of the wide characters of the number specified by the field width, and stores them.
  13. If a conversion wide character is `s' and conversion specification does not have `l', verify this function reads a wide character string, and stores the multibyte character string as same that are made of the wide character string by wcsrtombs() with initial conversion state. Especially check the null character is stood at the end of the multibyte character string.
  14. If a conversion wide character is `s' and conversion specification has `l', verify this function reads a wide character string, and stores them. Especially check the null wide character is stood at the end of wide character string.
  15. If a conversion wide characters are `[...]', verify this function reads the wide characters which are included between `[' and ']', and stores the multibyte character sequence as same that are made of the sequence of the wide characters by wcsrtombs() with initial conversion state. Especially check the null character is stood at the end of the multibyte character string.
  16. If a conversion wide character is `l[...]', verify this function reads the wide characters which are included between `[' and ']', and stores them. Especially check the null wide character is stood at the end of the wide character string.
  17. If a conversion wide character is `[^...]', verify this function reads the wide characters which are not included between `[^' and ']', and stores the multibyte character sequence as same that are made of the sequence of the wide characters by wcsrtombs() with initial conversion state. Especially check the null character is stood at the end of the multibyte character string.
  18. If a conversion wide character is `l[^...]', verify this function reads a sequence of the wide characters which is not included between `[^' and ']', and stores them. Especially check the null character is stood at the end of the multibyte character string.
  19. If a conversion wide character is `p', verify this function stores the pointer value.
  20. If a conversion wide character is `n', verify no input is consumed, and this function stores the number of the wide character which the function has read.
  21. If a conversion wide character is `%' (i.e. the orthography is `%%', it matched a wide character %.
  22. If this function has not did any conversion by a read error, verify this function returns EOF.
  23. If this function has did one or more conversion, verify this function returns the number of the conversion.
  24. After executing this function correctly, verify the stream is changed to wide character oriented.
71 swscanf 23 #include <stdio.h>
#include <wchar.h>
int swscanf (const wchar_t *s, const wchar_t *format, ...);
  1. Verify a directive composed one or more whitespace wide character is executed by reading input until no more valid input can be read, or up to the first wide character which is not whitespace wide character, which remains unread.
  2. If a directive is an ordinary wide character (i.e. except for %, and whitespace wide character), verify the next character is read, and compare with the directive and the read one and when they are not equivalent, the directive fails, and the differing and subsequent wide characters remain unread.
  3. If a conversion specification has `*', verify the result of conversion is not stored any arguments.
  4. If a conversion specification has a field width, verify this function interprets the interpreted wide character in the number of the field width.
  5. If a conversion wide character is `d', verify the conversion result is the same as the results of wcstol() with the value 10 for the base argument.
  6. If a conversion wide character is `i', verify the conversion result is the same as the results of wcstol() with the value 0 for the base argument.
  7. If a conversion wide character is `o', verify the conversion result is the same as the results of wcstoul() with the value 8 for the base argument.
  8. If a conversion wide character is `u', verify the conversion result is the same as the results of wcstoul() with the value 10 for the base argument.
  9. If a conversion wide character is `x' and `X', verify the conversion result is the same as the results of wcstoul() with the value 16 for the base argument.
  10. If a conversion wide character is `e', `E', `f', `F', `g' and `G', verify the conversion result is the same as the results of wcstod(). Especially check the radix character according to the current locale is interpreted correctly.
  11. If a conversion wide character is `c' and conversion specification does not have `l', verify this function reads a sequence of the wide characters of the number specified by the field width, and stores the multibyte character sequence as same that are made of the sequence of the wide characters by wcsrtombs() with initial conversion state.
  12. If a conversion wide character is `c' and conversion specification has `l', verify this function reads a sequence of the wide characters of the number specified by the field width, and stores them.
  13. If a conversion wide character is `s' and conversion specification does not have `l', verify this function reads a wide character string, and stores the multibyte character string as same that are made of the wide character string by wcsrtombs() with initial conversion state. Especially check the null character is stood at the end of the multibyte character string.
  14. If a conversion wide character is `s' and conversion specification has `l', verify this function reads a wide character string, and stores them. Especially check the null wide character is stood at the end of wide character string.
  15. If a conversion wide characters are `[...]', verify this function reads the wide characters which are included between `[' and ']', and stores the multibyte character sequence as same that are made of the sequence of the wide characters by wcsrtombs() with initial conversion state. Especially check the null character is stood at the end of the multibyte character string.
  16. If a conversion wide character is `l[...]', verify this function reads the wide characters which are included between `[' and ']', and stores them. Especially check the null wide character is stood at the end of the wide character string.
  17. If a conversion wide character is `[^...]', verify this function reads the wide characters which are not included between `[^' and ']', and stores the multibyte character sequence as same that are made of the sequence of the wide characters by wcsrtombs() with initial conversion state. Especially check the null character is stood at the end of the multibyte character string.
  18. If a conversion wide character is `l[^...]', verify this function reads a sequence of the wide characters which is not included between `[^' and ']', and stores them. Especially check the null character is stood at the end of the multibyte character string.
  19. If a conversion wide character is `p', verify this function stores the pointer value.
  20. If a conversion wide character is `n', verify no input is consumed, and this function stores the number of the wide character which the function has read.
  21. If a conversion wide character is `%' (i.e. the orthography is `%%', it matched a wide character %.
  22. If this function has not did any conversion by a read error, verify this function returns EOF.
  23. If this function has did one or more conversion, verify this function returns the number of the conversion.
72 wprintf 53 #include <stdio.h>
#include <wchar.h>
int wprintf (const wchar_t *format, ...);
  1. If field width is defined with decimal number, the length of output character is less than that decimal number, a `0' flag is not included in conversion specification and a `-' is not included in conversion specification, verify this function pads with spaces on the left.
  2. If field width is defined with decimal number, the length of output character is less than that decimal number, and a `-' is included in conversion specification, verify this function pads with spaces on the right whether a `0' flag is included in conversion specification or not.
  3. If field width is defined with decimal number, the conversion specifier is `d', `i', `o', `u', `x', `X', `e', `E', `f', `g' or `G', the length of output character is less than that decimal number, a `0' flag is included in conversion specification, and a `-' is not included in conversion specification, verify this function pads with the wide character 0 on the left.
  4. If field width is defined with decimal number and the length of output character is more than that decimal number, verify this function outputs the whole conversion results.
  5. Check this function ignores a `0' flag when the conversion specifier is `d', `i', `o', `u', `x' or `X' and conversion specification includes precision.
  6. Check the sign and base precedes the padded 0 when a `0' flag is given.
  7. If field width is given in *, verify an argument of type int supplies the field width.
  8. If precision is defined with decimal number and the conversion specifier is `d', `i', `o', `u', `x' or `X', verify the precision is interpreted as the minimum number of digits to appear.
  9. If precision is defined with decimal number and the conversion specifier is `e', `E' or `f', verify the precision is interpreted as the number of digits to appear after the radix character.
  10. If precision is defined with decimal number and the conversion specifier is `g' or `G', verify the precision is interpreted as the maximum number of significant digits.
  11. If precision is defined with decimal number and the conversion specifier is `s', verify the precision is interpreted as the maximum number of wide characters to be printed.
  12. If precision is given in *, verify an argument of type int supplies the precision.
  13. If precision is formed only .(period) into, verify precision is treated as 0.
  14. If a `+' flag is included in conversion specification, verify the result of a signed conversion begins with a sign(+ or -).
  15. If a `'(space) flag is included in conversion specification, verify the result of a signed conversion begins with a space when the first wide character of the conversion results is not a sign or a signed conversion results in no wide characters.
  16. If a `#' is included in conversion specification and the conversion specifier is `o', verify the result of a conversion begins with a 0.
  17. If a `#' is included in conversion specification and the conversion specifier is `x' or `X', verify the result of a conversion begins with a 0x or 0X.
  18. If a `#' is included in conversion specification and the conversion specifier is `e', `E', `f', `g' or `G', verify the result of a conversion includes the radix character.
  19. If a `#' is included in conversion specification and the conversion specifier is `g' or `G', verify the trailing zeros after radix character is not removed from the results.
  20. If a conversion specifier is `d' or `i', verify the int argument is converted to a signed decimal format.
  21. If a conversion specifier is `d' or `i' and the precision is more than the number of digits, verify the conversion results is expanded with leading 0.
  22. If a conversion specifier is `u', verify the unsigned int argument is converted to a unsigned decimal format.
  23. If a conversion specifier is `u' and the precision is more than the number of digits, verify the conversion results is expanded with leading 0.
  24. If a conversion specifier is `o', verify the unsigned int argument is converted to a unsigned octal format.
  25. If a conversion specifier is `o' and the precision is more than the number of digits, verify the conversion results is expanded with leading 0.
  26. If a conversion specifier is `x', verify the unsigned int argument is converted to a unsigned hexadecimal format (the letters `abcdef' are used).
  27. If a conversion specifier is `X', verify the unsigned int argument is converted to a unsigned hexadecimal format (the letters `ABCDEF' are used).
  28. If a conversion specifier is `x' or `X', and the precision is more than the number of digits, verify the conversion results is expanded with leading 0.
  29. If a conversion specifier is `f', verify the double argument is converted to decimal notation in the style [-]ddd.ddd. Especially check the radix character is according to the current locale.
  30. If a conversion specifier is `f' and the precision is not defined, verify the precision is taken as 6.
  31. If a conversion specifier is `f', the precision is 0 and a `#' flag is not included in conversion specification, verify no radix character appears.
  32. If a conversion specifier is `e', verify the double argument is converted in the style [-]d.ddde+(or -)dd. Especially check the radix character is according to the current locale.
  33. If a conversion specifier is `E', verify the double argument is converted in the style [-]d.dddE+(or -)dd. Especially check the radix character is according to the current locale.
  34. If a conversion specifier is `e' or `E' and the precision is not defined, verify precision is taken as 6.
  35. If a conversion specifier is `e' or `E', the precision is 0 and a `#' flag is not included in conversion specification, verify no radix character appears.
  36. When a conversion specifier is `g', if the exponent of the conversion results is less than -4 or greater than or equal to precision, verify the double argument is converted as same style as `e'. (But if precision is 0, it is taken as 1.) Especially check the radix character is according to the current locale.
  37. When a conversion specifier is `G', and if the exponent of the conversion results is less than -4 or greater than or equal to precision, verify the double argument is converted as same style as `E'. (But if precision is 0, it is taken as 1.) Especially check the radix character is according to the current locale.
  38. When a conversion specifier is `g' or `G', and if the exponent of the conversion results is greater than or equal to -4 and less than precision, verify the double argument is converted as same style as `f'. (But if precision is 0, it is taken as 1.)
  39. If a conversion specifier is `g' or `G', verify the trailing 0 are removed from the fractional portion of the results.
  40. If a conversion specifier is `g' or `G', verify a radix character is appears only when it follows digits.
  41. If a conversion specifier is `c' and no `l' specifier is present, verify the int argument is converted to a wide character as if by calling the btowc() the resulting wide character is written.
  42. If a conversion specifier is `c' and `l' specifier is present, verify the wint_t argument is written after converting wchar_t argument.
  43. When a conversion specifier is `s' and no `l' specifier is present, and if the precision is less than or equal to the length of the converted wide character, verify a multibyte character string starting at a pointer to character given by the argument is converted to a wide character string as if by calling the mbsrtowcs() function with initial conversion state and the wide characters, which are the top of string and which length is as same as the precision, are written.
  44. When a conversion specifier is `s' and no `l' specifier is present, and if the precision is more than the length of the converted wide character, verify a multibyte character string starting at a pointer to character given by the argument is converted to a wide character string as if by calling the mbsrtowcs() function with initial conversion state and the wide character string is written.
  45. When a conversion specifier is `s' and `l' specifier is present, and if the precision is less than or equal to the length of the converted wide character, verify the wide characters, which are the top of the string starting at a point to wide character given by the argument and which length is as same as the precision, are written.
  46. When a conversion specifier is `s' and `l' specifier is present, and the precision is more than the length of the converted wide character, verify a wide character string starting at a pointer to wide character given by the argument is written.
  47. If a conversion specifier is `p', verify the argument which is a pointer to void is converted to a sequence of printable wide characters.
  48. If a conversion specifier is `n', verify this function stores the number of the wide character, which the function has written, to the pointer to an integer which is given by the argument.
  49. If a conversion specifier is `%', verify this function output a % wide character.
  50. If an output error is occurred, verify this function returns negative value.
  51. If no output error is occurred, verify this function returns the number of the written wide characters.
  52. Verify the limits of conversion character is at least 509.
  53. After executing this function correctly, verify the standard output is changed to wide character oriented.
73 fwprintf 53 #include <stdio.h>
#include <wchar.h>
int fwprintf (FILE *stream, const wchar_t *format, ...);
  1. If field width is defined with decimal number, the length of output character is less than that decimal number, a `0' flag is not included in conversion specification and a `-' is not included in conversion specification, verify this function pads with spaces on the left.
  2. If field width is defined with decimal number, the length of output character is less than that decimal number, and a `-' is included in conversion specification, verify this function pads with spaces on the right whether a `0' flag is included in conversion specification or not.
  3. If field width is defined with decimal number, the conversion specifier is `d', `i', `o', `u', `x', `X', `e', `E', `f', `g' or `G', the length of output character is less than that decimal number, a `0' flag is included in conversion specification, and a `-' is not included in conversion specification, verify this function padded with the wide character 0 on the left.
  4. If field width is defined with decimal number and the length of output character is more than that decimal number, verify this function outputs the whole conversion results.
  5. Check this function ignores a `0' flag when the conversion specifier is `d', `i', `o', `u', `x' or `X' and conversion specification includes precision.
  6. Check the sign and base precedes the padded 0 when a `0' flag is given.
  7. If field width is given in *, verify an argument of type int supplies the field width.
  8. If precision is defined with decimal number and the conversion specifier is `d', `i', `o', `u', `x' or `X', verify the precision is interpreted as the minimum number of digits to appear.
  9. If precision is defined with decimal number and the conversion specifier is `e', `E' or `f', verify the precision is interpreted as the number of digits to appears after the radix character.
  10. If precision is defined with decimal number and the conversion specifier is `g' or `G', verify the precision is interpreted as the maximum number of significant digits.
  11. If precision is defined with decimal number and the conversion specifier is `s', verify the precision is interpreted as the maximum number of wide characters to be printed.
  12. If precision is given in *, verify an argument of type int supplies the precision.
  13. If precision is formed only .(period) into, verify precision is treated as 0.
  14. If a `+' flag is included in conversion specification, verify the result of a signed conversion begins with a sign(+ or -).
  15. If a ` '(space) flag is included in conversion specification, verify the result of a signed conversion begins with a space when the first wide character of the conversion results is not a sign or a signed conversion results in no wide characters.
  16. If a `#' is included in conversion specification and the conversion specifier is `o', verify the result of a conversion begins with a 0.
  17. If a `#' is included in conversion specification and the conversion specifier is `x' or `X', verify the result of a conversion begins with a 0x or 0X.
  18. If a `#' is included in conversion specification and the conversion specifier is `e', `E', `f', `g' or `G', verify the result of a conversion includes the radix character.
  19. If a `#' is included in conversion specification and the conversion specifier is `g' or `G', verify the trailing zeros after radix character is not removed from the results.
  20. If a conversion specifier is `d' or `i', verify the int argument is converted to a signed decimal format.
  21. If a conversion specifier is `d' or `i' and the precision is more than the number of digits, verify the conversion results is expanded with leading 0.
  22. If a conversion specifier is `u', verify the unsigned int argument is converted to a unsigned decimal format.
  23. If a conversion specifier is `u' and the precision is more than the number of digits, verify the conversion results is expanded with leading 0.
  24. If a conversion specifier is `o', verify the unsigned int argument is converted to a unsigned octal format.
  25. If a conversion specifier is `o' and the precision is more than the number of digits, verify the conversion results is expanded with leading 0.
  26. If a conversion specifier is `x', verify the unsigned int argument is converted to a unsigned hexadecimal format (the letters `abcdef' are used).
  27. If a conversion specifier is `X', verify the unsigned int argument is converted to a unsigned hexadecimal format (the letters `ABCDEF' are used).
  28. If a conversion specifier is `x' or `X', and the precision is more than the number of digits, verify the conversion results is expanded with leading 0.
  29. If a conversion specifier is `f', verify the double argument is converted to decimal notation in the style [-]ddd.ddd. Especially check the radix character is according to the current locale.
  30. If a conversion specifier is `f' and the precision is not defined, verify the precision is taken as 6.
  31. If a conversion specifier is `f', the precision is 0 and a `#' flag is not included in conversion specification, verify no radix character appears.
  32. If a conversion specifier is `e', verify the double argument is converted in the style [-]d.ddde+(or -)dd. Especially check the radix character is according to the current locale.
  33. If a conversion specifier is `E', verify the double argument is converted in the style [-]d.dddE+(or -)dd. Especially check the radix character is according to the current locale.
  34. If a conversion specifier is `e' or `E' and the precision is not defined, verify precision is taken as 6.
  35. If a conversion specifier is `e' or `E', the precision is 0 and a `#' flag is not included in conversion specification, verify no radix character appears.
  36. When a conversion specifier is `g', if the exponent of the conversion results is less than -4 or greater than or equal to precision, verify the double argument is converted as same style as `e'. (But if precision is 0, it is taken as 1.) Especially check the radix character is according to the current locale.
  37. When a conversion specifier is `G', and if the exponent of the conversion results is less than -4 or greater than or equal to precision, verify the double argument is converted as same style as `E'. (But if precision is 0, it is taken as 1.) Especially check the radix character is according to the current locale.
  38. When a conversion specifier is `g' or `G', and if the exponent of the conversion results is greater than or equal to -4 and less than precision, verify the double argument is converted as same style as `f'. (But if precision is 0, it is taken as 1.)
  39. If a conversion specifier is `g' or `G', verify the trailing 0 are removed from the fractional portion of the results.
  40. If a conversion specifier is `g' or `G', verify a radix character is appears only when it follows digits.
  41. If a conversion specifier is `c' and no `l' specifier is present, verify the int argument is converted to a wide character as if by calling the btowc() the resulting wide character is written.
  42. If a conversion specifier is `c' and `l' specifier is present, verify the wint_t argument is written after converting wchar_t argument.
  43. When a conversion specifier is `s' and no `l' specifier is present, and if the precision is less than or equal to the length of the converted wide character, verify a multibyte character string starting at a pointer to character given by the argument is converted to a wide character string as if by calling the mbsrtowcs() function with initial conversion state and the wide characters, which are the top of string and which length is as same as the precision, are written.
  44. When a conversion specifier is `s' and no `l' specifier is present, and if the precision is more than the length of the converted wide character, verify a multibyte character string starting at a pointer to character given by the argument is converted to a wide character string as if by calling the mbsrtowcs() function with initial conversion state and the wide character string is written.
  45. When a conversion specifier is `s' and `l' specifier is present, and if the precision is less than or equal to the length of the converted wide character, verify the wide characters, which are the top of the string starting at a point to wide character given by the argument and which length is as same as the precision, are written.
  46. When a conversion specifier is `s' and `l' specifier is present, and the precision is more than the length of the converted wide character, verify a wide character string starting at a pointer to wide character given by the argument is written.
  47. If a conversion specifier is `p', verify the argument which is a pointer to void is converted to a sequence of printable wide characters.
  48. If a conversion specifier is `n', verify this function stores the number of the wide character, which the function has written, to the pointer to an integer which is given by the argument.
  49. If a conversion specifier is `%', verify this function output a % wide character.
  50. If an output error is occurred, verify this function returns negative value.
  51. If no output error is occurred, verify this function returns the number of the written wide characters.
  52. Verify the limits of conversion character is at least 509.
  53. After executing this function correctly, verify the stream is changed to wide character oriented.
74 swprintf 52 #include <wchar.h>
int swprintf (wchar_t *s, size_t n, const wchar_t *format, ...);
  1. If field width is defined with decimal number, the length of output character is less than that decimal number, a `0' flag is not included in conversion specification and a `-' is not included in conversion specification, verify this function pads with spaces on the left.
  2. If field width is defined with decimal number, the length of output character is less than that decimal number, and a `-' is included in conversion specification, verify this function pads with spaces on the right whether a `0' flag is included in conversion specification or not.
  3. If field width is defined with decimal number, the conversion specifier is `d', `i', `o', `u', `x', `X', `e', `E', `f', `g' or `G', the length of output character is less than that decimal number, a `0' flag is included in conversion specification, and a `-' is not included in conversion specification, verify this function padded with the wide character 0 on the left.
  4. If field width is defined with decimal number and the length of output character is more than that decimal number, verify this function outputs the whole conversion results.
  5. Check this function ignores a `0' flag when the conversion specifier is `d', `i', `o', `u', `x' or `X' and conversion specification includes precision.
  6. Check the sign and base precedes the padded 0 when a `0' flag is given.
  7. If field width is given in *, verify an argument of type int supplies the field width.
  8. If precision is defined with decimal number and the conversion specifier is `d', `i', `o', `u', `x' or `X', verify the precision is interpreted as the minimum number of digits to appear.
  9. If precision is defined with decimal number and the conversion specifier is `e', `E' or `f', verify the precision is interpreted as the number of digits to appears after the radix character.
  10. If precision is defined with decimal number and the conversion specifier is `g' or `G', verify the precision is interpreted as the maximum number of significant digits.
  11. If precision is defined with decimal number and the conversion specifier is `s', verify the precision is interpreted as the maximum number of wide characters to be printed.
  12. If precision is given in *, verify an argument of type int supplies the precision.
  13. If precision is formed only .(period) into, verify precision is treated as 0.
  14. If a `+' flag is included in conversion specification, verify the result of a signed conversion begins with a sign(+ or -).
  15. If a `'(space) flag is included in conversion specification, verify the result of a signed conversion begins with a space when the first wide character of the conversion results is not a sign or a signed conversion results in no wide characters.
  16. If a `#' is included in conversion specification and the conversion specifier is `o', verify the result of a conversion begins with a 0.
  17. If a `#' is included in conversion specification and the conversion specifier is `x' or `X', verify the result of a conversion begins with a 0x or 0X.
  18. If a `#' is included in conversion specification and the conversion specifier is `e', `E', `f', `g' or `G', verify the result of a conversion includes the radix character.
  19. If a `#' is included in conversion specification and the conversion specifier is `g' or `G', verify the trailing zeros after radix character is not removed from the results.
  20. If a conversion specifier is `d' or `i', verify the int argument is converted to a signed decimal format.
  21. If a conversion specifier is `d' or `i' and the precision is more than the number of digits, verify the conversion results is expanded with leading 0.
  22. If a conversion specifier is `u', verify the unsigned int argument is converted to a unsigned decimal format.
  23. If a conversion specifier is `u' and the precision is more than the number of digits, verify the conversion results is expanded with leading 0.
  24. If a conversion specifier is `o', verify the unsigned int argument is converted to a unsigned octal format.
  25. If a conversion specifier is `o' and the precision is more than the number of digits, verify the conversion results is expanded with leading 0.
  26. If a conversion specifier is `x', verify the unsigned int argument is converted to a unsigned hexadecimal format (the letters `abcdef' are used).
  27. If a conversion specifier is `X', verify the unsigned int argument is converted to a unsigned hexadecimal format (the letters `ABCDEF' are used).
  28. If a conversion specifier is `x' or `X', and the precision is more than the number of digits, verify the conversion results is expanded with leading 0.
  29. If a conversion specifier is `f', verify the double argument is converted to decimal notation in the style [-]ddd.ddd. Especially check the radix character is according to the current locale.
  30. If a conversion specifier is `f' and the precision is not defined, verify the precision is taken as 6.
  31. If a conversion specifier is `f', the precision is 0 and a `#' flag is not included in conversion specification, verify no radix character appears.
  32. If a conversion specifier is `e', verify the double argument is converted in the style [-]d.ddde+(or -)dd. Especially check the radix character is according to the current locale.
  33. If a conversion specifier is `E', verify the double argument is converted in the style [-]d.dddE+(or -)dd. Especially check the radix character is according to the current locale.
  34. If a conversion specifier is `e' or `E' and the precision is not defined, verify precision is taken as 6.
  35. If a conversion specifier is `e' or `E', the precision is 0 and a `#' flag is not included in conversion specification, verify no radix character appears.
  36. When a conversion specifier is `g', if the exponent of the conversion results is less than -4 or greater than or equal to precision, verify the double argument is converted as same style as `e'. (But if precision is 0, it is taken as 1.) Especially check the radix character is according to the current locale.
  37. When a conversion specifier is `G', and if the exponent of the conversion results is less than -4 or greater than or equal to precision, verify the double argument is converted as same style as `E'. (But if precision is 0, it is taken as 1.) Especially check the radix character is according to the current locale.
  38. When a conversion specifier is `g' or `G', and if the exponent of the conversion results is greater than or equal to -4 and less than precision, verify the double argument is converted as same style as `f'. (But if precision is 0, it is taken as 1.)
  39. If a conversion specifier is `g' or `G', verify the trailing 0 are removed from the fractional portion of the results.
  40. If a conversion specifier is `g' or `G', verify a radix character is appears only when it follows digits.
  41. If a conversion specifier is `c' and no `l' specifier is present, verify the int argument is converted to a wide character as if by calling the btowc() the resulting wide character is written.
  42. If a conversion specifier is `c' and `l' specifier is present, verify the wint_t argument is written after converting wchar_t argument.
  43. When a conversion specifier is `s' and no `l' specifier is present, and if the precision is less than or equal to the length of the converted wide character, verify a multibyte character string starting at a pointer to character given by the argument is converted to a wide character string as if by calling the mbsrtowcs() function with initial conversion state and the wide characters, which are the top of string and which length is as same as the precision, are written.
  44. When a conversion specifier is `s' and no `l' specifier is present, and if the precision is more than the length of the converted wide character, verify a multibyte character string starting at a pointer to character given by the argument is converted to a wide character string as if by calling the mbsrtowcs() function with initial conversion state and the wide character string is written. Especially check the null wide character is stood at the end of wide character string.
  45. When a conversion specifier is `s' and `l' specifier is present, and if the precision is less than or equal to the length of the converted wide character, verify the wide characters, which are the top of the string starting at a point to wide character given by the argument and which length is as same as the precision, are written.
  46. When a conversion specifier is `s' and `l' specifier is present, and the precision is more than the length of the converted wide character, verify a wide character string starting at a pointer to wide character given by the argument is written. Especially check the null wide character is stood at the end of wide character string.
  47. If a conversion specifier is `p', verify the argument which is a pointer to void is converted to a sequence of printable wide characters.
  48. If a conversion specifier is `n', verify this function stores the number of the wide character, which the function has written, to the pointer to an integer which is given by the argument.
  49. If a conversion specifier is `%', verify this function output a % wide character.
  50. If the total length of the wide character which is made by conversion is more than n (including the terminating null wide character), verify this function returns negative value and outputs only n wide character.
  51. If no output error is occurred, verify this function returns the number of the written wide characters (excluding the terminating null wide character).
  52. Verify the limits of conversion character is at least 509.
75 vwprintf 53 #include <stdio.h>
#include <stdarg.h>

#include <wchar.h>
int vwprintf (const wchar_t *format, va_list arg);
  1. If field width is defined with decimal number, the length of output character is less than that decimal number, a `0' flag is not included in conversion specification and a `-' is not included in conversion specification, verify this function pads with spaces on the left.
  2. If field width is defined with decimal number, the length of output character is less than that decimal number, and a `-' is included in conversion specification, verify this function pads with spaces on the right whether a `0' flag is included in conversion specification or not.
  3. If field width is defined with decimal number, the conversion specifier is `d', `i', `o', `u', `x', `X', `e', `E', `f', `g' or `G', the length of output character is less than that decimal number, a `0' flag is included in conversion specification, and a `-' is not included in conversion specification, verify this function padded with the wide character 0 on the left.
  4. If field width is defined with decimal number and the length of output character is more than that decimal number, verify this function outputs the whole conversion results.
  5. Check this function ignores a `0' flag when the conversion specifier is `d', `i', `o', `u', `x' or `X' and conversion specification includes precision.
  6. Check the sign and base precedes the padded 0 when a `0' flag is given.
  7. If field width is given in *, verify an argument of type int supplies the field width.
  8. If precision is defined with decimal number and the conversion specifier is `d', `i', `o', `u', `x' or `X', verify the precision is interpreted as the minimum number of digits to appear.
  9. If precision is defined with decimal number and the conversion specifier is `e', `E' or `f', verify the precision is interpreted as the number of digits to appears after the radix character.
  10. If precision is defined with decimal number and the conversion specifier is `g' or `G', verify the precision is interpreted as the maximum number of significant digits.
  11. If precision is defined with decimal number and the conversion specifier is `s', verify the precision is interpreted as the maximum number of wide characters to be printed.
  12. If precision is given in *, verify an argument of type int supplies the precision.
  13. If precision is formed only .(period) into, verify precision is treated as 0.
  14. If a `+' flag is included in conversion specification, verify the result of a signed conversion begins with a sign(+ or -).
  15. If a `'(space) flag is included in conversion specification, verify the result of a signed conversion begins with a space when the first wide character of the conversion results is not a sign or a signed conversion results in no wide characters.
  16. If a `#' is included in conversion specification and the conversion specifier is `o', verify the result of a conversion begins with a 0.
  17. If a `#' is included in conversion specification and the conversion specifier is `x' or `X', verify the result of a conversion begins with a 0x or 0X.
  18. If a `#' is included in conversion specification and the conversion specifier is `e', `E', `f', `g' or `G', verify the result of a conversion includes the radix character.
  19. If a `#' is included in conversion specification and the conversion specifier is `g' or `G', verify the trailing zeros after radix character is not removed from the results.
  20. If a conversion specifier is `d' or `i', verify the int argument is converted to a signed decimal format.
  21. If a conversion specifier is `d' or `i' and the precision is more than the number of digits, verify the conversion results is expanded with leading 0.
  22. If a conversion specifier is `u', verify the unsigned int argument is converted to a unsigned decimal format.
  23. If a conversion specifier is `u' and the precision is more than the number of digits, verify the conversion results is expanded with leading 0.
  24. If a conversion specifier is `o', verify the unsigned int argument is converted to a unsigned octal format.
  25. If a conversion specifier is `o' and the precision is more than the number of digits, verify the conversion results is expanded with leading 0.
  26. If a conversion specifier is `x', verify the unsigned int argument is converted to a unsigned hexadecimal format (the letters `abcdef' are used).
  27. If a conversion specifier is `X', verify the unsigned int argument is converted to a unsigned hexadecimal format (the letters `ABCDEF' are used).
  28. If a conversion specifier is `x' or `X', and the precision is more than the number of digits, verify the conversion results is expanded with leading 0.
  29. If a conversion specifier is `f', verify the double argument is converted to decimal notation in the style [-]ddd.ddd. Especially check the radix character is according to the current locale.
  30. If a conversion specifier is `f' and the precision is not defined, verify the precision is taken as 6.
  31. If a conversion specifier is `f', the precision is 0 and a `#' flag is not included in conversion specification, verify no radix character appears.
  32. If a conversion specifier is `e', verify the double argument is converted in the style [-]d.ddde+(or -)dd. Especially check the radix character is according to the current locale.
  33. If a conversion specifier is `E', verify the double argument is converted in the style [-]d.dddE+(or -)dd. Especially check the radix character is according to the current locale.
  34. If a conversion specifier is `e' or `E' and the precision is not defined, verify precision is taken as 6.
  35. If a conversion specifier is `e' or `E', the precision is 0 and a `#' flag is not included in conversion specification, verify no radix character appears.
  36. When a conversion specifier is `g', if the exponent of the conversion results is less than -4 or greater than or equal to precision, verify the double argument is converted as same style as `e'. (But if precision is 0, it is taken as 1.) Especially check the radix character is according to the current locale.
  37. When a conversion specifier is `G', and if the exponent of the conversion results is less than -4 or greater than or equal to precision, verify the double argument is converted as same style as `E'. (But if precision is 0, it is taken as 1.) Especially check the radix character is according to the current locale.
  38. When a conversion specifier is `g' or `G', and if the exponent of the conversion results is greater than or equal to -4 and less than precision, verify the double argument is converted as same style as `f'. (But if precision is 0, it is taken as 1.)
  39. If a conversion specifier is `g' or `G', verify the trailing 0 are removed from the fractional portion of the results.
  40. If a conversion specifier is `g' or `G', verify a radix character is appears only when it follows digits.
  41. If a conversion specifier is `c' and no `l' specifier is present, verify the int argument is converted to a wide character as if by calling the btowc() the resulting wide character is written.
  42. If a conversion specifier is `c' and `l' specifier is present, verify the wint_t argument is written after converting wchar_t argument.
  43. When a conversion specifier is `s' and no `l' specifier is present, and if the precision is less than or equal to the length of the converted wide character, verify a multibyte character string starting at a pointer to character given by the argument is converted to a wide character string as if by calling the mbsrtowcs() function with initial conversion state and the wide characters, which are the top of string and which length is as same as the precision, are written.
  44. When a conversion specifier is `s' and no `l' specifier is present, and if the precision is more than the length of the converted wide character, verify a multibyte character string starting at a pointer to character given by the argument is converted to a wide character string as if by calling the mbsrtowcs() function with initial conversion state and the wide character string is written.
  45. When a conversion specifier is `s' and `l' specifier is present, and if the precision is less than or equal to the length of the converted wide character, verify the wide characters, which are the top of the string starting at a point to wide character given by the argument and which length is as same as the precision, are written.
  46. When a conversion specifier is `s' and `l' specifier is present, and the precision is more than the length of the converted wide character, verify a wide character string starting at a pointer to wide character given by the argument is written.
  47. If a conversion specifier is `p', verify the argument which is a pointer to void is converted to a sequence of printable wide characters.
  48. If a conversion specifier is `n', verify this function stores the number of the wide character, which the function has written, to the pointer to an integer which is given by the argument.
  49. If a conversion specifier is `%', verify this function output a % wide character.
  50. If an output error is occurred, verify this function returns negative value.
  51. If no output error is occurred, verify this function returns the number of the written wide characters.
  52. Verify the limits of conversion character is at least 509.
  53. After executing this function correctly, verify the stream is changed to wide character oriented.
76 vfwprintf 53 #include <stdio.h>
#include <stdarg.h>

#include <wchar.h>
int vfwprintf (FILE *stream, const wchar_t *format va_list arg);
  1. If field width is defined with decimal number, the length of output character is less than that decimal number, a `0' flag is not included in conversion specification and a `-' is not included in conversion specification, verify this function pads with spaces on the left.
  2. If field width is defined with decimal number, the length of output character is less than that decimal number, and a `-' is included in conversion specification, verify this function pads with spaces on the right whether a `0' flag is included in conversion specification or not.
  3. If field width is defined with decimal number, the conversion specifier is `d', `i', `o', `u', `x', `X', `e', `E', `f', `g' or `G', the length of output character is less than that decimal number, a `0' flag is included in conversion specification, and a `-' is not included in conversion specification, verify this function padded with the wide character 0 on the left.
  4. If field width is defined with decimal number and the length of output character is more than that decimal number, verify this function outputs the whole conversion results.
  5. Check this function ignores a `0' flag when the conversion specifier is `d', `i', `o', `u', `x' or `X' and conversion specification includes precision.
  6. Check the sign and base precedes the padded 0 when a `0' flag is given.
  7. If field width is given in *, verify an argument of type int supplies the field width.
  8. If precision is defined with decimal number and the conversion specifier is `d', `i', `o', `u', `x' or `X', verify the precision is interpreted as the minimum number of digits to appear.
  9. If precision is defined with decimal number and the conversion specifier is `e', `E' or `f', verify the precision is interpreted as the number of digits to appears after the radix character.
  10. If precision is defined with decimal number and the conversion specifier is `g' or `G', verify the precision is interpreted as the maximum number of significant digits.
  11. If precision is defined with decimal number and the conversion specifier is `s', verify the precision is interpreted as the maximum number of wide characters to be printed.
  12. If precision is given in *, verify an argument of type int supplies the precision.
  13. If precision is formed only .(period) into, verify precision is treated as 0.
  14. If a `+' flag is included in conversion specification, verify the result of a signed conversion begins with a sign(+ or -).
  15. If a `'(space) flag is included in conversion specification, verify the result of a signed conversion begins with a space when the first wide character of the conversion results is not a sign or a signed conversion results in no wide characters.
  16. If a `#' is included in conversion specification and the conversion specifier is `o', verify the result of a conversion begins with a 0.
  17. If a `#' is included in conversion specification and the conversion specifier is `x' or `X', verify the result of a conversion begins with a 0x or 0X.
  18. If a `#' is included in conversion specification and the conversion specifier is `e', `E', `f', `g' or `G', verify the result of a conversion includes the radix character.
  19. If a `#' is included in conversion specification and the conversion specifier is `g' or `G', verify the trailing zeros after radix character is not removed from the results.
  20. If a conversion specifier is `d' or `i', verify the int argument is converted to a signed decimal format.
  21. If a conversion specifier is `d' or `i' and the precision is more than the number of digits, verify the conversion results is expanded with leading 0.
  22. If a conversion specifier is `u', verify the unsigned int argument is converted to a unsigned decimal format.
  23. If a conversion specifier is `u' and the precision is more than the number of digits, verify the conversion results is expanded with leading 0.
  24. If a conversion specifier is `o', verify the unsigned int argument is converted to a unsigned octal format.
  25. If a conversion specifier is `o' and the precision is more than the number of digits, verify the conversion results is expanded with leading 0.
  26. If a conversion specifier is `x', verify the unsigned int argument is converted to a unsigned hexadecimal format (the letters `abcdef' are used).
  27. If a conversion specifier is `X', verify the unsigned int argument is converted to a unsigned hexadecimal format (the letters `ABCDEF' are used).
  28. If a conversion specifier is `x' or `X', and the precision is more than the number of digits, verify the conversion results is expanded with leading 0.
  29. If a conversion specifier is `f', verify the double argument is converted to decimal notation in the style [-]ddd.ddd. Especially check the radix character is according to the current locale.
  30. If a conversion specifier is `f' and the precision is not defined, verify the precision is taken as 6.
  31. If a conversion specifier is `f', the precision is 0 and a `#' flag is not included in conversion specification, verify no radix character appears.
  32. If a conversion specifier is `e', verify the double argument is converted in the style [-]d.ddde+(or -)dd. Especially check the radix character is according to the current locale.
  33. If a conversion specifier is `E', verify the double argument is converted in the style [-]d.dddE+(or -)dd. Especially check the radix character is according to the current locale.
  34. If a conversion specifier is `e' or `E' and the precision is not defined, verify precision is taken as 6.
  35. If a conversion specifier is `e' or `E', the precision is 0 and a `#' flag is not included in conversion specification, verify no radix character appears.
  36. When a conversion specifier is `g', if the exponent of the conversion results is less than -4 or greater than or equal to precision, verify the double argument is converted as same style as `e'. (But if precision is 0, it is taken as 1.) Especially check the radix character is according to the current locale.
  37. When a conversion specifier is `G', and if the exponent of the conversion results is less than -4 or greater than or equal to precision, verify the double argument is converted as same style as `E'. (But if precision is 0, it is taken as 1.) Especially check the radix character is according to the current locale.
  38. When a conversion specifier is `g' or `G', and if the exponent of the conversion results is greater than or equal to -4 and less than precision, verify the double argument is converted as same style as `f'. (But if precision is 0, it is taken as 1.)
  39. If a conversion specifier is `g' or `G', verify the trailing 0 are removed from the fractional portion of the results.
  40. If a conversion specifier is `g' or `G', verify a radix character is appears only when it follows digits.
  41. If a conversion specifier is `c' and no `l' specifier is present, verify the int argument is converted to a wide character as if by calling the btowc() the resulting wide character is written.
  42. If a conversion specifier is `c' and `l' specifier is present, verify the wint_t argument is written after converting wchar_t argument.
  43. When a conversion specifier is `s' and no `l' specifier is present, and if the precision is less than or equal to the length of the converted wide character, verify a multibyte character string starting at a pointer to character given by the argument is converted to a wide character string as if by calling the mbsrtowcs() function with initial conversion state and the wide characters, which are the top of string and which length is as same as the precision, are written.
  44. When a conversion specifier is `s' and no `l' specifier is present, and if the precision is more than the length of the converted wide character, verify a multibyte character string starting at a pointer to character given by the argument is converted to a wide character string as if by calling the mbsrtowcs() function with initial conversion state and the wide character string is written.
  45. When a conversion specifier is `s' and `l' specifier is present, and if the precision is less than or equal to the length of the converted wide character, verify the wide characters, which are the top of the string starting at a point to wide character given by the argument and which length is as same as the precision, are written.
  46. When a conversion specifier is `s' and `l' specifier is present, and the precision is more than the length of the converted wide character, verify a wide character string starting at a pointer to wide character given by the argument is written.
  47. If a conversion specifier is `p', verify the argument which is a pointer to void is converted to a sequence of printable wide characters.
  48. If a conversion specifier is `n', verify this function stores the number of the wide character, which the function has written, to the pointer to an integer which is given by the argument.
  49. If a conversion specifier is `%', verify this function output a % wide character.
  50. If an output error is occurred, verify this function returns negative value.
  51. If no output error is occurred, verify this function returns the number of the written wide characters.
  52. Verify the limits of conversion character is at least 509.
  53. After executing this function correctly, verify the stream is changed to wide character oriented.
77 vswprintf 52 #include <stdarg.h>
#include <wchar.h>
int vswprintf (wchar_t *s, size_t n, const wchar_t *format, va_list arg);
  1. If field width is defined with decimal number, the length of output character is less than that decimal number, a `0' flag is not included in conversion specification and a `-' is not included in conversion specification, verify this function pads with spaces on the left.
  2. If field width is defined with decimal number, the length of output character is less than that decimal number, and a `-' is included in conversion specification, verify this function pads with spaces on the right whether a `0' flag is included in conversion specification or not.
  3. If field width is defined with decimal number, the conversion specifier is `d', `i', `o', `u', `x', `X', `e', `E', `f', `g' or `G', the length of output character is less than that decimal number, a `0' flag is included in conversion specification, and a `-' is not included in conversion specification, verify this function padded with the wide character 0 on the left.
  4. If field width is defined with decimal number and the length of output character is more than that decimal number, verify this function outputs the whole conversion results.
  5. Check this function ignores a `0' flag when the conversion specifier is `d', `i', `o', `u', `x' or `X' and conversion specification includes precision.
  6. Check the sign and base precedes the padded 0 when a `0' flag is given.
  7. If field width is given in *, verify an argument of type int supplies the field width.
  8. If precision is defined with decimal number and the conversion specifier is `d', `i', `o', `u', `x' or `X', verify the precision is interpreted as the minimum number of digits to appear.
  9. If precision is defined with decimal number and the conversion specifier is `e', `E' or `f', verify the precision is interpreted as the number of digits to appears after the radix character.
  10. If precision is defined with decimal number and the conversion specifier is `g' or `G', verify the precision is interpreted as the maximum number of significant digits.
  11. If precision is defined with decimal number and the conversion specifier is `s', verify the precision is interpreted as the maximum number of wide characters to be printed.
  12. If precision is given in *, verify an argument of type int supplies the precision.
  13. If precision is formed only .(period) into, verify precision is treated as 0.
  14. If a `+' flag is included in conversion specification, verify the result of a signed conversion begins with a sign(+ or -).
  15. If a `'(space) flag is included in conversion specification, verify the result of a signed conversion begins with a space when the first wide character of the conversion results is not a sign or a signed conversion results in no wide characters.
  16. If a `#' is included in conversion specification and the conversion specifier is `o', verify the result of a conversion begins with a 0.
  17. If a `#' is included in conversion specification and the conversion specifier is `x' or `X', verify the result of a conversion begins with a 0x or 0X.
  18. If a `#' is included in conversion specification and the conversion specifier is `e', `E', `f', `g' or `G', verify the result of a conversion includes the radix character.
  19. If a `#' is included in conversion specification and the conversion specifier is `g' or `G', verify the trailing zeros after radix character is not removed from the results.
  20. If a conversion specifier is `d' or `i', verify the int argument is converted to a signed decimal format.
  21. If a conversion specifier is `d' or `i' and the precision is more than the number of digits, verify the conversion results is expanded with leading 0.
  22. If a conversion specifier is `u', verify the unsigned int argument is converted to a unsigned decimal format.
  23. If a conversion specifier is `u' and the precision is more than the number of digits, verify the conversion results is expanded with leading 0.
  24. If a conversion specifier is `o', verify the unsigned int argument is converted to a unsigned octal format.
  25. If a conversion specifier is `o' and the precision is more than the number of digits, verify the conversion results is expanded with leading 0.
  26. If a conversion specifier is `x', verify the unsigned int argument is converted to a unsigned hexadecimal format (the letters `abcdef' are used).
  27. If a conversion specifier is `X', verify the unsigned int argument is converted to a unsigned hexadecimal format (the letters `ABCDEF' are used).
  28. If a conversion specifier is `x' or `X', and the precision is more than the number of digits, verify the conversion results is expanded with leading 0.
  29. If a conversion specifier is `f', verify the double argument is converted to decimal notation in the style [-]ddd.ddd. Especially check the radix character is according to the current locale.
  30. If a conversion specifier is `f' and the precision is not defined, verify the precision is taken as 6.
  31. If a conversion specifier is `f', the precision is 0 and a `#' flag is not included in conversion specification, verify no radix character appears.
  32. If a conversion specifier is `e', verify the double argument is converted in the style [-]d.ddde+(or -)dd. Especially check the radix character is according to the current locale.
  33. If a conversion specifier is `E', verify the double argument is converted in the style [-]d.dddE+(or -)dd. Especially check the radix character is according to the current locale.
  34. If a conversion specifier is `e' or `E' and the precision is not defined, verify precision is taken as 6.
  35. If a conversion specifier is `e' or `E', the precision is 0 and a `#' flag is not included in conversion specification, verify no radix character appears.
  36. When a conversion specifier is `g', if the exponent of the conversion results is less than -4 or greater than or equal to precision, verify the double argument is converted as same style as `e'. (But if precision is 0, it is taken as 1.) Especially check the radix character is according to the current locale.
  37. When a conversion specifier is `G', and if the exponent of the conversion results is less than -4 or greater than or equal to precision, verify the double argument is converted as same style as `E'. (But if precision is 0, it is taken as 1.) Especially check the radix character is according to the current locale.
  38. When a conversion specifier is `g' or `G', and if the exponent of the conversion results is greater than or equal to -4 and less than precision, verify the double argument is converted as same style as `f'. (But if precision is 0, it is taken as 1.)
  39. If a conversion specifier is `g' or `G', verify the trailing 0 are removed from the fractional portion of the results.
  40. If a conversion specifier is `g' or `G', verify a radix character is appears only when it follows digits.
  41. If a conversion specifier is `c' and no `l' specifier is present, verify the int argument is converted to a wide character as if by calling the btowc() the resulting wide character is written.
  42. If a conversion specifier is `c' and `l' specifier is present, verify the wint_t argument is written after converting wchar_t argument.
  43. When a conversion specifier is `s' and no `l' specifier is present, and if the precision is less than or equal to the length of the converted wide character, verify a multibyte character string starting at a pointer to character given by the argument is converted to a wide character string as if by calling the mbsrtowcs() function with initial conversion state and the wide characters, which are the top of string and which length is as same as the precision, are written.
  44. When a conversion specifier is `s' and no `l' specifier is present, and if the precision is more than the length of the converted wide character, verify a multibyte character string starting at a pointer to character given by the argument is converted to a wide character string as if by calling the mbsrtowcs() function with initial conversion state and the wide character string is written. Especially check the null wide character is stood at the end of wide character string.
  45. When a conversion specifier is `s' and `l' specifier is present, and if the precision is less than or equal to the length of the converted wide character, verify the wide characters, which are the top of the string starting at a point to wide character given by the argument and which length is as same as the precision, are written.
  46. When a conversion specifier is `s' and `l' specifier is present, and the precision is more than the length of the converted wide character, verify a wide character string starting at a pointer to wide character given by the argument is written. Especially check the null wide character is stood at the end of wide character string.
  47. If a conversion specifier is `p', verify the argument which is a pointer to void is converted to a sequence of printable wide characters.
  48. If a conversion specifier is `n', verify this function stores the number of the wide character, which the function has written, to the pointer to an integer which is given by the argument.
  49. If a conversion specifier is `%', verify this function output a % wide character.
  50. If the total length of the wide character which is made by conversion is more than n (including the terminating null wide character), verify this function returns negative value and outputs only n wide character.
  51. If no output error is occurred, verify this function returns the number of the written wide characters (excluding the terminating null wide character).
  52. Verify the limits of conversion character is at least 509.
78 locale.h 2
  1. Check the following structure is defined:
    lconv
  2. Check the following functions are declared:
    setlocale() localeconv()
79 wchar.h 4
  1. Check the following data types are defined:
    wchar_t wint_t size_t mbstate_t
  2. Check the following structure is defined (but incompletely):
    tm
  3. Check the following macros are defined:
    NULL WEOF WCHAR_MAX WCHAR_MIN
  4. Check the following functions are declared:
    fwprintf() fwscanf() wprintf() wscanf() swprintf() swscanf() vfwprintf() vwprintf() vswprintf()
    fgetwc() fgetws() fputwc() fputws() getwc() getwchar() putwc() putwchar() ungetwc() fwide()
    wcstod() wcstol() wcstoul() wcscpy() wcsncpy() wcscat() wcsncat() wcscmp() wcsncmp() wcsxfrm()
    wcschr() wcscspn() wcspbrk() wcsrchr() wcsspn() wcsstr() wcstok() wcslen()
    wmemchr() wmemcmp() wmemcpy() wmemmove() wmemset() wcsftime()
    btowc() wctob() mbsinit() mbrlen() mbrtowc() wcrtomb() mbsrtowcs() wcsrtombs()
80 wctype.h 3
  1. Check the following data types are defined:
    wint_t wctrans_t wctype_t
  2. Check the following macro is defined:
    WEOF
  3. Check the following functions are declared:
    iswalnum() iswalpha() iswcntrl() iswdigit() iswgraph() iswlower() iswprint() iswpunct() iswspace() iswupper() iswxdigit()
    wctype() iswctype() towlower() towupper() wctrans() towctrans()
printf/scanf family functions (Ref. [ISO C])
81 scanf 6 #include <stdio.h>
int scanf (const char *format, ...);
  1. If format has `e', `E', `f', `g' or `G' flag, verify this function correctly interprets the radix character according to the current locale.
  2. If a conversion character is `c' and conversion specification has `l', verify this function reads a sequence of the multibyte characters of the number specified by the field width, and stores the wide character sequence as same that are made of the sequence of the multibyte characters by mbsrtowcs() with initial conversion state.
  3. If a conversion character is `s' and conversion specification has `l', verify this function reads a multibyte character string, and stores the wide character string as same that are made of the multibyte character string by mbsrtowcs() with initial conversion state. Especially check the null wide character is stood at the end of the wide character string.
  4. If the conversion specifier is `l[ ]', verify this function reads a sequence of bytes which is included between `[' and `]', and stores the wide character sequence as same as that are made of the sequence of the multibyte characters by mbsrtowcs() with initial conversion state. Especially check the null wide character is stood at the end of the wide character string.
  5. If the conversion specifier is `l[^ ]', verify this function reads a sequence of bytes which is not included between `[^' and `]', and stores the wide character sequence as same as that are made of the sequence of the multibyte characters by mbsrtowcs() with initial conversion state. Especially check the null wide character is stood at the end of the wide character string.
  6. After executing this function correctly, verify the standard input is changed to byte oriented.
82 fscanf 6 #include <stdio.h>
int fscanf (FILE *stream, const char *format, ...);
  1. If format has `e', `E', `f', `g' or `G' flag, verify this function correctly interprets the radix character according to the current locale.
  2. If a conversion character is `c' and conversion specification has `l', verify this function reads a sequence of the multibyte characters of the number specified by the field width, and stores the wide character sequence as same that are made of the sequence of the multibyte characters by mbsrtowcs() with initial conversion state.
  3. If a conversion character is `s' and conversion specification has `l', verify this function reads a multibyte character string, and stores the wide character string as same that are made of the multibyte character string by mbsrtowcs() with initial conversion state. Especially check the null wide character is stood at the end of the wide character string.
  4. If the conversion specifier is `l[ ]', verify this function reads a sequence of bytes which is included between `[' and `]', and stores the wide character sequence as same as that are made of the sequence of the multibyte characters by mbsrtowcs() with initial conversion state. Especially check the null wide character is stood at the end of the wide character string.
  5. If the conversion specifier is `l[^ ]', verify this function reads a sequence of bytes which is not included between `[^' and `]', and stores the wide character sequence as same as that are made of the sequence of the multibyte characters by mbsrtowcs() with initial conversion state. Especially check the null wide character is stood at the end of the wide character string.
  6. After executing this function correctly, verify the stream is changed to byte oriented.
83 sscanf 5 #include <stdio.h>
int sscanf (const char *s, const char *format, ...);
  1. If format has `e', `E', `f', `g' or `G' flag, verify this function correctly interprets the radix character according to the current locale.
  2. If a conversion character is `c' and conversion specification has `l', verify this function reads a sequence of the multibyte characters of the number specified by the field width, and stores the wide character sequence as same that are made of the sequence of the multibyte characters by mbsrtowcs() with initial conversion state.
  3. If a conversion character is `s' and conversion specification has `l', verify this function reads a multibyte character string, and stores the wide character string as same that are made of the multibyte character string by mbsrtowcs() with initial conversion state. Especially check the null wide character is stood at the end of the wide character string.
  4. If the conversion specifier is `l[ ]', verify this function reads a sequence of bytes which is included between `[' and `]', and stores the wide character sequence as same as that are made of the sequence of the multibyte characters by mbsrtowcs() with initial conversion state. Especially check the null wide character is stood at the end of the wide character string.
  5. If the conversion specifier is `l[^ ]', verify this function reads a sequence of bytes which is not included between `[^' and `]', and stores the wide character sequence as same as that are made of the sequence of the multibyte characters by mbsrtowcs() with initial conversion state. Especially check the null wide character is stood at the end of the wide character string.
84 printf 5 #include <stdio.h>
int printf (const char *format, ...);
  1. If format has `e', `E', `f', `g' or `G' flag, verify the output symbol which shows decimal point changes on the current locale.
  2. If a conversion specifier is `c' and `l' specifier is present, verify the wint_t argument is converted as if by an `ls' conversion specification with no precision and an argument that points to a two element array of type wchar_t, the first element of which contains the wint_t argument to the `ls' conversion specification and the second element contains a null wide character.
  3. When a conversion specifier is `ls', and the precision is less than or equal to the byte length of the converted character, verify a wide characters starting at a pointer to character given by the argument is converted to a multibyte characters as if wcsrtombs() function called with initial conversion state and the converted multibyte characters are written. (Notice: Any bytes which is not formed multibyte character is not written.)
  4. When a conversion specifier is `s' and `l' specifier is present, and if the precision is more than the length of the converted wide character, verify a wide character string starting at a pointer to character given by the argument is converted to a multibyte character string as if by calling the wcsrtombs() function with initial conversion state and the the multibyte character string is written.
  5. After executing this function correctly, verify the standard out is changed to byte oriented.
85 fprintf 5 #include <stdio.h>
int fprintf (FILE *stream, const char *format, ...);
  1. If format has `e', `E', `f', `g' or `G' flag, verify the output symbol which shows decimal point changes on the current locale.
  2. If a conversion specifier is `c' and `l' specifier is present, verify the wint_t argument is converted as if by an `ls' conversion specification with no precision and an argument that points to a two element array of type wchar_t, the first element of which contains the wint_t argument to the `ls' conversion specification and the second element contains a null wide character.
  3. When a conversion specifier is `ls', and the precision is less than or equal to the byte length of the converted character, verify a wide characters starting at a pointer to character given by the argument is converted to a multibyte characters as if wcsrtombs() function called with initial conversion state and the converted multibyte characters are written. (Notice: Any bytes which is not formed multibyte character is not written.)
  4. When a conversion specifier is `s' and `l' specifier is present, and if the precision is more than the length of the converted wide character, verify a wide character string starting at a pointer to character given by the argument is converted to a multibyte character string as if by calling the wcsrtombs() function with initial conversion state and the the multibyte character string is written.
  5. After executing this function correctly, the stream is changed to byte oriented.
86 sprintf 4 #include <stdio.h>
int sprintf (char *s, const char *format, ...);
  1. If format has `e', `E', `f', `g' or `G' flag, verify the output symbol which shows decimal point changes on the current locale.
  2. If a conversion specifier is `c' and `l' specifier is present, verify the wint_t argument is converted as if by an `ls' conversion specification with no precision and an argument that points to a two element array of type wchar_t, the first element of which contains the wint_t argument to the `ls' conversion specification and the second element contains a null wide character.
  3. When a conversion specifier is `ls', and the precision is less than or equal to the byte length of the converted character, verify a wide characters starting at a pointer to character given by the argument is converted to a multibyte characters as if wcsrtombs() function called with initial conversion state and the converted multibyte characters are written. (Notice: Any bytes which is not formed multibyte character is not written.)
  4. When a conversion specifier is `s' and `l' specifier is present, and if the precision is more than the length of the converted wide character, verify a wide character string starting at a pointer to character given by the argument is converted to a multibyte character string as if by calling the wcsrtombs() function with initial conversion state and the the multibyte character string is written. Especially check the null character is stood at the end of wide character string.
87 vprintf 5 #include <stdio.h>
#include <stdarg.h>

int vprintf (const char *format, va_list arg);
  1. If format has `e', `E', `f', `g' or `G' flag, verify the output symbol which shows decimal point changes on the current locale.
  2. If a conversion specifier is `c' and `l' specifier is present, verify the wint_t argument is converted as if by an `ls' conversion specification with no precision and an argument that points to a two element array of type wchar_t, the first element of which contains the wint_t argument to the `ls' conversion specification and the second element contains a null wide character.
  3. When a conversion specifier is `ls', and the precision is less than or equal to the byte length of the converted character, verify a wide characters starting at a pointer to character given by the argument is converted to a multibyte characters as if wcsrtombs() function called with initial conversion state and the converted multibyte characters are written. (Notice: Any bytes which is not formed multibyte character is not written.)
  4. When a conversion specifier is `s' and `l' specifier is present, and if the precision is more than the length of the converted wide character, verify a wide character string starting at a pointer to character given by the argument is converted to a multibyte character string as if by calling the wcsrtombs() function with initial conversion state and the the multibyte character string is written.
  5. After executing this function correctly, verify the standard output is changed to byte oriented.
88 vfprintf 5 #include <stdio.h>
#include <stdarg.h>

int vfprintf (FILE *stream, const char *format, va_list arg);
  1. If format has `e', `E', `f', `g' or `G' flag, verify the output symbol which shows decimal point changes on the current locale.
  2. If a conversion specifier is `c' and `l' specifier is present, verify the wint_t argument is converted as if by an `ls' conversion specification with no precision and an argument that points to a two element array of type wchar_t, the first element of which contains the wint_t argument to the `ls' conversion specification and the second element contains a null wide character.
  3. When a conversion specifier is `ls', and the precision is less than or equal to the byte length of the converted character, verify a wide characters starting at a pointer to character given by the argument is converted to a multibyte characters as if wcsrtombs() function called with initial conversion state and the converted multibyte characters are written. (Notice: Any bytes which is not formed multibyte character is not written.)
  4. When a conversion specifier is `s' and `l' specifier is present, and if the precision is more than the length of the converted wide character, verify a wide character string starting at a pointer to character given by the argument is converted to a multibyte character string as if by calling the wcsrtombs() function with initial conversion state and the the multibyte character string is written.
  5. After executing this function correctly, verify the stream is changed to byte oriented.
89 vsprintf 4 #include <stdio.h>
#include <stdarg.h>

int vsprintf (char *s, const char *format, va_list arg);
  1. If format has `e', `E', `f', `g' or `G' flag, verify the output symbol which shows decimal point changes on the current locale.
  2. If a conversion specifier is `c' and `l' specifier is present, verify the wint_t argument is converted as if by an `ls' conversion specification with no precision and an argument that points to a two element array of type wchar_t, the first element of which contains the wint_t argument to the `ls' conversion specification and the second element contains a null wide character.
  3. When a conversion specifier is `ls', and the precision is less than or equal to the byte length of the converted character, verify a wide characters starting at a pointer to character given by the argument is converted to a multibyte characters as if wcsrtombs() function called with initial conversion state and the converted multibyte characters are written. (Notice: Any bytes which is not formed multibyte character is not written.)
  4. When a conversion specifier is `s' and `l' specifier is present, and if the precision is more than the length of the converted wide character, verify a wide character string starting at a pointer to character given by the argument is converted to a multibyte character string as if by calling the wcsrtombs() function with initial conversion state and the the multibyte character string is written. Especially check the null character is stood at the end of wide character string.
Additional C language internationalization functions (Ref. [XSH5])
90 catopen 6 #include <nl_types.h>
nl_catd catopen (const char *name, int oflag);
  1. When this function is executed successfully, verify this function returns a message catalog descriptor.
  2. When this function is not executed successfully, verify this function returns (nl_catd)-1 and sets errno to indicate the error.
  3. If name contains a "/", verify the pathname specifies a complete name for the message catalog.
  4. If name does not have "/" on its head, verify the environment variable NLSPATH is used to the path name.
  5. If the value of the oflag argument is 0, verify the LANG environment variable is used to locate the catalog without regard to the LC_MESSAGES category.
  6. If the oflag argument is NL_CAT_LOCALE, verify the LC_MESSAGES category is used to locate the message catalog.
91 catgets 2 #include <nl_types.h>
char *catgets (nl_catd catd, int set_id, int msg_id, const char *s);
  1. If the call is successful, verify this function returns a pointer to an internal buffer area containing the null-terminated message string.
  2. If the call is unsuccessful for any reason, verify s is returned and errno may be set to indicate the error.
92 catclose 2 #include <nl_types.h>
int catclose (nl_catd catd);
  1. If the call is successful, verify this function returns 0.
  2. If the call is unsuccessful for any reason, verify this function returns -1, and errno is set to indicate the error.
93 iconv_open 3 #include <iconv.h>
iconv_t iconv_open (const char *tocode, const char *fromcode);
  1. If the call is successful, verify this function returns conversion descriptor for use on subsequent calls to iconv().
  2. If the call is unsuccessful for any reason, verify this function returns (iconv_t)-1 and sets errno to indicate the error.
  3. If a file descriptor is used to implement conversion descriptors, verify the FD_CLOEXEC flag will be set.
94 iconv 4 #include <iconv.h>
size_t iconv (iconv_t cd, const char **inbuf, size_t *inbytesleft, char **outbuf, size_t *outbytesleft);
  1. If this function converts the entire string in the input buffer, verify the value pointed to by inbytesleft will be 0.
  2. If the input conversion is stopped, verify the value pointed to by inbytesleft will be non-zero and errno is set to indicate the condition.
  3. If an error occurs, verify this function returns (size_t)-1 and sets errno to indicate the error.
  4. If the output buffer is not large enough to hold the entire reset sequence, verify iconv() will fail and set errno to [E2BIG].
95 iconv_close 3 #include <iconv.h>
iconv_t iconv_close (iconv_t cd);
  1. If the call is successful, verify this function returns 0.
  2. If the call is unsuccessful for any reason, verify this function returns -1, and errno is set to indicate the error.
  3. If a file descriptor is used to implement the type iconv_t, verify that file descriptor will be closed.
96 nl_langinfo 59 #include <langinfo.h>
char *nl_langinfo (nl_item item);
  1. If item is CODESET, verify this function returns a pointer to a string which shows codeset name.
  2. If item is D_T_FMT, verify this function returns a pointer to a string which shows formatting date and time.
  3. If item is D_FMT, verify this function returns a pointer to a string which shows a date format string.
  4. If item is T_FMT, verify this function returns a pointer to a string which shows time format string.
  5. If item is T_FMT_AMPM, verify this function returns a pointer to a string which shows a.m. or p.m. time format string.
  6. If item is AM_STR, verify this function returns a pointer to a string which shows Ante Meridian affix.
  7. If item is PM_STR, verify this function returns a pointer to a string which shows Post Meridian affix.
  8. If item is DAY_1, verify this function returns a pointer to a string which shows name of the first day of the week.
  9. If item is DAY_2, verify this function returns a pointer to a string which shows name of the second day of the week.
  10. If item is DAY_3, verify this function returns a pointer to a string which shows name of the third day of the week.
  11. If item is DAY_4, verify this function returns a pointer to a string which shows name of the fourth day of the week.
  12. If item is DAY_5, verify this function returns a pointer to a string which shows name of the fifth day of the week.
  13. If item is DAY_6, verify this function returns a pointer to a string which shows name of the sixth day of the week.
  14. If item is DAY_7, verify this function returns a pointer to a string which shows name of the seventh day of the week.
  15. If item is ABDAY_1, verify this function returns a pointer to a string which shows abbreviated name of the first day of the week.
  16. If item is ABDAY_2, verify this function returns a pointer to a string which shows abbreviated name of the second day of the week.
  17. If item is ABDAY_3, verify this function returns a pointer to a string which shows abbreviated name of the third day of the week.
  18. If item is ABDAY_4, verify this function returns a pointer to a string which shows abbreviated name of the fourth day of the week.
  19. If item is ABDAY_5, verify this function returns a pointer to a string which shows abbreviated name of the fifth day of the week.
  20. If item is ABDAY_6, verify this function returns a pointer to a string which shows abbreviated name of the sixth day of the week.
  21. If item is ABDAY_7, verify this function returns a pointer to a string which shows abbreviated name of the seventh day of the week.
  22. If item is MON_1, verify this function returns a pointer to a string which shows a string which shows name of the first month of the year.
  23. If item is MON_2, verify this function returns a pointer to a string which shows a name of the second month.
  24. If item is MON_3, verify this function returns a pointer to a string which shows a name of the third month.
  25. If item is MON_4, verify this function returns a pointer to a string which shows a name of the fourth month.
  26. If item is MON_5, verify this function returns a pointer to a string which shows a name of the fifth month.
  27. If item is MON_6, verify this function returns a pointer to a string which shows a name of the sixth month.
  28. If item is MON_7, verify this function returns a pointer to a string which shows a name of the seventh month.
  29. If item is MON_8, verify this function returns a pointer to a string which shows a name of the eighth month.
  30. If item is MON_9, verify this function returns a pointer to a string which shows a name of the ninth month.
  31. If item is MON_10, verify this function returns a pointer to a string which shows a name of the tenth month.
  32. If item is MON_11, verify this function returns a pointer to a string which shows a name of the eleventh month.
  33. If item is MON_12, verify this function returns a pointer to a string which shows a name of the twelfth month.
  34. If item is ABMON_1, verify this function returns a pointer to a string which shows a abbreviated name of the first month.
  35. If item is ABMON_2, verify this function returns a pointer to a string which shows a abbreviated name of the second month.
  36. If item is ABMON_3, verify this function returns a pointer to a string which shows a abbreviated name of the third month.
  37. If item is ABMON_4, verify this function returns a pointer to a string which shows a abbreviated name of the fourth month.
  38. If item is ABMON_5, verify this function returns a pointer to a string which shows a abbreviated name of the fifth month.
  39. If item is ABMON_6, verify this function returns a pointer to a string which shows a abbreviated name of the sixth month.
  40. If item is ABMON_7, verify this function returns a pointer to a string which shows a abbreviated name of the seventh month.
  41. If item is ABMON_8, verify this function returns a pointer to a string which shows a abbreviated name of the eighth month.
  42. If item is ABMON_9, verify this function returns a pointer to a string which shows a abbreviated name of the ninth month.
  43. If item is ABMON_10, verify this function returns a pointer to a string which shows a abbreviated name of the tenth month.
  44. If item is ABMON_11, verify this function returns a pointer to a string which shows a abbreviated name of the eleventh month.
  45. If item is ABMON_12, verify this function returns a pointer to a string which shows a abbreviated name of the twelfth month.
  46. If item is ERA, verify this function returns a pointer to a string which shows a era description segments.
  47. If item is ERA_D_FMT, verify this function returns a pointer to a string which shows a era date format string.
  48. If item is ERA_D_T_FMT, verify this function returns a pointer to a string which shows a era date and time format string.
  49. If item is ERA_T_FMT, verify this function returns a pointer to a string which shows a era time format string.
  50. If item is ALT_DIGITS, verify this function returns a pointer to a string which shows a alternative symbols for digits.
  51. If item is RADIXCHAR, verify this function returns a pointer to a string which shows a radix character.
  52. If item is THOUSEP, verify this function returns a pointer to a string which shows a separator for thousands.
  53. If item is YESEXPR, verify this function returns a pointer to a string which shows a affirmative response expression.
  54. If item is NOEXPR, verify this function returns a pointer to a string which shows a negative response expression.
  55. If item is YESSTR, verify this function returns a pointer to a string which shows a affirmative response for yes/no queries.
  56. If item is NOSTR, verify this function returns a pointer to a string which shows a negative response for yes/no queries.
  57. If item is CRNCYSTR, verify this function returns a pointer to a string which shows a currency symbol, preceded by - if the symbol should appear before the value, + if the symbol should appear after the value, or . if the symbol should replace the radix character.
  58. If the langinfo data is not defined on the current locale, verify this function returns a pointer to the corresponding string in the POSIX locale against each item.
  59. Verify this function returns a pointer to an empty string if item contains an invalid setting.
97 strfmon 20 #include <monetary.h>
ssize_t strfmon (char *s, size_t maxsize, const char format, ...);
  1. If a flag =c is given, verify this function uses c as the numeric fill character.
  2. If a flag =c is not given, verify this function uses space character as the numeric fill character.
  3. If a flag ^ is given, verify this function do not format the currency amount with grouping characters.
  4. If a flag ^ is not given, verify this function insert the grouping characters if defined for the current locale.
  5. If a flag + is given, verify this function sets the locale's equivalent of + and - for the style of representing positive and negative currency amounts.
  6. If a flag ( is given, verify this function sets negative amounts are enclosed within parentheses for the style of representing positive and negative currency amounts.
  7. If neither + nor ( is given, verify this function sets the locale's equivalent of + and - for the style of representing positive and negative currency amounts.
  8. If a flag ! is given, verify this function suppresses the currency symbol from the output conversion.
  9. If a flag - is given, verify this function all fields are left-justified (padded to the right) rather than right-justified.
  10. Verify this function replaces conversion specifier w with decimal digit string which shows minimum field width in bytes in which the result of the conversion is right-justified (or left-justified if the flag - is specified).
  11. If a flag w is not defined, The field width is 0.
  12. If a flag #n (n is a maximum number of digits) is given, verify this function formats to the left of the radix character.
  13. If a flag #n (n is a maximum number of digits) is given, and grouping has not been suppressed with the ^ flag, grouping separators are inserted before the fill characters (if any) are added.
  14. If a flag .n (n is the number of digits after the radix character) is given and n is 0, no radix character appears.
  15. If a flag .n (n is the number of digits after the radix character) is given and the value of the right precision n is non-zero, the amount being formatted is rounded to the specified number of digits prior to formatting.
  16. Verify this function replaces conversion specifier i with the double argument is formatted according to the locale's international currency format.
  17. Verify this function replaces conversion specifier n with the double argument is formatted according to the locale's national currency format.
  18. Verify this function replaces conversion specifier % with a %.
  19. If the call is successful and the total number of resulting bytes including the terminating null byte is not more than maxsize, verify this function returns the number of bytes replaced into the array pointed to by s, not including the terminating null byte.
  20. If the call is unsuccessful, verify this function returns -1 and errno is set to indicate the error.
98 strptime 44 #include <time.h>
char *strptime (const char *buf, const char *format, struct tm *tm);
  1. If a directive is an ordinary character (i.e. except for %, and whitespace character), verify the next character is read, and compare with the directive and the read one and when they are not equivalent, the directive fails, and the differing and subsequent characters remain unread.
  2. Verify a series of directives composed of `n', `t', whitespace characters or any combination is executed by reading input until no more valid input can be read, or up to the first character that is not whitespace wide character, and which remains unread.
  3. If the conversion character is `a' or `A', verify this function converts the characters which shows either the abbreviated or full weekday name according to the current locale.
  4. If the conversion character is `b', `B' or `h', verify this function converts the characters either the abbreviated or full month name according to the current locale.
  5. If the conversion character is `c', verify this function converts the characters which is the locale's appropriate date and time representation.
  6. If conversion character is `C', verify this function converts the characters which shows the century number.
  7. If the conversion character is `d' or `e', verify this function converts the characters which shows the day of month.
  8. If the conversion character is `D', verify this function converts the characters which shows the date as same style as `%m'/`%d'/`%y'.
  9. If the conversion character is `H', verify this function converts the characters which shows the hour(24-hour clock).
  10. If the conversion character is `I', verify this function converts the characters which shows the hour(12-hour clock).
  11. If the conversion character is `j', verify this function converts the characters which shows the day number of the year.
  12. If the conversion character is `m', verify this function converts the characters which shows the month number.
  13. If the conversion character is `M', verify this function converts the characters which shows the minute.
  14. If the conversion character is `p', verify this function converts the characters which is the locale's equivalent of a.m. or p.m..
  15. If the conversion character is `r', verify this function converts the characters which shows 12-hour clock time using the AM/PM notation.
  16. If the conversion character is `R', verify this function converts the characters which shows the time as `%H:%M'.
  17. If the conversion character is `S', verify this function converts the characters which shows the seconds.
  18. If the conversion character is `T', verify this function converts the characters which shows the theme as `%H:%M:%S'.
  19. If the conversion character is `U', verify this function converts the characters which shows the week number of the year (Sunday as the first day of the week) as a decimal number.
  20. If the conversion character is `w', verify this function converts the characters which shows the weekday as a decimal number, with 0 representing Sunday.
  21. If the conversion character is `W', verify this function converts the characters which shows the week number of the year (Monday as the first day of the week) as a decimal number.
  22. If the conversion character is `x', verify this function converts the characters which shows the date using the locale's date format.
  23. If the conversion character is `X', verify this function converts the characters which shows the time using the locale's time format.
  24. If the conversion character is `y', verify this function converts the characters which shows the year in 2 figure.
  25. If the conversion character is `Y', verify this function converts the characters which shows the year in 4 figure.
  26. If the conversion character is `%' (i.e. the orthography is `%%', verify this function replace with `%'.
  27. If the conversion character is `Ec', verify this function converts the characters which is the locale's alternative appropriate date and time representation.
  28. If the conversion character is `EC', verify this function converts the characters which is the name of the base year (period) in the locale's alternative representation.
  29. If the conversion character is `Ex', verify this function converts the characters which is the locale's alternative date representation.
  30. If the conversion character is `EX', verify this function converts the characters which is the locale's alternative time representation.
  31. If the conversion character is `Ey', verify this function converts the characters which is the offset from `%EC' (year only) in the locale's alternative representation.
  32. If the conversion character is `EY', verify this function converts the characters which is the full alternative year representation.
  33. If the conversion character is `Od' or `Oe', verify this function converts the character which shows the day of the month using the locale's alternative numeric symbols.
  34. If the conversion character is `OH', verify this function converts the character which shows the hour (24-hour clock) using the locale's alternative numeric symbols.
  35. If the conversion character is `OI', verify this function converts the character which shows the hour (12-hour clock) using the locale's alternative numeric symbols.
  36. If the conversion character is `Om', verify this function converts the character which shows the month using the locale's alternative numeric symbols.
  37. If the conversion character is `OM', verify this function converts the character which shows the minutes using the locale's alternative numeric symbols.
  38. If the conversion character is `OS', verify this function converts the character which shows the seconds using the locale's alternative numeric symbols.
  39. If the conversion character is `OU', verify this function converts the character which shows the week number of the year (Sunday as the first day of the week) using the locale's alternative numeric symbols.
  40. If the conversion character is `Ow', verify this function converts the character which shows the number of the weekday (Sunday=0) using the locale's alternative numeric symbols.
  41. If the conversion character is `OW', verify this function converts the character which shows the week number of the year (Monday as the first day of the week) using the locale's alternative numeric symbols.
  42. If the conversion character is `Oy', verify this function converts the character which shows the year (offset from `%C') using the locale's alternative numeric symbols.
  43. If the call is successful, verify this function returns a pointer to the character following the last character parsed.
  44. If the call is unsuccessful, verify this function returns a NULL is returned.
99 wcwidth 3 #include <wchar.h>
int wcwidth (wchar_t wc);
  1. If wc is a null wide character, verify this function either returns 0.
  2. If wc corresponds to a printing wide character, verify this function returns the number of column positions to be occupied by wc.
  3. If wc does not correspond to a printing wide character, this function returns -1.
100 wcswidth 4 #include <wchar.h>
int wcswidth (const wchar_t *pwcs, size_t n);
  1. If pwcs points to a null wide character, verify this function returns 0.
  2. If the first n wide character codes in the wide character string pointed to by pwcs are a printing wide character, verify this function returns the number of column positions to be occupied by the wide character string pointed to by pwcs.
  3. If any of the first n wide character codes in the wide character string pointed to by pwcs is not a printing wide character, verify this function returns -1.
  4. If a null wide character is encountered before n wide character, verify the interpretation is stopped at the null wide character.
101 nl_types.h 3
  1. Check the following data types are defined:
    nl_catd nl_item
  2. Check the following macros are defined:
    NL_SETD NL_CAT_LOCALE
  3. Check the following functions are declared:
    catclose catgets catopen
102 monetary.h 2
  1. Check the following data types are defined:
    size_t ssize_t
  2. Check the following function is declared.
    strfmon
103 langinfo.h 2
  1. Check the following macros are defined in this header, or header included by this header:
    CODESET
    D_T_FMT D_FMT T_FMT T_FMT_AMPM AM_STR PM_STR
    DAY_1 DAY_2 DAY_3 DAY_4 DAY_5 DAY_6 DAY_7
    ABDAY_1 ABDAY_2 ABDAY_3 ABDAY_4 ABDAY_5 ABDAY_6 ABDAY_7
    MON_1 MON_2 MON_3 MON_4 MON_5 MON_6 MON_7 MON_8 MON_9 MON_10 MON_11 MON_12 ABMON_1 ABMON_2 ABMON_3 ABMON_4 ABMON_5 ABMON_6
    ABMON_7 ABMON_8 ABMON_9 ABMON_10 ABMON_11 ABMON_12
    ERA ERA_D_FMT ERA_D_T_FMT ERA_T_FMT ALT_DIGITS
    RADIXCHAR THOUSEP
    YESEXPR NOEXPR YESSTR NOSTR
    CRNCYSTR
  2. Check the following function is declared:
    nl_langinfo
104 iconv.h 2
  1. Check the following data types is defined:
    iconv_t
  2. Check the following functions are declared:
    iconv_open iconv iconv_close
Additional message handling functions (Ref. LSB 1.3 `Interfaces Definitions for libc')
105 gettext 7 #include <libintl.h>
extern char *gettext(const char *msgid);
  1. If LANGUAGE environment variable is defined and the value is a locale name, verify that this function uses the localename to determine the message catalog.
  2. If LANGUAGE environment variable is defined and the value is a list of locale name separated by `:' character, verify that this function searches the message sequentially from the top of that list.
  3. If LANGUAGE environment variable is defined and this function can locate the message according to the msgid, verify that this function returns a pointer to the located message.
  4. If LANGUAGE environment variable is defined and this function cannot locate the message according to the msgid, verify that this function returns msgid.
  5. If LANGUAGE environment variable is not defined, verify that this function searches the message according to the LC_ALL, LC_xxx, and LANG environment variables.
  6. If LANGUAGE environment variable is not defined and this function cannot locate the message according to the LC_ALL, LC_xxx, and LANG environment variables, verify that this function returns msgid.
  7. If the LC_MESSAGES locale category of the current locale is the standard C locale or the standard POSIX locale, verify that this function returns msgid.
106 dgettext 8 #include <libintl.h>
char *dgettext (const char *domainname, const char *msgid);
  1. Verify that this function locates the message according to the string pointed by domainname.
  2. If LANGUAGE environment variable is defined and the value is a locale name, verify that this function uses the localename to determine the message catalog.
  3. If LANGUAGE environment variable is defined and the value is a list of locale name separated by `:' character, verify that this function searches the message sequentially from the top of that list.
  4. If LANGUAGE environment variable is defined and this function can locate the message according to the msgid, verify that this function returns a pointer to the located message.
  5. If LANGUAGE environment variable is defined and this function cannot locate the message according to the msgid, verify that this function returns msgid.
  6. If LANGUAGE environment variable is not defined, verify that this function searches the message according to the LC_ALL, LC_xxx, and LANG environment variables.
  7. If LANGUAGE environment variable is not defined and this function cannot locate the message according to the LC_ALL, LC_xxx, and LANG environment variables, verify that this function returns msgid.
  8. If the LC_MESSAGES locale category of the current locale is the standard C locale or the standard POSIX locale, verify that this function returns msgid.
107 textdomain 7 #include <libintl.h>
char *textdomain (const char *domainname);
  1. When the domainname is not NULL nor the pointer to null string and this function called successfully, verify that the message outputted by gettext family searches the message from domain whose name is domainname.
  2. When the domainname is not NULL nor the pointer to null string and this function called successfully, verify that this functions returns domainname.
  3. When the domainname is NULL and this function called successfully, verify that this function returns the name of current domain.
  4. When the domainname is the pointer to null string and this function called successfully, verify that the current domain is changed to `messages'.
  5. When this function fails, verify that the return value is NULL.
  6. Verify that the domain defined by this function is remained even if gettext family is called.
  7. Verify that the domain defined by this function is remained even if setlocale is called.
108 bindtextdomain 6 #include <libintl.h>
char *bindtextdomain(const char *domainname, const char *dirname);
  1. Verify that this function specifies that the domainname message catalog will be found in the dirname directory hierarchy.
  2. Veirfy that this function applies domainname to the currently active LC_MESSAGES locale.
  3. Verify that this function specifies the message even if the dirname directory is absolute pathname.
  4. Verify that this function specifies the message even if the dirname directory is relative pathname.
  5. When this function specifies the message correctly, verify this function returns the pointer to the string which shows the directory pathname currently bound to the domain.
  6. When this function does not specify the message correctly, verify this function returns NULL.
109 dcgettext 14 #include <libintl.h>
char *dcgettext(const char *domainname, const char *msgid, int category);
  1. Verify that this function locates the message according to the string pointed by domainname.
  2. When category is LC_CTYPE, verify the message catalog file under the LC_CTYPE directory is located.
  3. When category is LC_COLLATE, verify the message catalog file under the LC_COLLATE directory is located.
  4. When category is LC_MESSAGES, verify the message catalog file under the LC_MESSAGES directory is located.
  5. When category is LC_MONETARY, verify the message catalog file under the LC_MONETARY directory is located.
  6. When category is LC_NUMERIC, verify the message catalog file under the LC_NUMERIC directory is located.
  7. When category is LC_TIME, verify the message catalog file under the LC_TIME directory is located.
  8. If LANGUAGE environment variable is defined and the value is a locale name, verify that this function uses the localename to determine the message catalog.
  9. If LANGUAGE environment variable is defined and the value is a list of locale name separated by `:' character, verify that this function searches the message sequentially from the top of that list.
  10. If LANGUAGE environment variable is defined and this function can locate the message according to the msgid, verify that this function returns a pointer to the located message.
  11. If LANGUAGE environment variable is defined and this function cannot locate the message according to the msgid, verify that this function returns msgid.
  12. If LANGUAGE environment variable is not defined, verify that this function searches the message according to the LC_ALL, LC_xxx, and LANG environment variables.
  13. If LANGUAGE environment variable is not defined and this function cannot locate the message according to the LC_ALL, LC_xxx, and LANG environment variables, verify that this function returns msgid.
  14. If the LC_MESSAGES locale category of the current locale is the standard C locale or the standard POSIX locale, verify that this function returns msgid.
110 ngettext 10 #include <libintl.h>
char *ngettext(const char *msgid1, const char *msgid2, unsigned long int n);
  1. If LANGUAGE environment variable is defined and the value is a locale name, verify that this function uses the localename to determine the message catalog.
  2. If LANGUAGE environment variable is defined and the value is a list of locale name separated by `:' character, verify that this function searches the message sequentially from the top of that list.
  3. If LANGUAGE environment variable is defined and this function can locate the message according to the msgid1, verify that this function returns a pointer to the located message.
  4. If LANGUAGE environment variable is defined, the value of n is 1 and this function cannot locate the message according to the msgid1, verify that this function returns msgid1.
  5. If LANGUAGE environment variable is defined, the value of n is not 1 and this function cannot locate the message according to the msgid1, verify that this function returns msgid2.
  6. If LANGUAGE environment variable is not defined, verify that this function searches the message according to the LC_ALL, LC_xxx, and LANG environment variables.
  7. If LANGUAGE environment variable is not defined, the value of n is 1, and this function cannot locate the message according to the LC_ALL, LC_xxx, and LANG environment variables, verify that this function returns msgid1.
  8. If LANGUAGE environment variable is not defined, the value of n is not 1, and this function cannot locate the message according to the LC_ALL, LC_xxx, and LANG environment variables, verify that this function returns msgid2.
  9. If the LC_MESSAGES locale category of the current locale is the standard C locale or the standard POSIX locale and the value of n is 1, verify that this function returns msgid1.
  10. If the LC_MESSAGES locale category of the current locale is the standard C locale or the standard POSIX locale and the value of n is 2, verify that this function returns msgid2.
111 dngettext 11 #include <libintl.h>
char *dngettext(const char *domainname, const char *msgid1, const char *msgid2, unsigned long int n);
  1. Verify that this function locates the message according to the string pointed by domainname.
  2. If LANGUAGE environment variable is defined and the value is a locale name, verify that this function uses the localename to determine the message catalog.
  3. If LANGUAGE environment variable is defined and the value is a list of locale name separated by `:' character, verify that this function searches the message sequentially from the top of that list.
  4. If LANGUAGE environment variable is defined and this function can locate the message according to the msgid1, verify that this function returns a pointer to the located message.
  5. If LANGUAGE environment variable is defined, the value of n is 1 and this function cannot locate the message according to the msgid1, verify that this function returns msgid1.
  6. If LANGUAGE environment variable is defined, the value of n is not 1 and this function cannot locate the message according to the msgid1, verify that this function returns msgid2.
  7. If LANGUAGE environment variable is not defined, verify that this function searches the message according to the LC_ALL, LC_xxx, and LANG environment variables.
  8. If LANGUAGE environment variable is not defined, the value of n is 1, and this function cannot locate the message according to the LC_ALL, LC_xxx, and LANG environment variables, verify that this function returns msgid1.
  9. If LANGUAGE environment variable is not defined, the value of n is not 1, and this function cannot locate the message according to the LC_ALL, LC_xxx, and LANG environment variables, verify that this function returns msgid2.
  10. If the LC_MESSAGES locale category of the current locale is the standard C locale or the standard POSIX locale and the value of n is 1, verify that this function returns msgid1.
  11. If the LC_MESSAGES locale category of the current locale is the standard C locale or the standard POSIX locale and the value of n is 2, verify that this function returns msgid2.
112 dcngettext 17 #include <libintl.h>
char *dcngettext(const char *domainname, const char *msgid1, const char *msgid2, unsigned long int n, int category);
  1. Verify that this function locates the message according to the string pointed by domainname.
  2. When category is LC_CTYPE, verify the message catalog file under the LC_CTYPE directory is located.
  3. When category is LC_COLLATE, verify the message catalog file under the LC_COLLATE directory is located.
  4. When category is LC_MESSAGES, verify the message catalog file under the LC_MESSAGES directory is located.
  5. When category is LC_MONETARY, verify the message catalog file under the LC_MONETARY directory is located.
  6. When category is LC_NUMERIC, verify the message catalog file under the LC_NUMERIC directory is located.
  7. When category is LC_TIME, verify the message catalog file under the LC_TIME directory is located.
  8. If LANGUAGE environment variable is defined and the value is a locale name, verify that this function uses the localename to determine the message catalog.
  9. If LANGUAGE environment variable is defined and the value is a list of locale name separated by `:' character, verify that this function searches the message sequentially from the top of that list.
  10. If LANGUAGE environment variable is defined and this function can locate the message according to the msgid1, verify that this function returns a pointer to the located message.
  11. If LANGUAGE environment variable is defined, the value of n is 1 and this function cannot locate the message according to the msgid1, verify that this function returns msgid1.
  12. If LANGUAGE environment variable is defined, the value of n is not 1 and this function cannot locate the message according to the msgid1, verify that this function returns msgid2.
  13. If LANGUAGE environment variable is not defined, verify that this function searches the message according to the LC_ALL, LC_xxx, and LANG environment variables.
  14. If LANGUAGE environment variable is not defined, the value of n is 1, and this function cannot locate the message according to the LC_ALL, LC_xxx, and LANG environment variables, verify that this function returns msgid1.
  15. If LANGUAGE environment variable is not defined, the value of n is not 1, and this function cannot locate the message according to the LC_ALL, LC_xxx, and LANG environment variables, verify that this function returns msgid2.
  16. If the LC_MESSAGES locale category of the current locale is the standard C locale or the standard POSIX locale and the value of n is 1, verify that this function returns msgid1.
  17. If the LC_MESSAGES locale category of the current locale is the standard C locale or the standard POSIX locale and the value of n is 2, verify that this function returns msgid2.
113 bind_textdomain_codeset 5 #include <libintl.h>
char *bind_textdomain_codeset(const char *domainname, const char *codeset);
  1. When the codeset argument is a valid codeset name which can be used for the iconv_open() function, verify that the codeset of message outputted by gettext family is converted into codeset argument.
  2. When the codeset argument is a valid codeset name which can be used for the iconv_open() function, verify that this function returns a pointer to string which shows the valid codeset argument.
  3. When the codeset argument is NULL and the domain whose name is domainname has been bound with a codeset already, verify that this function returns the bided codeset name.
  4. When the codeset argument is NULL and the domain whose name is domainname has not been binded with a codeset already, verify that this function returns NULL.
  5. When this function applies for the domain whose name is domainname several times, verify that the valid codeset is the latter one.
114 libintl.h 1
  1. Check the following functions are declared:
    gettext dgettext ngettext dngettext textdomain bindtextdomain bind_textdomain_codeset
    dcgettext dcngettext
Additional Wide Character (Interface of libc, LSB1.3)
115 __wcstod_internal 16 double __wcstod_internal(const wchar_t *nptr, wchar_t **endptr, int group);

*) It is assumed that the value of group is always 0, because the behavior is undefined when group is not 0.
  1. Verify that this function ignores first white-space characters at nptr. The white-space characters are the ones whose results applied with iswspace() is true.
  2. Verify that this function interprets decimal-point wide character according to current locale.
  3. When the wide characters string for conversion is decimal-floating-constant, verify that this function converts it to floating point number in double representation.
  4. When the wide characters string for conversion is hexadecimal-floating-constant, verify that this function converts it to floating point number in double representation.
  5. When neither an exponent part nor a decimal-point wide character appears in a decimal floating point number, verify that an exponent part of the appropriate type with value zero is assumed to follow the last digit in the string.
  6. When a binary exponent part does not appear in a hexadecimal floating point number, verify that an exponent part of the appropriate type with value zero is assumed to follow the last digit in the string.
  7. When the wide character string for conversion begins with a minus sign, verify that the string is interpreted as negated.
  8. When the correct value is outside of representable values, verify that plus or minus HUGE_VAL is returned and ERANGE is stored in errno.
  9. When the wide character string for conversion is INF or INFINITY, verify that it is interpreted as infinity.
  10. When the result underflows, verify this function returns a value whose magnitude is no greater than the smallest normalized positive number in the double type.
  11. When endptr is not a null pointer, verify that a pointer to the character which is next to the last converted character is stored in the object pointed to by endptr.
  12. When the wide character string for conversion has the hexadecimal form and FLT_RADIX is a power of 2, the value resulting from the conversion is correctly rounded.
  13. When the wide character string for conversion is empty, verify that return value is 0.
  14. When the wide character string for conversion is empty and endptr is not a null pointer, verify that the value of nptr is stored in the object pointed to by endptr.
  15. When the wide character string for conversion does not have the expected form, verify that return value is 0.
  16. When the wide character string for conversion does not have the expected form and endptr is not a null pointer, verify that the value of nptr is stored in the object pointed to by endptr.
116 __wcstof_internal 16 float __wcstof_internal(const wchar_t *nptr, wchar_t **endptr, int group);

*) It is assumed that the value of group is always 0, because the behavior is undefined when group is not 0.
  1. Verify that this function ignores first white-space characters at nptr. The white-space characters are the ones whose results applied with iswspace() is true.
  2. Verify that this function interprets decimal-point wide character according to current locale.
  3. When the wide characters string for conversion is decimal-floating-constant, verify that this function converts it to floating point number in float representation.
  4. When the wide characters string for conversion is hexadecimal-floating-constant, verify that this function converts it to floating point number in float representation.
  5. When neither an exponent part nor a decimal-point wide character appears in a decimal floating point number, verify that an exponent part of the appropriate type with value zero is assumed to follow the last digit in the string.
  6. When a binary exponent part does not appear in a hexadecimal floating point number, verify that an exponent part of the appropriate type with value zero is assumed to follow the last digit in the string.
  7. When the wide character string for conversion begins with a minus sign, verify that the string is interpreted as negated.
  8. When the correct value is outside of representable values, verify that plus or minus HUGE_VALF is returned and ERANGE is stored in errno.
  9. When the wide character string for conversion is INF or INFINITY, verify that it is interpreted as infinity.
  10. When the result underflows, verify this function returns a value whose magnitude is no greater than the smallest normalized positive number in the float type.
  11. When endptr is not a null pointer, verify that a pointer to the character which is next to the last converted character is stored in the object pointed to by endptr.
  12. When the wide character string for conversion has the hexadecimal form and FLT_RADIX is a power of 2, the value resulting from the conversion is correctly rounded.
  13. When the wide character string for conversion is empty, verify that return value is 0.
  14. When the wide character string for conversion is empty and endptr is not a null pointer, verify that the value of nptr is stored in the object pointed to by endptr.
  15. When the wide character string for conversion does not have the expected form, verify that return value is 0.
  16. When the wide character string for conversion does not have the expected form and endptr is not a null pointer, verify that the value of nptr is stored in the object pointed to by endptr.
117 __wcstol_internal 17 long __wcstol_internal(const wchar_t *nptr, wchar_t **endptr, int base, int group);

*) It is assumed that the value of group is always 0, because the behavior is undefined when group is not 0.
  1. Verify that this function ignores first white-space characters at nptr. The white-space characters are the ones whose results applied with iswspace() is true.
  2. When base is 0 and the wide character string for conversion starts with '0', verify that the string is interpreted as octal number.
  3. When base is 0 and the wide character string for conversion starts without '0', verify that the string is interpreted as decimal number.
  4. When base is 0 and the wide character string for conversion starts with '0x' or '0X', verify that the string is interpreted as hexadecimal number.
  5. When the the wide character string for conversion have a integer suffix, verify that this function does not interpret it as numerical symbol.
  6. When base is bigger than 9, verify that some alphabets are interpreted as numeric character.
    (e.g. If base is 16, 'a', 'b', 'c', 'd', 'e', 'f' are interpreted respectively '10', '11', '12', '13', '14', '15'.)
  7. When alphabets are interpreted as numeric characters, verify that both the uppercase letter and lowercase letter are acceptable.
  8. When a digit is bigger than base, verify that it is the outside for conversion.
  9. When base is 16, verify that the wide character string for conversion is permitted to have '0x' or '0X'.
  10. When the wide character string for conversion begins with a minus sign, verify that the string is interpreted as negated.
  11. When endptr is not a null pointer, verify that a pointer to the character which is the next to the last converted character is stored in the object pointed to by endptr.
  12. When the wide character string for conversion is empty, verify that return value is 0.
  13. When the wide character string for conversion is empty and endptr is not a null pointer, verify that the value of nptr is stored in the object pointed to by endptr.
  14. When the wide character string for conversion does not have the expected form, verify that return value is 0.
  15. When the wide character string for conversion does not have the expected form and endptr is not a null pointer, verify that the value of nptr is stored in the object pointed to by endptr.
  16. When the wide character string for conversion is bigger than LONG_MAX, verify that the return value is LONG_MAX and errno is ERANGE.
  17. When the wide character string for conversion is smaller than the LONG_MIN, verify that the return value is LONG_MIN and errno is ERANGE.
118 __wcstold_internal 16 long double __wcstold_internal(const wchar_t *nptr, wchar_t **endptr, int group);

*) It is assumed that the value of group is always 0, because the behavior is undefined when group is not 0.
  1. Verify that this function ignores first white-space characters at nptr. The white-space characters are the ones whose results applied with iswspace() is true.
  2. Verify that this function interprets decimal-point wide character according to current locale.
  3. When the wide characters string for conversion is decimal-floating-constant, verify that this function converts it to floating point number in long double representation.
  4. When the wide characters string for conversion is hexadecimal-floating-constant, verify that this function converts it to floating point number in long double representation.
  5. When neither an exponent part nor a decimal-point wide character appears in a decimal floating point number, verify that an exponent part of the appropriate type with value zero is assumed to follow the last digit in the string.
  6. When a binary exponent part does not appear in a hexadecimal floating point number, verify that an exponent part of the appropriate type with value zero is assumed to follow the last digit in the string.
  7. When the wide character string for conversion begins with a minus sign, verify that the string is interpreted as negated.
  8. When the correct value is outside of representable values, verify that plus or minus HUGE_VALL is returned and ERANGE is stored in errno.
  9. When the wide character string for conversion is INF or INFINITY, verify that it is interpreted as infinity.
  10. When the result underflows, verify this function returns a value whose magnitude is no greater than the smallest normalized positive number in the long double type.
  11. When endptr is not a null pointer, verify that a pointer to the character which is next to the last converted character is stored in the object pointed to by endptr.
  12. When the wide character string for conversion has the hexadecimal form and FLT_RADIX is a power of 2, the value resulting from the conversion is correctly rounded.
  13. When the wide character string for conversion is empty, verify that return value is 0.
  14. When the wide character string for conversion is empty and endptr is not a null pointer, verify that the value of nptr is stored in the object pointed to by endptr.
  15. When the wide character string for conversion does not have the expected form, verify that return value is 0.
  16. When the wide character string for conversion does not have the expected form and endptr is not a null pointer, verify that the value of nptr is stored in the object pointed to by endptr.
119 __wcstoul_internal 15 unsigned long __wcstoul_internal(const wchar_t *restrict nptr, wchar_t **restrict endptr, int base, int group);

*) It is assumed that the value of group is always 0, because the behavior is undefined when group is not 0.
  1. Verify that this function ignores first white-space characters at nptr. The white-space characters are the ones whose results applied with iswspace() is true.
  2. When base is 0 and the wide character string for conversion starts with '0', verify that the string is interpreted as octal number.
  3. When base is 0 and the wide character string for conversion starts without '0', verify that the string is interpreted as decimal number.
  4. When base is 0 and the wide character string for conversion starts with '0x' or '0X', verify that the string is interpreted as hexadecimal number.
  5. When the the wide character string for conversion have a integer suffix, verify that this function does not interpret it as numerical symbol.
  6. When base is bigger than 9, verify that some alphabets are interpreted as numeric character.
    (e.g. If base is 16, 'a', 'b', 'c', 'd', 'e', 'f' are interpreted respectively '10', '11', '12', '13', '14', '15'.)
  7. When alphabets are interpreted as numeric characters, verify that both the uppercase letter and lowercase letter are acceptable.
  8. When a digit is bigger than base, verify that it is the outside for conversion.
  9. When base is 16, verify that the wide character string for conversion is permitted to have '0x' or '0X'.
  10. When endptr is not a null pointer, verify that a pointer to the character which is the next to the last converted character is stored in the object pointed to by endptr.
  11. When the wide character string for conversion is empty, verify that return value is 0.
  12. When the wide character string for conversion is empty and endptr is not a null pointer, verify that the value of nptr is stored in the object pointed to by endptr.
  13. When the wide character string for conversion does not have the expected form, verify that return value is 0.
  14. When the wide character string for conversion does not have the expected form and endptr is not a null pointer, verify that the value of nptr is stored in the object pointed to by endptr.
  15. When the wide character string for conversion is bigger than ULONG_MAX, verify that the return value is ULONG_MAX and errno is ERANGE.
120 mbsnrtowcs 7 #include <wchar.h>
size_t mbsnrtowcs(wchar_t *dest, const char **src, size_t nms, size_t len, mbstate_t *ps);
  1. When the situation is the following:
    • dest is not NULL pointer.
    • The terminating `\0' locates at the less than or equal to nms-th from the pointer which src stored.
    • The byte sequence starting at src is able to be converted to the wide character string.
    • The length of converted wide character (not including the terminating null wide character) is less than or equal to len.
    , verify the following:
    • The src value is NULL.
    • The return value is the length of the converted wide characters (not including the terminating null wide character).
    • The converted wide character string is stored from dest.
  2. When the situation is the following:
    • dest is not NULL pointer.
    • The terminating `\0' locates at the less than or equal to nms-th from the pointer which src stored.
    • The byte sequence starting at src is able to be converted to the wide character string.
    • The length of converted wide character (not including the terminating null wide character) is bigger than len.
    , verify the following:
    • The src is left pointing to the next multibyte sequence to be converted
    • The return value is equal to len.
    • The number of converted wide character (not including the terminating null wide character) is len.
    • The converted wide character string is stored from dest.
  3. When the situation is the following:
    • dest is not NULL pointer.
    • The terminating `\0' locates at the bigger than nms-th from the pointer which src stored.
    • The byte sequence starting at src is able to be converted to the wide character string.
    • The length of converted wide character (not including the terminating null wide character) is less than or equal to len.
    , verify the following:
    • The src is left pointing to the next multibyte sequence to be converted.
    • The return value is the length of the converted wide characters (not including the terminating null wide character).
    • The converted wide character string is stored from dest.
  4. When the situation is the following:
    • dest is not NULL pointer.
    • An invalid byte as a character exists in the byte sequence for conversion.
    , verify the following:
    • The src is left pointing to the the invalid byte as a character.
    • The return value is (size_t)(-1).
    • The global variable errno is set to EILSEQ.
  5. When the situation is the following:
    • dest is NULL pointer.
    • The terminating `\0' locates at the less than or equal to nms-th from the pointer which src stored.
    • The byte sequence starting at src is able to be converted to the wide character string.
    • The length of converted wide character (not including the terminating null wide character) is less than or equal to len.
    , verify the following:
    • The return value is the length of the converted wide characters (not including the terminating null wide character).
  6. When the situation is the following:
    • dest is NULL pointer.
    • The terminating `\0' locates at the less than or equal to nms-th from the pointer which src stored.
    • The byte sequence starting at src is able to be converted to the wide character string.
    • The length of converted wide character (not including the terminating null wide character) is bigger than len.
    , verify the following:
    • len is ignored.
    • The return value is the length of the converted wide characters (not including the terminating null wide character).
  7. When the situation is the following:
    • dest is NULL pointer.
    • The invalid byte as a character exists in the byte sequence for conversion.
    , verify the following:
    • The return value is (size_t)(-1).
    • The global variable errno is set to EILSEQ.
121 vwscanf 25 #include <stdarg.h>
#include <wchar.h>
int vwscanf (const wchar_t * restrict format, va_list arg);
  1. When a directive is composed of white-space wide characters, verify that this function reads input up to the first non-white-space wide character (which remains unread), or it reads input until no more wide characters can be read.
  2. When a directive is an ordinary wide character (i.e. except for %, and white-space wide character) and the wide character is equivalent to the wide character which would be read from the standard input, verify that this function read the next wide character from the standard input.
  3. When a directive is an ordinary wide character (i.e. except for %, and white-space wide character) and the wide character is not equivalent to the wide character which would be read from the standard input, verify that the directive fails and the next wide character on the standard input remains unread.
  4. When a conversion specification has `*', verify that the result of conversion is not stored any arguments.
  5. When a conversion specification has decimal wide characters, verify that this function interprets the wide characters as the field width.
  6. When a conversion wide character is `d', verify that the conversion result is the same as the results of wcstol() with the value 10 for the base argument.
  7. When a conversion wide character is `i', verify that the conversion result is the same as the results of wcstol() with the value 0 for the base argument.
  8. When a conversion wide character is `o', verify that the conversion result is the same as the results of wcstoul() with the value 8 for the base argument.
  9. When a conversion wide character is `u', verify that the conversion result is the same as the results of wcstoul() with the value 10 for the base argument.
  10. When a conversion wide character is `x' and `X', verify that the conversion result is the same as the results of wcstoul() with the value 16 for the base argument.
  11. When a conversion wide character is `a', `A', `e', `E', `f', `F', 'g' and `G', verify the conversion result is the same as the results of wcstod(). Especially check the radix character according to the current locale is interpreted correctly.
  12. When a conversion wide character is `c' and conversion specification does not have `l', verify that this function reads a sequence of the wide characters whose length is specified by the field width and this function stores the multibyte character sequence which are made of the sequence of the wide characters by wcsrtombs() with initial conversion state.
  13. When a conversion wide character is `c' and conversion specification has `l', verify that this function reads a sequence of the wide characters of whose number is specified by the field width and this function stores them.
  14. When a conversion wide character is `s' and conversion specification does not have `l', verify that this function reads a wide character string and this function stores the multibyte character string which that are made of the wide character string by wcsrtombs() with initial conversion state. Especially check the null character is stood at the end of the multibyte character string.
  15. When a conversion wide character is `s' and conversion specification has `l', verify that this function reads a wide character string and this function stores them. Especially check the null wide character is stood at the end of wide character string.
  16. When a conversion wide characters are `[...]', verify that this function reads the wide characters which are included between `[' and ']' and this function stores the multibyte character sequence which are made of the sequence of the wide characters by wcsrtombs() with initial conversion state. Especially check the null character is stood at the end of the multibyte character string.
  17. When a conversion wide character is `l[...]', verify that this function reads the wide characters which are included between `[' and ']' and this function stores them. Especially check the null wide character is stood at the end of the wide character string.
  18. When a conversion wide character is `[^...]', verify that this function reads the wide characters which are not included between `[^' and ']' and this function stores the multibyte character sequence as same that are made of the sequence of the wide characters by wcsrtombs() with initial conversion state. Especially check the null character is stood at the end of the multibyte character string.
  19. When a conversion wide character is `l[^...]', verify that this function reads a sequence of the wide characters which is not included between `[^' and ']', and stores them. Especially check the null character is stood at the end of the multibyte character string.
  20. When a conversion wide character is `p', verify that this function stores the pointer value.
  21. When a conversion wide character is `n', verify that no input is consumed and this function stores the number of the wide character which the function has read.
  22. When a conversion wide character is `%' (i.e. the orthography is `%%', verify that it matched a wide character %.
  23. When this function has not done any conversion by a read error, verify that this function returns EOF.
  24. When this function has done one or more conversion, verify that this function returns the number of the conversion.
  25. After this function execute correctly, verify that the standard input is changed to wide character oriented.
122 vfwscanf 25 #include <stdarg.h>
#include <wchar.h>
int vfwscanf (FILE * restrict stream, const wchar_t * restrict format, va_list arg);
  1. When a directive is composed of white-space wide characters, verify that this function reads input up to the first non-white-space wide character (which remains unread), or it reads input until no more wide characters can be read.
  2. When a directive is an ordinary wide character (i.e. except for %, and white-space wide character) and the wide character is equivalent to the wide character which would be read from the stream, verify that this function read the next wide character from the stream.
  3. When a directive is an ordinary wide character (i.e. except for %, and white-space wide character) and the wide character is not equivalent to the wide character which would be read from the stream, verify that the directive fails and the next wide character on the stream remains unread.
  4. When a conversion specification has `*', verify that the result of conversion is not stored any arguments.
  5. When a conversion specification has decimal wide characters, verify that this function interprets the wide characters as the field width.
  6. When a conversion wide character is `d', verify that the conversion result is the same as the results of wcstol() with the value 10 for the base argument.
  7. When a conversion wide character is `i', verify that the conversion result is the same as the results of wcstol() with the value 0 for the base argument.
  8. When a conversion wide character is `o', verify that the conversion result is the same as the results of wcstoul() with the value 8 for the base argument.
  9. When a conversion wide character is `u', verify that the conversion result is the same as the results of wcstoul() with the value 10 for the base argument.
  10. When a conversion wide character is `x' and `X', verify that the conversion result is the same as the results of wcstoul() with the value 16 for the base argument.
  11. When a conversion wide character is `a', `A', `e', `E', `f', `F', 'g' and `G', verify the conversion result is the same as the results of wcstod(). Especially check the radix character according to the current locale is interpreted correctly.
  12. When a conversion wide character is `c' and conversion specification does not have `l', verify that this function reads a sequence of the wide characters whose length is specified by the field width and this function stores the multibyte character sequence which are made of the sequence of the wide characters by wcsrtombs() with initial conversion state.
  13. When a conversion wide character is `c' and conversion specification has `l', verify that this function reads a sequence of the wide characters of whose number is specified by the field width and this function stores them.
  14. When a conversion wide character is `s' and conversion specification does not have `l', verify that this function reads a wide character string and this function stores the multibyte character string which that are made of the wide character string by wcsrtombs() with initial conversion state. Especially check the null character is stood at the end of the multibyte character string.
  15. When a conversion wide character is `s' and conversion specification has `l', verify that this function reads a wide character string and this function stores them. Especially check the null wide character is stood at the end of wide character string.
  16. When a conversion wide characters are `[...]', verify that this function reads the wide characters which are included between `[' and ']' and this function stores the multibyte character sequence which are made of the sequence of the wide characters by wcsrtombs() with initial conversion state. Especially check the null character is stood at the end of the multibyte character string.
  17. When a conversion wide character is `l[...]', verify that this function reads the wide characters which are included between `[' and ']' and this function stores them. Especially check the null wide character is stood at the end of the wide character string.
  18. When a conversion wide character is `[^...]', verify that this function reads the wide characters which are not included between `[^' and ']' and this function stores the multibyte character sequence as same that are made of the sequence of the wide characters by wcsrtombs() with initial conversion state. Especially check the null character is stood at the end of the multibyte character string.
  19. When a conversion wide character is `l[^...]', verify that this function reads a sequence of the wide characters which is not included between `[^' and ']', and stores them. Especially check the null character is stood at the end of the multibyte character string.
  20. When a conversion wide character is `p', verify that this function stores the pointer value.
  21. When a conversion wide character is `n', verify that no input is consumed and this function stores the number of the wide character which the function has read.
  22. When a conversion wide character is `%' (i.e. the orthography is `%%', verify that it matched a wide character %.
  23. When this function has not done any conversion by a read error, verify that this function returns EOF.
  24. When this function has done one or more conversion, verify that this function returns the number of the conversion.
  25. After this function execute correctly, verify that the stream is changed to wide character oriented.
123 vswscanf 24 #include <stdarg.h>
#include <wchar.h>
int vswscanf (const wchar_t * restrict s, const wchar_t * restrict format, va_list arg);
  1. When a directive is composed of white-space wide characters, verify that this function reads input up to the first non-white-space wide character (which remains unread), or it reads input until no more wide characters can be read.
  2. When a directive is an ordinary wide character (i.e. except for %, and white-space wide character) and the wide character is equivalent to the wide character which would be read from s, verify that this function read the next wide character s.
  3. When a directive is an ordinary wide character (i.e. except for %, and white-space wide character) and the wide character is not equivalent to the wide character which would be read from s, verify that the directive fails and the next wide character on the s remains unread.
  4. When a conversion specification has `*', verify that the result of conversion is not stored any arguments.
  5. When a conversion specification has decimal wide characters, verify that this function interprets the wide characters as the field width.
  6. When a conversion wide character is `d', verify that the conversion result is the same as the results of wcstol() with the value 10 for the base argument.
  7. When a conversion wide character is `i', verify that the conversion result is the same as the results of wcstol() with the value 0 for the base argument.
  8. When a conversion wide character is `o', verify that the conversion result is the same as the results of wcstoul() with the value 8 for the base argument.
  9. When a conversion wide character is `u', verify that the conversion result is the same as the results of wcstoul() with the value 10 for the base argument.
  10. When a conversion wide character is `x' and `X', verify that the conversion result is the same as the results of wcstoul() with the value 16 for the base argument.
  11. When a conversion wide character is `a', `A', `e', `E', `f', `F', 'g' and `G', verify the conversion result is the same as the results of wcstod(). Especially check the radix character according to the current locale is interpreted correctly.
  12. When a conversion wide character is `c' and conversion specification does not have `l', verify that this function reads a sequence of the wide characters whose length is specified by the field width and this function stores the multibyte character sequence which are made of the sequence of the wide characters by wcsrtombs() with initial conversion state.
  13. When a conversion wide character is `c' and conversion specification has `l', verify that this function reads a sequence of the wide characters of whose number is specified by the field width and this function stores them.
  14. When a conversion wide character is `s' and conversion specification does not have `l', verify that this function reads a wide character string and this function stores the multibyte character string which that are made of the wide character string by wcsrtombs() with initial conversion state. Especially check the null character is stood at the end of the multibyte character string.
  15. When a conversion wide character is `s' and conversion specification has `l', verify that this function reads a wide character string and this function stores them. Especially check the null wide character is stood at the end of wide character string.
  16. When a conversion wide characters are `[...]', verify that this function reads the wide characters which are included between `[' and ']' and this function stores the multibyte character sequence which are made of the sequence of the wide characters by wcsrtombs() with initial conversion state. Especially check the null character is stood at the end of the multibyte character string.
  17. When a conversion wide character is `l[...]', verify that this function reads the wide characters which are included between `[' and ']' and this function stores them. Especially check the null wide character is stood at the end of the wide character string.
  18. When a conversion wide character is `[^...]', verify that this function reads the wide characters which are not included between `[^' and ']' and this function stores the multibyte character sequence as same that are made of the sequence of the wide characters by wcsrtombs() with initial conversion state. Especially check the null character is stood at the end of the multibyte character string.
  19. When a conversion wide character is `l[^...]', verify that this function reads a sequence of the wide characters which is not included between `[^' and ']', and stores them. Especially check the null character is stood at the end of the multibyte character string.
  20. When a conversion wide character is `p', verify that this function stores the pointer value.
  21. When a conversion wide character is `n', verify that no input is consumed and this function stores the number of the wide character which the function has read.
  22. When a conversion wide character is `%' (i.e. the orthography is `%%', verify that it matched a wide character %.
  23. When this function has not done any conversion by a read error, verify that this function returns EOF.
  24. When this function has done one or more conversion, verify that this function returns the number of the conversion.
124 wcpcpy 2 #include <wchar.h>
wchar_t *wcpcpy(wchar_t *dest, const wchar_t *src);
  1. Verify the string starting at dest is same as the string starting at src.
  2. Verify this function returns a pointer to the end of the wide-character string dest.
125 wcpncpy 4 #include <wchar.h>
wchar_t *wcpncpy(wchar_t *dest, const wchar_t *src, size_t n);
  1. When the length of src (including the terminating L'\0' character) is less than or equal to n, verify the string starting at dest is same as the string starting at src.
  2. When the length of src is smaller than n, verify the remaining wide characters in the array dest are filled with L'\0' characters.
  3. When the length of src is bigger than n, verify that only n wide characters are written at dest.
  4. Verify this function returns a pointer to the wide character one past the last non-null character written.
126 wcscasecmp 3 #include <wchar.h>
int wcscasecmp(const wchar_t *s1, const wchar_t *s2);
  1. When a wide character string starting at s1 is less than a wide character string starting at s2 except for case distinctions, verify this function returns negative value.
  2. If a wide character string starting at s1 and a wide character string starting at s2 are equal except for case distinctions, verify this function returns 0.
  3. If a wide character string starting at s1 is greater than a wide character string starting at s2 except for case distinctions, verify this function returns positive value.
127 wcsdup 1 #include <wchar.h>
wchar_t *wcsdup (const wchar_t *s);
  1. Verify the wide character string starting at return value is equal to the one starting at s.
128 wcsncasecmp 3 #include <wchar.h>
int wcsncasecmp(const wchar_t *s1, const wchar_t *s2, size_t n);
  1. When the first n wide characters starting at s1 is less than the first n wide characters starting at s2 except for case distinctions, verify this function returns negative value.
  2. When the first n wide characters starting at s1 and the first n wide characters starting at s2 are equal except for case distinctions, verify this function returns 0.
  3. When the first n wide characters starting at s1 is greater than the first n wide characters starting at s2 except for case distinctions, verify this function returns positive value.
129 wcsnlen 2 #include <wchar.h>
size_t wcsnlen (const wchar_t *s, size_t maxlen);
  1. When the number of wide character string is less than maxlen, verify this function returns the number.
  2. When the number of wide character string is equal to or more than maxlen, verify this function returns maxlen.
130 wcsnrtombs 7 #include <wchar.h>
size_t wcsnrotmbs (char *dest, const wchar_t **src, size_t nwc, size_t len, mbstate_t *ps);
  1. When the situation is the following:
    • dest is not NULL pointer.
    • The terminating L`\0' locates at the less than or equal to nwc-th from the pointer which src stored.
    • The wide character sequence starting at src is able to be converted to the multibyte character string.
    • The byte length of converted multi byte characters (not including the terminating null character) is less than or equal to len.
    , verify the following:
    • The src value is NULL.
    • The return value is the byte length of the converted multibyte characters (not including the terminating null character).
    • The converted multibyte character string is stored from dest.
  2. When the situation is the following:
    • dest is not NULL pointer.
    • The terminating L`\0' locates at the less than or equal to nwc-th from the pointer which src stored.
    • The wide character sequence starting at src is able to be converted to the multibyte character string.
    • The byte length of converted multi byte characters (not including the terminating null character) is bigger than len.
    , verify the following:
    • The src is left pointing to the next wide character sequence to be converted.
    • The return value is equal to len.
    • The number of converted multibyte character (not including the terminating null character) is len.
    • The converted multibyte character string is stored from dest.
  3. When the situation is the following:
    • dest is not NULL pointer.
    • The terminating L`\0' locates at the bigger than nwc-th from the pointer which src stored.
    • The wide character sequence starting at src is able to be converted to the multibyte character string.
    • The byte length of converted multi byte characters (not including the terminating null character) is less than or equal to len.
    , verify the following:
    • The src is left pointing to the next wide character sequence to be converted.
    • The return value is the byte length of the converted multibyte characters (not including the terminating null character).
    • The converted multibyte character string is stored from dest.
  4. When the situation is the following:
    • dest is not NULL pointer.
    • An invalid wide character which cannot be converted to a multibyte character exists in the wide character sequence for conversion.
    , verify the following:
    • The src is left pointing to the the invalid wide character.
    • The return value is (size_t)(-1).
    • The global variable errno is set to EILSEQ.
  5. When the situation is the following:
    • dest is NULL pointer.
    • The terminating L`\0' locates at the less than or equal to nwc-th from the pointer which src stored.
    • The wide character sequence starting at src is able to be converted to the multibyte character string.
    • The byte length of converted multi byte characters (not including the terminating null character) is less than or equal to len.
    , verify the following:
    • The return value is the byte length of the converted multibyte characters (not including the terminating null character).
  6. When the situation is the following:
    • dest is NULL pointer.
    • The terminating L`\0' locates at the less than or equal to nwc-th from the pointer which src stored.
    • The wide character sequence starting at src is able to be converted to the multibyte character string.
    • The byte length of converted multi byte characters (not including the terminating null character) is bigger than len.
    , verify the following:
    • len is ignored.
    • The return value is the byte length of the converted multibyte characters (not including the terminating null character).
  7. When the situation is the following:
    • dest is NULL pointer.
    • An invalid wide character which cannot be converted to a multibyte character exists in the wide character sequence for conversion.
    , verify the following:
    • The return value is (size_t)(-1).
    • The global variable errno is set to EILSEQ.
131 wcstof 16 #include <wchar.h>
float wcstof (const wchar_t * restrict nptr, wchar_t ** restrict endptr);
  1. Verify that this function ignores first white-space characters at nptr. The white-space characters are the ones whose results applied with iswspace() is true.
  2. Verify that this function interprets decimal-point wide character according to current locale.
  3. When the wide characters string for conversion is decimal-floating-constant, verify that this function converts it to floating point number in float representation.
  4. When the wide characters string for conversion is hexadecimal-floating-constant, verify that this function converts it to floating point number in float representation.
  5. When neither an exponent part nor a decimal-point wide character appears in a decimal floating point number, verify that an exponent part of the appropriate type with value zero is assumed to follow the last digit in the string.
  6. When a binary exponent part does not appear in a hexadecimal floating point number, verify that an exponent part of the appropriate type with value zero is assumed to follow the last digit in the string.
  7. When the wide character string for conversion begins with a minus sign, verify that the string is interpreted as negated.
  8. When the correct value is outside of representable values, verify that plus or minus HUGE_VALF is returned and ERANGE is stored in errno.
  9. When the wide character string for conversion is INF or INFINITY, verify that it is interpreted as infinity.
  10. When the result underflows, verify this function returns a value whose magnitude is no greater than the smallest normalized positive number in the float type.
  11. When endptr is not a null pointer, verify that a pointer to the character which is next to the last converted character is stored in the object pointed to by endptr.
  12. When the wide character string for conversion has the hexadecimal form and FLT_RADIX is a power of 2, the value resulting from the conversion is correctly rounded.
  13. When the wide character string for conversion is empty, verify that return value is 0.
  14. When the wide character string for conversion is empty and endptr is not a null pointer, verify that the value of nptr is stored in the object pointed to by endptr.
  15. When the wide character string for conversion does not have the expected form, verify that return value is 0.
  16. When the wide character string for conversion does not have the expected form and endptr is not a null pointer, verify that the value of nptr is stored in the object pointed to by endptr.
132 wcstoimax 17 #include <wchar.h>
intmax_t wcstoimax (const wchar_t * restrict nptr, wchar_t ** restrict endptr, int base);
  1. Verify that this function ignores first white-space characters at nptr. The white-space characters are the ones whose results applied with iswspace() is true.
  2. When base is 0 and the wide character string for conversion starts with '0', verify that the string is interpreted as octal number.
  3. When base is 0 and the wide character string for conversion starts without '0', verify that the string is interpreted as decimal number.
  4. When base is 0 and the wide character string for conversion starts with '0x' or '0X', verify that the string is interpreted as hexadecimal number.
  5. When the the wide character string for conversion have a integer suffix, verify that this function does not interpret it as numerical symbol.
  6. When base is bigger than 9, verify that some alphabets are interpreted as numeric character.
    (e.g. If base is 16, 'a', 'b', 'c', 'd', 'e', 'f' are interpreted respectively '10', '11', '12', '13', '14', '15'.)
  7. When alphabets are interpreted as numeric characters, verify that both the uppercase letter and lowercase letter are acceptable.
  8. When a digit is bigger than base, verify that it is the outside for conversion.
  9. When base is 16, verify that the wide character string for conversion is permitted to have '0x' or '0X'.
  10. When the wide character string for conversion begins with a minus sign, verify that the string is interpreted as negated.
  11. When endptr is not a null pointer, verify that a pointer to the character which is the next to the last converted character is stored in the object pointed to by endptr.
  12. When the wide character string for conversion is empty, verify that return value is 0.
  13. When the wide character string for conversion is empty and endptr is not a null pointer, verify that the value of nptr is stored in the object pointed to by endptr.
  14. When the wide character string for conversion does not have the expected form, verify that return value is 0.
  15. When the wide character string for conversion does not have the expected form and endptr is not a null pointer, verify that the value of nptr is stored in the object pointed to by endptr.
  16. When the wide character string for conversion is bigger than INTMAX_MAX, verify that the return value is INTMAX_MAX and errno is ERANGE.
  17. When the wide character string for conversion is smaller than the INTMAX_MIN, verify that the return value is INTMAX_MIN and errno is ERANGE.
133 wcstold 16 #include <wchar.h>
long double wcstold (const wchar_t * restrict nptr, wchar_t ** restrict endptr);
  1. Verify that this function ignores first white-space characters at nptr. The white-space characters are the ones whose results applied with iswspace() is true.
  2. Verify that this function interprets decimal-point wide character according to current locale.
  3. When the wide characters string for conversion is decimal-floating-constant, verify that this function converts it to floating point number in long double representation.
  4. When the wide characters string for conversion is hexadecimal-floating-constant, verify that this function converts it to floating point number in long double representation.
  5. When neither an exponent part nor a decimal-point wide character appears in a decimal floating point number, verify that an exponent part of the appropriate type with value zero is assumed to follow the last digit in the string.
  6. When a binary exponent part does not appear in a hexadecimal floating point number, verify that an exponent part of the appropriate type with value zero is assumed to follow the last digit in the string.
  7. When the wide character string for conversion begins with a minus sign, verify that the string is interpreted as negated.
  8. When the correct value is outside of representable values, verify that plus or minus HUGE_VALL is returned and ERANGE is stored in errno.
  9. When the wide character string for conversion is INF or INFINITY, verify that it is interpreted as infinity.
  10. When the result underflows, verify this function returns a value whose magnitude is no greater than the smallest normalized positive number in the long double type.
  11. When endptr is not a null pointer, verify that a pointer to the character which is next to the last converted character is stored in the object pointed to by endptr.
  12. When the wide character string for conversion has the hexadecimal form and FLT_RADIX is a power of 2, the value resulting from the conversion is correctly rounded.
  13. When the wide character string for conversion is empty, verify that return value is 0.
  14. When the wide character string for conversion is empty and endptr is not a null pointer, verify that the value of nptr is stored in the object pointed to by endptr.
  15. When the wide character string for conversion does not have the expected form, verify that return value is 0.
  16. When the wide character string for conversion does not have the expected form and endptr is not a null pointer, verify that the value of nptr is stored in the object pointed to by endptr.
134 wcstoll 17 #include <wchar.h>
long long int wcstoll (const wchar_t * restrict nptr, wchar_t ** restrict endptr, int base);
  1. Verify that this function ignores first white-space characters at nptr. The white-space characters are the ones whose results applied with iswspace() is true.
  2. When base is 0 and the wide character string for conversion starts with '0', verify that the string is interpreted as octal number.
  3. When base is 0 and the wide character string for conversion starts without '0', verify that the string is interpreted as decimal number.
  4. When base is 0 and the wide character string for conversion starts with '0x' or '0X', verify that the string is interpreted as hexadecimal number.
  5. When the the wide character string for conversion have a integer suffix, verify that this function does not interpret it as numerical symbol.
  6. When base is bigger than 9, verify that some alphabets are interpreted as numeric character.
    (e.g. If base is 16, 'a', 'b', 'c', 'd', 'e', 'f' are interpreted respectively '10', '11', '12', '13', '14', '15'.)
  7. When alphabets are interpreted as numeric characters, verify that both the uppercase letter and lowercase letter are acceptable.
  8. When a digit is bigger than base, verify that it is the outside for conversion.
  9. When base is 16, verify that the wide character string for conversion is permitted to have '0x' or '0X'.
  10. When the wide character string for conversion begins with a minus sign, verify that the string is interpreted as negated.
  11. When endptr is not a null pointer, verify that a pointer to the character which is the next to the last converted character is stored in the object pointed to by endptr.
  12. When the wide character string for conversion is empty, verify that return value is 0.
  13. When the wide character string for conversion is empty and endptr is not a null pointer, verify that the value of nptr is stored in the object pointed to by endptr.
  14. When the wide character string for conversion does not have the expected form, verify that return value is 0.
  15. When the wide character string for conversion does not have the expected form and endptr is not a null pointer, verify that the value of nptr is stored in the object pointed to by endptr.
  16. When the wide character string for conversion is bigger than LLONG_MAX, verify that the return value is LLONG_MAX and errno is ERANGE.
  17. When the wide character string for conversion is smaller than the LLONG_MIN, verify that the return value is LLONG_MIN and errno is ERANGE.
135 wcstoq 17 #include <wchar.h>
extern long long int wcstoq (const wchar_t * restrict nptr, wchar_t ** restrict endptr, int base);
  1. Verify that this function ignores first white-space characters at nptr. The white-space characters are the ones whose results applied with iswspace() is true.
  2. When base is 0 and the wide character string for conversion starts with '0', verify that the string is interpreted as octal number.
  3. When base is 0 and the wide character string for conversion starts without '0', verify that the string is interpreted as decimal number.
  4. When base is 0 and the wide character string for conversion starts with '0x' or '0X', verify that the string is interpreted as hexadecimal number.
  5. When the the wide character string for conversion have a integer suffix, verify that this function does not interpret it as numerical symbol.
  6. When base is bigger than 9, verify that some alphabets are interpreted as numeric character.
    (e.g. If base is 16, 'a', 'b', 'c', 'd', 'e', 'f' are interpreted respectively '10', '11', '12', '13', '14', '15'.)
  7. When alphabets are interpreted as numeric characters, verify that both the uppercase letter and lowercase letter are acceptable.
  8. When a digit is bigger than base, verify that it is the outside for conversion.
  9. When base is 16, verify that the wide character string for conversion is permitted to have '0x' or '0X'.
  10. When the wide character string for conversion begins with a minus sign, verify that the string is interpreted as negated.
  11. When endptr is not a null pointer, verify that a pointer to the character which is the next to the last converted character is stored in the object pointed to by endptr.
  12. When the wide character string for conversion is empty, verify that return value is 0.
  13. When the wide character string for conversion is empty and endptr is not a null pointer, verify that the value of nptr is stored in the object pointed to by endptr.
  14. When the wide character string for conversion does not have the expected form, verify that return value is 0.
  15. When the wide character string for conversion does not have the expected form and endptr is not a null pointer, verify that the value of nptr is stored in the object pointed to by endptr.
  16. When the wide character string for conversion is bigger than LLONG_MAX, verify that the return value is LLONG_MAX and errno is ERANGE.
  17. When the wide character string for conversion is smaller than the LLONG_MIN, verify that the return value is LLONG_MIN and errno is ERANGE.
136 wcstoull 15 #include <wchar.h>
unsigned long long int wcstoll (const wchar_t * restrict nptr, wchar_t ** restrict endptr, int base);
  1. Verify that this function ignores first white-space characters at nptr. The white-space characters are the ones whose results applied with iswspace() is true.
  2. When base is 0 and the wide character string for conversion starts with '0', verify that the string is interpreted as octal number.
  3. When base is 0 and the wide character string for conversion starts without '0', verify that the string is interpreted as decimal number.
  4. When base is 0 and the wide character string for conversion starts with '0x' or '0X', verify that the string is interpreted as hexadecimal number.
  5. When the the wide character string for conversion have a integer suffix, verify that this function does not interpret it as numerical symbol.
  6. When base is bigger than 9, verify that some alphabets are interpreted as numeric character.
    (e.g. If base is 16, 'a', 'b', 'c', 'd', 'e', 'f' are interpreted respectively '10', '11', '12', '13', '14', '15'.)
  7. When alphabets are interpreted as numeric characters, verify that both the uppercase letter and lowercase letter are acceptable.
  8. When a digit is bigger than base, verify that it is the outside for conversion.
  9. When base is 16, verify that the wide character string for conversion is permitted to have '0x' or '0X'.
  10. When endptr is not a null pointer, verify that a pointer to the character which is the next to the last converted character is stored in the object pointed to by endptr.
  11. When the wide character string for conversion is empty, verify that return value is 0.
  12. When the wide character string for conversion is empty and endptr is not a null pointer, verify that the value of nptr is stored in the object pointed to by endptr.
  13. When the wide character string for conversion does not have the expected form, verify that return value is 0.
  14. When the wide character string for conversion does not have the expected form and endptr is not a null pointer, verify that the value of nptr is stored in the object pointed to by endptr.
  15. When the wide character string for conversion is bigger than ULLONG_MAX, verify that the return value is ULLONG_MAX and errno is ERANGE.
137 wcstoumax 15 #include <wchar.h>
uintmax_t wcstoumax (const wchar_t * restrict nptr, wchar_t ** restrict endptr, int base);
  1. Verify that this function ignores first white-space characters at nptr. The white-space characters are the ones whose results applied with iswspace() is true.
  2. When base is 0 and the wide character string for conversion starts with '0', verify that the string is interpreted as octal number.
  3. When base is 0 and the wide character string for conversion starts without '0', verify that the string is interpreted as decimal number.
  4. When base is 0 and the wide character string for conversion starts with '0x' or '0X', verify that the string is interpreted as hexadecimal number.
  5. When the the wide character string for conversion have a integer suffix, verify that this function does not interpret it as numerical symbol.
  6. When base is bigger than 9, verify that some alphabets are interpreted as numeric character.
    (e.g. If base is 16, 'a', 'b', 'c', 'd', 'e', 'f' are interpreted respectively '10', '11', '12', '13', '14', '15'.)
  7. When alphabets are interpreted as numeric characters, verify that both the uppercase letter and lowercase letter are acceptable.
  8. When a digit is bigger than base, verify that it is the outside for conversion.
  9. When base is 16, verify that the wide character string for conversion is permitted to have '0x' or '0X'.
  10. When endptr is not a null pointer, verify that a pointer to the character which is the next to the last converted character is stored in the object pointed to by endptr.
  11. When the wide character string for conversion is empty, verify that return value is 0.
  12. When the wide character string for conversion is empty and endptr is not a null pointer, verify that the value of nptr is stored in the object pointed to by endptr.
  13. When the wide character string for conversion does not have the expected form, verify that return value is 0.
  14. When the wide character string for conversion does not have the expected form and endptr is not a null pointer, verify that the value of nptr is stored in the object pointed to by endptr.
  15. When the wide character string for conversion is bigger than UINTMAX_MAX, verify that the return value is UINTMAX_MAX and errno is ERANGE.
138 wcstouq 15 #include <wchar.h>
extern unsigned long long int wcstouq (const wchar_t * restrict nptr, wchar_t ** restrict endptr, int base);
  1. Verify that this function ignores first white-space characters at nptr. The white-space characters are the ones whose results applied with iswspace() is true.
  2. When base is 0 and the wide character string for conversion starts with '0', verify that the string is interpreted as octal number.
  3. When base is 0 and the wide character string for conversion starts without '0', verify that the string is interpreted as decimal number.
  4. When base is 0 and the wide character string for conversion starts with '0x' or '0X', verify that the string is interpreted as hexadecimal number.
  5. When the the wide character string for conversion have a integer suffix, verify that this function does not interpret it as numerical symbol.
  6. When base is bigger than 9, verify that some alphabets are interpreted as numeric character.
    (e.g. If base is 16, 'a', 'b', 'c', 'd', 'e', 'f' are interpreted respectively '10', '11', '12', '13', '14', '15'.)
  7. When alphabets are interpreted as numeric characters, verify that both the uppercase letter and lowercase letter are acceptable.
  8. When a digit is bigger than base, verify that it is the outside for conversion.
  9. When base is 16, verify that the wide character string for conversion is permitted to have '0x' or '0X'.
  10. When endptr is not a null pointer, verify that a pointer to the character which is the next to the last converted character is stored in the object pointed to by endptr.
  11. When the wide character string for conversion is empty, verify that return value is 0.
  12. When the wide character string for conversion is empty and endptr is not a null pointer, verify that the value of nptr is stored in the object pointed to by endptr.
  13. When the wide character string for conversion does not have the expected form, verify that return value is 0.
  14. When the wide character string for conversion does not have the expected form and endptr is not a null pointer, verify that the value of nptr is stored in the object pointed to by endptr.
  15. When the wide character string for conversion is bigger than ULLONG_MAX, verify that the return value is ULLONG_MAX and errno is ERANGE.
139 wcswcs 3 #include <wchar.h>
wchar_t *wcswcs (const wchar_t *s1, const wchar_t *s2);
  1. If the wide character string starting at s1 has the string starting at s2 (except the last null wide character), verify this function returns a point to the first occurrence of that string.
  2. If the wide character string starting at s1 does not have the string starting at s2 (except the last null wide character), verify this function returns NULL.
  3. If s2 points to a wide-character string with zero length, verify this function returns s1.


References
[POSIX.1]
ISO/IEC 9945-1:1996 Information technology - Portable Operating System Interface (POSIX) - Part 1: System Application Program Interface (API) [C Language]

[ISO C]
ISO/IEC 9899:1990 Programming Language - C

ISO/IEC 9899:1990/Amd.1:1995 Programming Language - C Amendment 1: C Integrity
[XSH5]
The Single UNIX Specification, Version 2

System Interfaces and Headers, Issue 5 (2 volumes)
(The Open Group CAE Specification C606)