# Copyright (C) 2016 and later: Unicode, Inc. and others.
# License & terms of use: http://www.unicode.org/copyright.html
# *******************************************************************************
# * Copyright (C) 2001-2009, International Business Machines
# * Corporation and others.  All Rights Reserved.
# *******************************************************************************
#
# test1.ucm
#
# Test file for MBCS conversion with single-byte codepage data.

<code_set_name>     "test1"
<mb_cur_max>        1
<mb_cur_min>        1
<uconv_class>       "MBCS"
<subchar>           \xff
<icu:state>         0, 5-9, a:0.s, ff

CHARMAP

# fromUnicode result is zero byte from other than U+0000
<U20ac>     \x00 |0
<U20ad>     \x00 |1

# nothing special
<U0005>     \x05 |0

# toUnicode result is fallback direct
<U0006>     \x06 |3

# toUnicode result is direct non-BMP code point
<U101234>   \x07 |0
<Ufebcd>    \x08 |1

#unassigned \x09

END CHARMAP
