[MSVC] 22.locale.ctype.is.cpp test fails

• Key: STDCXX-660
• Type: Bug
• Status: Closed
• Resolution: Fixed
• Priority: Minor
• Assignee: Farid Zaripov
• Reporter: Farid Zaripov
• Component/s: Tests
• Affects Version/s: 4.2.0
• Fix Version/s: 4.2.1

Description

The 22.locale.ctype.is.cpp test fails with the following assertions:

---------------------------------------------
# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\t') in locale("C") expected to hold for { space print cntrl }, got { space cntrl }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\t', locale ("C")) expected to hold for { space print cntrl }, got { space cntrl }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\x80') in locale("C") expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\x80', locale ("C")) expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\x81') in locale("C") expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\x81', locale ("C")) expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\x82') in locale("C") expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\x82', locale ("C")) expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\x83') in locale("C") expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\x83', locale ("C")) expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\x84') in locale("C") expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\x84', locale ("C")) expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\x85') in locale("C") expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\x85', locale ("C")) expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\x86') in locale("C") expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\x86', locale ("C")) expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\x87') in locale("C") expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\x87', locale ("C")) expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\x88') in locale("C") expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\x88', locale ("C")) expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\x89') in locale("C") expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\x89', locale ("C")) expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\x8a') in locale("C") expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\x8a', locale ("C")) expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\x8b') in locale("C") expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\x8b', locale ("C")) expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\x8c') in locale("C") expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\x8c', locale ("C")) expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\x8d') in locale("C") expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\x8d', locale ("C")) expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\x8e') in locale("C") expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\x8e', locale ("C")) expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\x8f') in locale("C") expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\x8f', locale ("C")) expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\x90') in locale("C") expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\x90', locale ("C")) expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\x91') in locale("C") expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\x91', locale ("C")) expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\x92') in locale("C") expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\x92', locale ("C")) expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\x93') in locale("C") expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\x93', locale ("C")) expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\x94') in locale("C") expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\x94', locale ("C")) expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\x95') in locale("C") expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\x95', locale ("C")) expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\x96') in locale("C") expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\x96', locale ("C")) expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\x97') in locale("C") expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\x97', locale ("C")) expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\x98') in locale("C") expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\x98', locale ("C")) expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\x99') in locale("C") expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\x99', locale ("C")) expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\x9a') in locale("C") expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\x9a', locale ("C")) expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\x9b') in locale("C") expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\x9b', locale ("C")) expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\x9c') in locale("C") expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\x9c', locale ("C")) expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\x9d') in locale("C") expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\x9d', locale ("C")) expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\x9e') in locale("C") expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\x9e', locale ("C")) expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\x9f') in locale("C") expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\x9f', locale ("C")) expected to hold for { cntrl }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xa0') in locale("C") expected to hold for { space print }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xa0', locale ("C")) expected to hold for { space print }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xa1') in locale("C") expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xa1', locale ("C")) expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xa2') in locale("C") expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xa2', locale ("C")) expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xa3') in locale("C") expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xa3', locale ("C")) expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xa4') in locale("C") expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xa4', locale ("C")) expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xa5') in locale("C") expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xa5', locale ("C")) expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xa6') in locale("C") expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xa6', locale ("C")) expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xa7') in locale("C") expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xa7', locale ("C")) expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xa8') in locale("C") expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xa8', locale ("C")) expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xa9') in locale("C") expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xa9', locale ("C")) expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xaa') in locale("C") expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xaa', locale ("C")) expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xab') in locale("C") expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xab', locale ("C")) expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xac') in locale("C") expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xac', locale ("C")) expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xad') in locale("C") expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xad', locale ("C")) expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xae') in locale("C") expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xae', locale ("C")) expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xaf') in locale("C") expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xaf', locale ("C")) expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xb0') in locale("C") expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xb0', locale ("C")) expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xb1') in locale("C") expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xb1', locale ("C")) expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xb2') in locale("C") expected to hold for { print digit punct alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xb2', locale ("C")) expected to hold for { print digit punct alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xb3') in locale("C") expected to hold for { print digit punct alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xb3', locale ("C")) expected to hold for { print digit punct alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xb4') in locale("C") expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xb4', locale ("C")) expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xb5') in locale("C") expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xb5', locale ("C")) expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xb6') in locale("C") expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xb6', locale ("C")) expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xb7') in locale("C") expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xb7', locale ("C")) expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xb8') in locale("C") expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xb8', locale ("C")) expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xb9') in locale("C") expected to hold for { print digit punct alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xb9', locale ("C")) expected to hold for { print digit punct alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xba') in locale("C") expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xba', locale ("C")) expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xbb') in locale("C") expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xbb', locale ("C")) expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xbc') in locale("C") expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xbc', locale ("C")) expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xbd') in locale("C") expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xbd', locale ("C")) expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xbe') in locale("C") expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xbe', locale ("C")) expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xbf') in locale("C") expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xbf', locale ("C")) expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xc0') in locale("C") expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xc0', locale ("C")) expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xc1') in locale("C") expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xc1', locale ("C")) expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xc2') in locale("C") expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xc2', locale ("C")) expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xc3') in locale("C") expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xc3', locale ("C")) expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xc4') in locale("C") expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xc4', locale ("C")) expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xc5') in locale("C") expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xc5', locale ("C")) expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xc6') in locale("C") expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xc6', locale ("C")) expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xc7') in locale("C") expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xc7', locale ("C")) expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xc8') in locale("C") expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xc8', locale ("C")) expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xc9') in locale("C") expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xc9', locale ("C")) expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xca') in locale("C") expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xca', locale ("C")) expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xcb') in locale("C") expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xcb', locale ("C")) expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xcc') in locale("C") expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xcc', locale ("C")) expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xcd') in locale("C") expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xcd', locale ("C")) expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xce') in locale("C") expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xce', locale ("C")) expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xcf') in locale("C") expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xcf', locale ("C")) expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xd0') in locale("C") expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xd0', locale ("C")) expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xd1') in locale("C") expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xd1', locale ("C")) expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xd2') in locale("C") expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xd2', locale ("C")) expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xd3') in locale("C") expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xd3', locale ("C")) expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xd4') in locale("C") expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xd4', locale ("C")) expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xd5') in locale("C") expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xd5', locale ("C")) expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xd6') in locale("C") expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xd6', locale ("C")) expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xd7') in locale("C") expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xd7', locale ("C")) expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xd8') in locale("C") expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xd8', locale ("C")) expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xd9') in locale("C") expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xd9', locale ("C")) expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xda') in locale("C") expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xda', locale ("C")) expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xdb') in locale("C") expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xdb', locale ("C")) expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xdc') in locale("C") expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xdc', locale ("C")) expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xdd') in locale("C") expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xdd', locale ("C")) expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xde') in locale("C") expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xde', locale ("C")) expected to hold for { print upper alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xdf') in locale("C") expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xdf', locale ("C")) expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xe0') in locale("C") expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xe0', locale ("C")) expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xe1') in locale("C") expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xe1', locale ("C")) expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xe2') in locale("C") expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xe2', locale ("C")) expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xe3') in locale("C") expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xe3', locale ("C")) expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xe4') in locale("C") expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xe4', locale ("C")) expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xe5') in locale("C") expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xe5', locale ("C")) expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xe6') in locale("C") expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xe6', locale ("C")) expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xe7') in locale("C") expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xe7', locale ("C")) expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xe8') in locale("C") expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xe8', locale ("C")) expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xe9') in locale("C") expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xe9', locale ("C")) expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xea') in locale("C") expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xea', locale ("C")) expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xeb') in locale("C") expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xeb', locale ("C")) expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xec') in locale("C") expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xec', locale ("C")) expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xed') in locale("C") expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xed', locale ("C")) expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xee') in locale("C") expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xee', locale ("C")) expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xef') in locale("C") expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xef', locale ("C")) expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xf0') in locale("C") expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xf0', locale ("C")) expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xf1') in locale("C") expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xf1', locale ("C")) expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xf2') in locale("C") expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xf2', locale ("C")) expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xf3') in locale("C") expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xf3', locale ("C")) expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xf4') in locale("C") expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xf4', locale ("C")) expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xf5') in locale("C") expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xf5', locale ("C")) expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xf6') in locale("C") expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xf6', locale ("C")) expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xf7') in locale("C") expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xf7', locale ("C")) expected to hold for { print punct graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xf8') in locale("C") expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xf8', locale ("C")) expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xf9') in locale("C") expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xf9', locale ("C")) expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xfa') in locale("C") expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xfa', locale ("C")) expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xfb') in locale("C") expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xfb', locale ("C")) expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xfc') in locale("C") expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xfc', locale ("C")) expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xfd') in locale("C") expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xfd', locale ("C")) expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (4 lines):
# TEXT: ctype<wchar_t>::is(..., '\xfe') in locale("C") expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 577

# ASSERTION (S7) (4 lines):
# TEXT: is* ('\xfe', locale ("C")) expected to hold for { print lower alpha alnum graph }, got { }
# CLAUSE: lib.category.ctype
# LINE: 583

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\x88", ..., v) in locale("C") at offset 0; got 0 expected cntrl
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xcf\x94", ..., v) in locale("C") at offset 0; got 0 expected alpha | graph | print | upper
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xcf\x94", ..., v) in locale("C") at offset 1; got 0 expected cntrl
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"~G\xf0", ..., v) in locale("C") at offset 2; got 0 expected alpha | graph | lower | print
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"U\x8a\x81m", ..., v) in locale("C") at offset 1; got 0 expected cntrl
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"U\x8a\x81m", ..., v) in locale("C") at offset 2; got 0 expected cntrl
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"8\xd9!~\\", ..., v) in locale("C") at offset 1; got 0 expected alpha | graph | print | upper
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xed\xc38\a4@", ..., v) in locale("C") at offset 0; got 0 expected alpha | graph | lower | print
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xed\xc38\a4@", ..., v) in locale("C") at offset 1; got 0 expected alpha | graph | print | upper
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xfa\"\x05z\x916\xd7", ..., v) in locale("C") at offset 0; got 0 expected alpha | graph | lower | print
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xfa\"\x05z\x916\xd7", ..., v) in locale("C") at offset 4; got 0 expected cntrl
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xfa\"\x05z\x916\xd7", ..., v) in locale("C") at offset 6; got 0 expected graph | print | punct
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\x9a\x90\x10\xdb\x17\xd5\x9fh", ..., v) in locale("C") at offset 0; got 0 expected cntrl
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\x9a\x90\x10\xdb\x17\xd5\x9fh", ..., v) in locale("C") at offset 1; got 0 expected cntrl
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\x9a\x90\x10\xdb\x17\xd5\x9fh", ..., v) in locale("C") at offset 3; got 0 expected alpha | graph | print | upper
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\x9a\x90\x10\xdb\x17\xd5\x9fh", ..., v) in locale("C") at offset 5; got 0 expected alpha | graph | print | upper
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\x9a\x90\x10\xdb\x17\xd5\x9fh", ..., v) in locale("C") at offset 6; got 0 expected cntrl
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xa9,\xd5\x7f\x1f\xf3wP\x1e", ..., v) in locale("C") at offset 0; got 0 expected graph | print | punct
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xa9,\xd5\x7f\x1f\xf3wP\x1e", ..., v) in locale("C") at offset 2; got 0 expected alpha | graph | print | upper
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xa9,\xd5\x7f\x1f\xf3wP\x1e", ..., v) in locale("C") at offset 5; got 0 expected alpha | graph | lower | print
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xdeBp\xc9\x96\xc8\xc0h\xd6i", ..., v) in locale("C") at offset 0; got 0 expected alpha | graph | print | upper
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xdeBp\xc9\x96\xc8\xc0h\xd6i", ..., v) in locale("C") at offset 3; got 0 expected alpha | graph | print | upper
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xdeBp\xc9\x96\xc8\xc0h\xd6i", ..., v) in locale("C") at offset 4; got 0 expected cntrl
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xdeBp\xc9\x96\xc8\xc0h\xd6i", ..., v) in locale("C") at offset 5; got 0 expected alpha | graph | print | upper
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xdeBp\xc9\x96\xc8\xc0h\xd6i", ..., v) in locale("C") at offset 6; got 0 expected alpha | graph | print | upper
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xdeBp\xc9\x96\xc8\xc0h\xd6i", ..., v) in locale("C") at offset 8; got 0 expected alpha | graph | print | upper
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L",\xeb\xe1\xc8?\x88V\"@\xb3:", ..., v) in locale("C") at offset 1; got 0 expected alpha | graph | lower | print
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L",\xeb\xe1\xc8?\x88V\"@\xb3:", ..., v) in locale("C") at offset 2; got 0 expected alpha | graph | lower | print
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L",\xeb\xe1\xc8?\x88V\"@\xb3:", ..., v) in locale("C") at offset 3; got 0 expected alpha | graph | print | upper
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L",\xeb\xe1\xc8?\x88V\"@\xb3:", ..., v) in locale("C") at offset 5; got 0 expected cntrl
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L",\xeb\xe1\xc8?\x88V\"@\xb3:", ..., v) in locale("C") at offset 9; got 0 expected digit | graph | print | punct
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xf5E6\xd3\xc7\xf4\xb5\xa2\t\xed\xd2\x90", ..., v) in locale("C") at offset 0; got 0 expected alpha | graph | lower | print
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xf5E6\xd3\xc7\xf4\xb5\xa2\t\xed\xd2\x90", ..., v) in locale("C") at offset 3; got 0 expected alpha | graph | print | upper
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xf5E6\xd3\xc7\xf4\xb5\xa2\t\xed\xd2\x90", ..., v) in locale("C") at offset 4; got 0 expected alpha | graph | print | upper
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xf5E6\xd3\xc7\xf4\xb5\xa2\t\xed\xd2\x90", ..., v) in locale("C") at offset 5; got 0 expected alpha | graph | lower | print
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xf5E6\xd3\xc7\xf4\xb5\xa2\t\xed\xd2\x90", ..., v) in locale("C") at offset 6; got 0 expected graph | print | punct
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xf5E6\xd3\xc7\xf4\xb5\xa2\t\xed\xd2\x90", ..., v) in locale("C") at offset 7; got 0 expected graph | print | punct
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xf5E6\xd3\xc7\xf4\xb5\xa2\t\xed\xd2\x90", ..., v) in locale("C") at offset 8; got cntrl | space expected cntrl | print | space
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xf5E6\xd3\xc7\xf4\xb5\xa2\t\xed\xd2\x90", ..., v) in locale("C") at offset 9; got 0 expected alpha | graph | lower | print
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xf5E6\xd3\xc7\xf4\xb5\xa2\t\xed\xd2\x90", ..., v) in locale("C") at offset 10; got 0 expected alpha | graph | print | upper
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xf5E6\xd3\xc7\xf4\xb5\xa2\t\xed\xd2\x90", ..., v) in locale("C") at offset 11; got 0 expected cntrl
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xd7\x80I\xa3\xb35\xae\xd2VN6H\xb5", ..., v) in locale("C") at offset 0; got 0 expected graph | print | punct
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xd7\x80I\xa3\xb35\xae\xd2VN6H\xb5", ..., v) in locale("C") at offset 1; got 0 expected cntrl
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xd7\x80I\xa3\xb35\xae\xd2VN6H\xb5", ..., v) in locale("C") at offset 3; got 0 expected graph | print | punct
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xd7\x80I\xa3\xb35\xae\xd2VN6H\xb5", ..., v) in locale("C") at offset 4; got 0 expected digit | graph | print | punct
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xd7\x80I\xa3\xb35\xae\xd2VN6H\xb5", ..., v) in locale("C") at offset 6; got 0 expected graph | print | punct
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xd7\x80I\xa3\xb35\xae\xd2VN6H\xb5", ..., v) in locale("C") at offset 7; got 0 expected alpha | graph | print | upper
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xd7\x80I\xa3\xb35\xae\xd2VN6H\xb5", ..., v) in locale("C") at offset 12; got 0 expected graph | print | punct
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xc2 %\x8aU0\xa6\xb8\xcfb*\x06\x81#", ..., v) in locale("C") at offset 0; got 0 expected alpha | graph | print | upper
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xc2 %\x8aU0\xa6\xb8\xcfb*\x06\x81#", ..., v) in locale("C") at offset 3; got 0 expected cntrl
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xc2 %\x8aU0\xa6\xb8\xcfb*\x06\x81#", ..., v) in locale("C") at offset 6; got 0 expected graph | print | punct
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xc2 %\x8aU0\xa6\xb8\xcfb*\x06\x81#", ..., v) in locale("C") at offset 7; got 0 expected graph | print | punct
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xc2 %\x8aU0\xa6\xb8\xcfb*\x06\x81#", ..., v) in locale("C") at offset 8; got 0 expected alpha | graph | print | upper
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xc2 %\x8aU0\xa6\xb8\xcfb*\x06\x81#", ..., v) in locale("C") at offset 12; got 0 expected cntrl
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xfd\x82\x8e\xcf|{%MZ\xf3\xacb\xa5\xe7\x03", ..., v) in locale("C") at offset 0; got 0 expected alpha | graph | lower | print
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xfd\x82\x8e\xcf|{%MZ\xf3\xacb\xa5\xe7\x03", ..., v) in locale("C") at offset 1; got 0 expected cntrl
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xfd\x82\x8e\xcf|{%MZ\xf3\xacb\xa5\xe7\x03", ..., v) in locale("C") at offset 2; got 0 expected cntrl
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xfd\x82\x8e\xcf|{%MZ\xf3\xacb\xa5\xe7\x03", ..., v) in locale("C") at offset 3; got 0 expected alpha | graph | print | upper
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xfd\x82\x8e\xcf|{%MZ\xf3\xacb\xa5\xe7\x03", ..., v) in locale("C") at offset 9; got 0 expected alpha | graph | lower | print
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xfd\x82\x8e\xcf|{%MZ\xf3\xacb\xa5\xe7\x03", ..., v) in locale("C") at offset 10; got 0 expected graph | print | punct
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xfd\x82\x8e\xcf|{%MZ\xf3\xacb\xa5\xe7\x03", ..., v) in locale("C") at offset 12; got 0 expected graph | print | punct
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xfd\x82\x8e\xcf|{%MZ\xf3\xacb\xa5\xe7\x03", ..., v) in locale("C") at offset 13; got 0 expected alpha | graph | lower | print
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\xd8^", ..., v) in locale("C") at offset 0; got 0 expected alpha | graph | print | upper
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"_\f\x9a", ..., v) in locale("C") at offset 2; got 0 expected cntrl
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\x8ed\xd3h", ..., v) in locale("C") at offset 0; got 0 expected cntrl
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\x8ed\xd3h", ..., v) in locale("C") at offset 2; got 0 expected alpha | graph | print | upper
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\x9e\x83\xd5V;", ..., v) in locale("C") at offset 0; got 0 expected cntrl
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\x9e\x83\xd5V;", ..., v) in locale("C") at offset 1; got 0 expected cntrl
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\x9e\x83\xd5V;", ..., v) in locale("C") at offset 2; got 0 expected alpha | graph | print | upper
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L">:+\x8fNZ", ..., v) in locale("C") at offset 3; got 0 expected cntrl
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"s\xdeiW\xdcJ\x85", ..., v) in locale("C") at offset 1; got 0 expected alpha | graph | print | upper
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"s\xdeiW\xdcJ\x85", ..., v) in locale("C") at offset 4; got 0 expected alpha | graph | print | upper
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"s\xdeiW\xdcJ\x85", ..., v) in locale("C") at offset 6; got 0 expected cntrl
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\x06ex\xe6/N8\xd3", ..., v) in locale("C") at offset 3; got 0 expected alpha | graph | lower | print
# CLAUSE: lib.category.ctype
# LINE: 512

# ASSERTION (S7) (5 lines):
# TEXT: ctype<wchar_t>::is(L"\x06ex\xe6/N8\xd3", ..., v) in locale("C") at offset 7; got 0 expected alpha | graph | print | upper
# CLAUSE: lib.category.ctype
# LINE: 512
---------------------------------------------

Comments

[Farid Zaripov]

The reason of the assertions is that the ctype<char> and ctype<wchar_t> uses the same mask table (__rw_classic_tab in src/ctype.cpp), but MSVC crt uses the different tables for isxxx() and iswxxx() functions in "C" locale.

So that isprint ('\t') == 0; but iswprint (L'\t') == 64;

For the characters >= 0x80 the __rw_classic_tab table inited by zero values, but CRT isxxx() functions returns non-zero values.

[Martin Sebor]

Disabled formatting in Description.

[Martin Sebor]

Is that allowed by the C standard? If so, I wonder if there are any other platforms that use different masks between narrow and wide chars. Either way, we should be able to fix it by creating another table for the ctype<wchar_t> specialization for MSVC any any other platforms that behave this way (based on the result of a new config test).

[Farid Zaripov]

Seems that this behavior is not allowed by C99 standard (7.25.2.1 p2):

2 Each of the following functions returns true for each wide character that corresponds (as
if by a call to the wctob function) to a single-byte character for which the corresponding
character classification function from 7.4.1 returns true, except that the iswgraph and
iswpunct functions may differ with respect to wide characters other than L' ' that are
both printing and white-space wide characters.295)

295) For example, if the expression isalpha(wctob(wc)) evaluates to true, then the call
iswalpha(wc) also returns true. But, if the expression isgraph(wctob(wc)) evaluates to true
(which cannot occur for wc == L' ' of course), then either iswgraph(wc) or iswprint(wc)
&& iswspace(wc) is true, but not both.

[Martin Sebor]

In that light (since C doesn't allow it) I see two options:

1. open a bug with Microsoft and disable the tests
2. implement it as an extension on Windows

Incidentally, what does the native implementation do?

[Farid Zaripov]

Hmm, after carefully reading the C99 standard now I think that this behavior is allowed.

The standard says that if isxxx() returns true, then iswxxx() should also return true, but at the same time it doesn't says that if isxxx() returns false, the iswxxx() should return false.

The following test passes, asserting only in assert (-1 != ci); line when i == 255 due to wctob() returns -1:

test.cpp

#include <locale.h>
#include <ctype.h>
#include <wctype.h>
#include <wchar.h>
#include <assert.h>

int main()
{
	setlocale (LC_ALL, "C");

	for (int i = 0; i < 256; ++i) {
		const wint_t wi = btowc (i);
		assert (WEOF != wi);

		const int ci = wctob (wi);
		assert (-1 != ci);

		assert (char (ci) == char (i));

		assert (!!iswalnum (wi)  == !!isalnum (i) || !isalnum (i));
		assert (!!iswalpha (wi)  == !!isalpha (i) || !isalpha (i));
		assert (!!iswcntrl (wi)  == !!iscntrl (i) || !iscntrl (i));
		assert (!!iswdigit (wi)  == !!isdigit (i) || !isdigit (i));
		assert (!!iswlower (wi)  == !!islower (i) || !islower (i));
		assert (!!iswprint (wi)  == !!isprint (i) || !isprint (i));
		assert (!!iswspace (wi)  == !!isspace (i) || !isspace (i));
		assert (!!iswupper (wi)  == !!isupper (i) || !isupper (i));
		assert (!!iswxdigit (wi) == !!isxdigit (i) || !isxdigit (i));
#ifdef _MSC_VER
		// MSVC specific function
		assert (!!iswascii (wi)  == !!isascii (i) || !isascii (i));
#endif

		// does not supported in MSVC
		// assert (!!iswblank (wi)  == !!isblank (i));
		// the result may differ by the standard
		// assert (!!iswgraph (wi)  == !!isgraph (i));
		// the result may differ by the standard
		// assert (!!iswpunct (wi)  == !!ispunct (i));
	}

	return 0;
}

[Martin Sebor]

I agree with your reading of the C standard. Sounds like we have a bug after all.

[Farid Zaripov]

The proposed patch is attached.

ChangeLog:

• etc/config/src/EQUAL_CTYPE_MASK.cpp: New file to check that ctype mask's for char and wchar_t are equal.
• src/wctype.cpp [_RWSTD_NO_EQUAL_CTYPE_MASK] (__rw_classic_wide_tab): Static array with ctype
  mask's for wide characters.
  [_RWSTD_NO_EQUAL_CTYPE_MASK] (ctype<wchar_t>::ctype): Init __rw_classic_wide_tab array using
  __rw_get_mask().

[Martin Sebor]

I agree with the approach in principle but I have a concern with the efficiency of the patch: calling __rw_get_mask() 256 times in a loop will result in 256 calls to setlocale(), each of them involving locking and unlocking a mutex. That's far too costly. We need to optimize away all but one of these calls.

One way to do it would be to introduce an array of wchar_t initialized to consecutive values from L'\0' to L'\xff' and
call __rw_get_mask() on this array. However, that would mean adding 1K worth of otherwise useless data into the
library. I wonder if we could achieve the same effect by somehow tweaking __rw_get_mask() to do that for us without complicating the function too much (we don't want to add 1K worth of code to save 1K worth of data).

[Farid Zaripov]

Fixed thus: http://svn.apache.org/viewvc?rev=644666&view=rev
Will be closed after merging the changes in 4.2.x branch.

[Farid Zaripov]

Merged in 4.2.x branch thus: http://svn.apache.org/viewvc?view=rev&revision=648752