// convert bytes to string using a fixed blocksize.
// If something bad happens, try to recover using the
// DecoderFallbackException info.
private void DecoderFallbackExceptions_Convert (
char [] chars,
int testno,
Decoder dec,
DecoderFallbackExceptionTest t,
int block_size)
{
int charsUsed, bytesUsed;
bool completed;
int ce = 0; // current exception
for (int c = 0; c < t.bytes.Length; ) {
try {
int bu = c + block_size > t.bytes.Length
? t.bytes.Length - c
: block_size;
dec.Convert (
t.bytes, c, bu,
chars, 0, chars.Length,
c + bu >= t.bytes.Length,
out bytesUsed, out charsUsed,
out completed);
c += bytesUsed;
} catch (DecoderFallbackException ex) {
Assert.IsTrue (
t.eindex.Length > ce,
String.Format (
"test#{0}-2-{1}#{2}: UNEXPECTED FAIL (c={3}, eIndex={4}, eBytesUnknwon={5})",
testno, block_size, ce, c,
ex.Index,
ex.BytesUnknown.Length));
Assert.IsTrue (
ex.Index + c == t.eindex[ce],
String.Format (
"test#{0}-2-{1}#{2}: Expected at {3} not {4}.",
testno, block_size, ce,
t.eindex[ce],
ex.Index + c));
Assert.IsTrue (
ex.BytesUnknown.Length == t.elen[ce],
String.Format (
"test#{0}-2-{1}#{2}: Expected BytesUnknown.Length of {3} not {4} @{5}.",
testno, block_size, ce,
t.elen[0], ex.BytesUnknown.Length, c));
for (int i = 0; i < ex.BytesUnknown.Length; i++)
Assert.IsTrue (
ex.BytesUnknown[i] == t.bytes[ex.Index + i + c],
String.Format (
"test#{0}-2-{1}#{2}: Expected byte {3:X} not {4:X} at {5}.",
testno, block_size, ce,
t.bytes[ex.Index + i + c],
ex.BytesUnknown[i],
ex.Index + i));
c += ex.BytesUnknown.Length + ex.Index;
dec.Reset ();
ce++;
}
}
Assert.IsTrue (
ce == t.eindex.Length,
String.Format (
"test#{0}-2-{1}: UNEXPECTED SUCCESS (expected {2} exceptions, but happened {3})",
testno, block_size, t.eindex.Length, ce));
}
public void DecoderFallbackExceptions ()
{
DecoderFallbackExceptionTest [] tests = new DecoderFallbackExceptionTest []
{
/* #1 */
new DecoderFallbackExceptionTest (
"Greek word 'kosme'",
new int [] { },
new int [] { },
new byte [] {
0xce, 0xba, 0xe1, 0xbd, 0xb9, 0xcf,
0x83, 0xce, 0xbc, 0xce, 0xb5 }),
/* #2 */
new DecoderFallbackExceptionTest (
"First possible sequence of 1 byte",
new int [] { },
new int [] { },
new byte [] { 0x00 }),
/* #3 */
new DecoderFallbackExceptionTest (
"First possible sequence of 2 bytes",
new int [] { },
new int [] { },
new byte [] { 0xc2, 0x80 }),
/* #4 */
new DecoderFallbackExceptionTest (
"First possible sequence of 3 bytes",
new int [] { },
new int [] { },
new byte [] { 0xe0, 0xa0, 0x80 }),
/* #5 */
new DecoderFallbackExceptionTest (
"First possible sequence of 4 bytes",
new int [] { },
new int [] { },
new byte [] { 0xf0, 0x90, 0x80, 0x80 }),
/* #6 */
new DecoderFallbackExceptionTest (
"First possible sequence of 5 bytes",
new int [] { 0, 1, 2, 3, 4 },
new int [] { 1, 1, 1, 1, 1 },
new byte [] { 0xf8, 0x88, 0x80, 0x80, 0x80 }),
/* #7 */
new DecoderFallbackExceptionTest (
"First possible sequence of 6 bytes",
new int [] { 0, 1, 2, 3, 4, 5 },
new int [] { 1, 1, 1, 1, 1, 1 },
new byte [] {
0xfc, 0x84, 0x80, 0x80, 0x80, 0x80 }),
/* #8 */
new DecoderFallbackExceptionTest (
"Last possible sequence of 1 byte",
new int [] { },
new int [] { },
new byte [] { 0x7f }),
/* #9 */
new DecoderFallbackExceptionTest (
"Last possible sequence of 2 bytes",
new int [] { },
new int [] { },
new byte [] { 0xdf, 0xbf }),
/* #10 */
new DecoderFallbackExceptionTest (
"Last possible sequence of 3 bytes",
new int [] { },
new int [] { },
new byte [] { 0xef, 0xbf, 0xbf }),
/* #11 */
new DecoderFallbackExceptionTest (
"Last possible sequence of 4 bytes",
new int [] { 0, 1, 2, 3 },
new int [] { 1, 1, 1, 1 },
new byte [] { 0xf7, 0xbf, 0xbf, 0xbf }),
/* #12 */
new DecoderFallbackExceptionTest (
"Last possible sequence of 5 bytes",
new int [] { 0, 1, 2, 3, 4 },
new int [] { 1, 1, 1, 1, 1 },
new byte [] { 0xfb, 0xbf, 0xbf, 0xbf, 0xbf }),
/* #13 */
new DecoderFallbackExceptionTest (
"Last possible sequence of 6 bytes",
new int [] { 0, 1, 2, 3, 4, 5 },
new int [] { 1, 1, 1, 1, 1, 1 },
new byte [] { 0xfd, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf }),
/* #14 */
new DecoderFallbackExceptionTest (
"U-0000D7FF = ed 9f bf",
new int [] { },
new int [] { },
new byte [] { 0xed, 0x9f, 0xbf }),
/* #15 */
new DecoderFallbackExceptionTest (
"U-0000E000 = ee 80 80",
new int [] { },
new int [] { },
new byte [] { 0xee, 0x80, 0x80 }),
/* #16 */
new DecoderFallbackExceptionTest (
"U-0000FFFD = ef bf bd",
new int [] { },
new int [] { },
new byte [] { 0xef, 0xbf, 0xbd }),
/* #17 */
new DecoderFallbackExceptionTest (
"U-0010FFFF = f4 8f bf bf",
new int [] { },
new int [] { },
new byte [] { 0xf4, 0x8f, 0xbf, 0xbf }),
/* #18 */
new DecoderFallbackExceptionTest (
"U-00110000 = f4 90 80 80",
new int [] { 0, 2, 3 },
new int [] { 2, 1, 1 },
new byte [] { 0xf4, 0x90, 0x80, 0x80 }),
/* #19 */
new DecoderFallbackExceptionTest (
"First continuation byte 0x80",
new int [] { 0 },
new int [] { 1 },
new byte [] { 0x80 }),
/* #20 */
new DecoderFallbackExceptionTest (
"Last continuation byte 0xbf",
new int [] { 0 },
new int [] { 1 },
new byte [] { 0xbf }),
/* #21 */
new DecoderFallbackExceptionTest (
"2 continuation bytes",
new int [] { 0, 1 },
new int [] { 1, 1 },
new byte [] { 0x80, 0xbf }),
/* #22 */
new DecoderFallbackExceptionTest (
"3 continuation bytes",
new int [] { 0, 1, 2 },
new int [] { 1, 1, 1 },
new byte [] { 0x80, 0xbf, 0x80 }),
/* #23 */
new DecoderFallbackExceptionTest (
"4 continuation bytes",
new int [] { 0, 1, 2, 3 },
new int [] { 1, 1, 1, 1 },
new byte [] { 0x80, 0xbf, 0x80, 0xbf }),
/* #24 */
new DecoderFallbackExceptionTest (
"5 continuation bytes",
new int [] { 0, 1, 2, 3, 4 },
new int [] { 1, 1, 1, 1, 1 },
new byte [] { 0x80, 0xbf, 0x80, 0xbf, 0x80 }),
/* #25 */
new DecoderFallbackExceptionTest (
"6 continuation bytes",
new int [] { 0, 1, 2, 3, 4, 5 },
new int [] { 1, 1, 1, 1, 1, 1 },
new byte [] {
0x80, 0xbf, 0x80, 0xbf, 0x80, 0xbf }),
/* #26 */
new DecoderFallbackExceptionTest (
"7 continuation bytes",
new int [] { 0, 1, 2, 3, 4, 5, 6 },
new int [] { 1, 1, 1, 1, 1, 1, 1 },
new byte [] {
0x80, 0xbf, 0x80, 0xbf, 0x80, 0xbf,
0x80 }),
/* #27 */
new DecoderFallbackExceptionTest (
"Sequence of all 64 continuation bytes",
new int [] {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
60, 61, 62, 63 },
new int [] {
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1 },
new byte [] {
0x80, 0x81, 0x82, 0x83, 0x84, 0x85,
0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b,
0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91,
0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d,
0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3,
0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9,
0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5,
0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb,
0xbc, 0xbd, 0xbe, 0xbf }),
/* #28 */
new DecoderFallbackExceptionTest (
"All 32 first bytes of 2-byte sequences (0xc0-0xdf), each followed by a space character",
new int [] {
0, 2, 4, 6, 8,
10, 12, 14, 16, 18,
20, 22, 24, 26, 28,
30, 32, 34, 36, 38,
40, 42, 44, 46, 48,
50, 52, 54, 56, 58,
60, 62 },
new int [] {
1, 1, 1, 1, 1,
1, 1, 1, 1, 1,
1, 1, 1, 1, 1,
1, 1, 1, 1, 1,
1, 1, 1, 1, 1,
1, 1, 1, 1, 1,
1, 1 },
new byte [] {
0xc0, 0x20, 0xc1, 0x20, 0xc2, 0x20,
0xc3, 0x20, 0xc4, 0x20, 0xc5, 0x20,
0xc6, 0x20, 0xc7, 0x20, 0xc8, 0x20,
0xc9, 0x20, 0xca, 0x20, 0xcb, 0x20,
0xcc, 0x20, 0xcd, 0x20, 0xce, 0x20,
0xcf, 0x20, 0xd0, 0x20, 0xd1, 0x20,
0xd2, 0x20, 0xd3, 0x20, 0xd4, 0x20,
0xd5, 0x20, 0xd6, 0x20, 0xd7, 0x20,
0xd8, 0x20, 0xd9, 0x20, 0xda, 0x20,
0xdb, 0x20, 0xdc, 0x20, 0xdd, 0x20,
0xde, 0x20, 0xdf, 0x20 }),
/* #29 */
new DecoderFallbackExceptionTest (
"All 16 first bytes of 3-byte sequences (0xe0-0xef), each followed by a space character",
new int [] {
0, 2, 4, 6, 8,
10, 12, 14, 16, 18,
20, 22, 24, 26, 28,
30 },
new int [] {
1, 1, 1, 1, 1,
1, 1, 1, 1, 1,
1, 1, 1, 1, 1,
1 },
new byte [] {
0xe0, 0x20, 0xe1, 0x20, 0xe2, 0x20,
0xe3, 0x20, 0xe4, 0x20, 0xe5, 0x20,
0xe6, 0x20, 0xe7, 0x20, 0xe8, 0x20,
0xe9, 0x20, 0xea, 0x20, 0xeb, 0x20,
0xec, 0x20, 0xed, 0x20, 0xee, 0x20,
0xef, 0x20 }),
/* #30 */
new DecoderFallbackExceptionTest (
"All 8 first bytes of 4-byte sequences (0xf0-0xf7), each followed by a space character",
new int [] { 0, 2, 4, 6, 8, 10, 12, 14 },
new int [] { 1, 1, 1, 1, 1, 1, 1, 1 },
new byte [] {
0xf0, 0x20, 0xf1, 0x20, 0xf2, 0x20,
0xf3, 0x20, 0xf4, 0x20, 0xf5, 0x20,
0xf6, 0x20, 0xf7, 0x20 }),
/* #31 */
new DecoderFallbackExceptionTest (
"All 4 first bytes of 5-byte sequences (0xf8-0xfb), each followed by a space character",
new int [] { 0, 2, 4, 6 },
new int [] { 1, 1, 1, 1 },
new byte [] {
0xf8, 0x20, 0xf9, 0x20, 0xfa, 0x20,
0xfb, 0x20 }),
/* #32 */
new DecoderFallbackExceptionTest (
"All 2 first bytes of 6-byte sequences (0xfc-0xfd), each followed by a space character",
new int [] { 0, 2 },
new int [] { 1, 1 },
new byte [] { 0xfc, 0x20, 0xfd, 0x20 }),
/* #33 */
new DecoderFallbackExceptionTest (
"2-byte sequence with last byte missing",
new int [] { 0 },
new int [] { 1 },
new byte [] { 0xc0 }),
/* #34 */
new DecoderFallbackExceptionTest (
"3-byte sequence with last byte missing",
new int [] { 0 },
new int [] { 2 },
new byte [] { 0xe0, 0x80 }),
/* #35 */
new DecoderFallbackExceptionTest (
"4-byte sequence with last byte missing",
new int [] { 0, 2 },
new int [] { 2, 1 },
new byte [] { 0xf0, 0x80, 0x80 }),
/* #36 */
new DecoderFallbackExceptionTest (
"5-byte sequence with last byte missing",
new int [] { 0, 1, 2, 3 },
new int [] { 1, 1, 1, 1 },
new byte [] { 0xf8, 0x80, 0x80, 0x80 }),
/* #37 */
new DecoderFallbackExceptionTest (
"6-byte sequence with last byte missing",
new int [] { 0, 1, 2, 3, 4 },
new int [] { 1, 1, 1, 1, 1 },
new byte [] { 0xfc, 0x80, 0x80, 0x80, 0x80 }),
/* #38 */
new DecoderFallbackExceptionTest (
"2-byte sequence with last byte missing",
new int [] { 0 },
new int [] { 1 },
new byte [] { 0xdf }),
/* #39 */
new DecoderFallbackExceptionTest (
"3-byte sequence with last byte missing",
new int [] { 0 },
new int [] { 2 },
new byte [] { 0xef, 0xbf }),
/* #40 */
new DecoderFallbackExceptionTest (
"4-byte sequence with last byte missing",
new int [] { 0, 1, 2 },
new int [] { 1, 1, 1 },
new byte [] { 0xf7, 0xbf, 0xbf }),
/* #41 */
new DecoderFallbackExceptionTest (
"5-byte sequence with last byte missing",
new int [] { 0, 1, 2, 3 },
new int [] { 1, 1, 1, 1 },
new byte [] { 0xfb, 0xbf, 0xbf, 0xbf }),
/* #42 */
new DecoderFallbackExceptionTest (
"6-byte sequence with last byte missing",
new int [] { 0, 1, 2, 3, 4 },
new int [] { 1, 1, 1, 1, 1 },
new byte [] { 0xfd, 0xbf, 0xbf, 0xbf, 0xbf }),
/* #43 */
new DecoderFallbackExceptionTest (
"All the 10 sequences of 3.3 concatenated",
new int [] {
0, 1, 3,
5, 6, 7, 8, 9,
10, 11, 12, 13, 14,
15, 16, 18, 19,
20, 21, 22, 23, 24,
25, 26, 27, 28, 29 },
new int [] {
1, 2, 2,
1, 1, 1, 1, 1,
1, 1, 1, 1, 1,
1, 2, 1, 1,
1, 1, 1, 1, 1,
1, 1, 1, 1, 1 },
new byte [] {
0xc0, 0xe0, 0x80, 0xf0, 0x80, 0x80,
0xf8, 0x80, 0x80, 0x80, 0xfc, 0x80,
0x80, 0x80, 0x80, 0xdf, 0xef, 0xbf,
0xf7, 0xbf, 0xbf, 0xfb, 0xbf, 0xbf,
0xbf, 0xfd, 0xbf, 0xbf, 0xbf, 0xbf }),
/* #44 */
new DecoderFallbackExceptionTest (
"Bad chars fe",
new int [] { 0 },
new int [] { 1 },
new byte [] { 0xfe }),
/* #45 */
new DecoderFallbackExceptionTest (
"Bad chars ff",
new int [] { 0 },
new int [] { 1 },
new byte [] { 0xff }),
/* #46 */
new DecoderFallbackExceptionTest (
"Bad chars fe fe ff ff",
new int [] { 0, 1, 2, 3 },
new int [] { 1, 1, 1, 1 },
new byte [] { 0xfe, 0xfe, 0xff, 0xff }),
/* #47 */
new DecoderFallbackExceptionTest (
"Overlong U+002F = c0 af",
new int [] { 0, 1 },
new int [] { 1, 1 },
new byte [] { 0xc0, 0xaf }),
/* #48 */
new DecoderFallbackExceptionTest (
"Overlong U+002F = e0 80 af",
new int [] { 0, 2 },
new int [] { 2, 1 },
new byte [] { 0xe0, 0x80, 0xaf }),
/* #49 */
new DecoderFallbackExceptionTest (
"Overlong U+002F = f0 80 80 af",
new int [] { 0, 2, 3 },
new int [] { 2, 1, 1 },
new byte [] { 0xf0, 0x80, 0x80, 0xaf }),
/* #50 */
new DecoderFallbackExceptionTest (
"Overlong U+002F = f8 80 80 80 af",
new int [] { 0, 1, 2, 3, 4 },
new int [] { 1, 1, 1, 1, 1 },
new byte [] { 0xf8, 0x80, 0x80, 0x80, 0xaf }),
/* #51 */
new DecoderFallbackExceptionTest (
"Overlong U+002F = fc 80 80 80 80 af",
new int [] { 0, 1, 2, 3, 4, 5 },
new int [] { 1, 1, 1, 1, 1, 1 },
new byte [] {
0xfc, 0x80, 0x80, 0x80, 0x80, 0xaf }),
/* #52 */
new DecoderFallbackExceptionTest (
"Maximum overlong U-0000007F",
new int [] { 0, 1 },
new int [] { 1, 1 },
new byte [] { 0xc1, 0xbf }),
/* #53 */
new DecoderFallbackExceptionTest (
"Maximum overlong U-000007FF",
new int [] { 0, 2 },
new int [] { 2, 1, },
new byte [] { 0xe0, 0x9f, 0xbf }),
/* #54 */
new DecoderFallbackExceptionTest (
"Maximum overlong U-0000FFFF",
new int [] { 0, 2, 3 },
new int [] { 2, 1, 1 },
new byte [] { 0xf0, 0x8f, 0xbf, 0xbf }),
/* #55 */
new DecoderFallbackExceptionTest (
"Maximum overlong U-001FFFFF",
new int [] { 0, 1, 2, 3, 4 },
new int [] { 1, 1, 1, 1, 1 },
new byte [] { 0xf8, 0x87, 0xbf, 0xbf, 0xbf }),
/* #56 */
new DecoderFallbackExceptionTest (
"Maximum overlong U-03FFFFFF",
new int [] { 0, 1, 2, 3, 4, 5 },
new int [] { 1, 1, 1, 1, 1, 1 },
new byte [] {
0xfc, 0x83, 0xbf, 0xbf, 0xbf, 0xbf }),
/* #57 */
new DecoderFallbackExceptionTest (
"Null overlong c0 80",
new int [] { 0, 1 },
new int [] { 1, 1 },
new byte [] { 0xc0, 0x80, 0x22 }),
/* #58 */
new DecoderFallbackExceptionTest (
"Null overlong e0 80 80",
new int [] { 0, 2 },
new int [] { 2, 1 },
new byte [] { 0xe0, 0x80, 0x80 }),
/* #59 */
new DecoderFallbackExceptionTest (
"Null overlong f0 80 80 80",
new int [] { 0, 2, 3 },
new int [] { 2, 1, 1 },
new byte [] { 0xf0, 0x80, 0x80, 0x80 }),
/* #60 */
new DecoderFallbackExceptionTest (
"Null overlong f8 80 80 80 80",
new int [] { 0, 1, 2, 3, 4 },
new int [] { 1, 1, 1, 1, 1 },
new byte [] { 0xf8, 0x80, 0x80, 0x80, 0x80 }),
/* #61 */
new DecoderFallbackExceptionTest (
"Null overlong fc 80 80 80 80 80",
new int [] { 0, 1, 2, 3, 4, 5 },
new int [] { 1, 1, 1, 1, 1, 1 },
new byte [] {
0xfc, 0x80, 0x80, 0x80, 0x80, 0x80 }),
/* #62 */
new DecoderFallbackExceptionTest (
"Single UTF-16 surrogate U+D800",
new int [] { 0, 2 },
new int [] { 2, 1 },
new byte [] { 0xed, 0xa0, 0x80 }),
/* #63 */
new DecoderFallbackExceptionTest (
"Single UTF-16 surrogate U+DB7F",
new int [] { 0, 2 },
new int [] { 2, 1 },
new byte [] { 0xed, 0xad, 0xbf }),
/* #64 */
new DecoderFallbackExceptionTest (
"Single UTF-16 surrogate U+DB80",
new int [] { 0, 2 },
new int [] { 2, 1 },
new byte [] { 0xed, 0xae, 0x80 }),
/* #65 */
new DecoderFallbackExceptionTest (
"Single UTF-16 surrogate U+DBFF",
new int [] { 0, 2 },
new int [] { 2, 1 },
new byte [] { 0xed, 0xaf, 0xbf }),
/* #66 */
new DecoderFallbackExceptionTest (
"Single UTF-16 surrogate U+DC00",
new int [] { 0, 2 },
new int [] { 2, 1 },
new byte [] { 0xed, 0xb0, 0x80 }),
/* #67 */
new DecoderFallbackExceptionTest (
"Single UTF-16 surrogate U+DF80",
new int [] { 0, 2 },
new int [] { 2, 1 },
new byte [] { 0xed, 0xbe, 0x80 }),
/* #68 */
new DecoderFallbackExceptionTest (
"Single UTF-16 surrogate U+DFFF",
new int [] { 0, 2 },
new int [] { 2, 1 },
new byte [] { 0xed, 0xbf, 0xbf }),
/* #69 */
new DecoderFallbackExceptionTest (
"Paired UTF-16 surrogate U+D800 U+DC00",
new int [] { 0, 2, 3, 5 },
new int [] { 2, 1, 2, 1 },
new byte [] {
0xed, 0xa0, 0x80, 0xed, 0xb0, 0x80 }),
/* #70 */
new DecoderFallbackExceptionTest (
"Paired UTF-16 surrogate U+D800 U+DFFF",
new int [] { 0, 2, 3, 5 },
new int [] { 2, 1, 2, 1 },
new byte [] {
0xed, 0xa0, 0x80, 0xed, 0xbf, 0xbf }),
/* #71 */
new DecoderFallbackExceptionTest (
"Paired UTF-16 surrogate U+DB7F U+DC00",
new int [] { 0, 2, 3, 5 },
new int [] { 2, 1, 2, 1 },
new byte [] {
0xed, 0xad, 0xbf, 0xed, 0xb0, 0x80 }),
/* #72 */
new DecoderFallbackExceptionTest (
"Paired UTF-16 surrogate U+DB7F U+DFFF",
new int [] { 0, 2, 3, 5 },
new int [] { 2, 1, 2, 1 },
new byte [] {
0xed, 0xad, 0xbf, 0xed, 0xbf, 0xbf }),
/* #73 */
new DecoderFallbackExceptionTest (
"Paired UTF-16 surrogate U+DB80 U+DC00",
new int [] { 0, 2, 3, 5 },
new int [] { 2, 1, 2, 1 },
new byte [] {
0xed, 0xae, 0x80, 0xed, 0xb0, 0x80 }),
/* #74 */
new DecoderFallbackExceptionTest (
"Paired UTF-16 surrogate U+DB80 U+DFFF",
new int [] { 0, 2, 3, 5 },
new int [] { 2, 1, 2, 1 },
new byte [] {
0xed, 0xae, 0x80, 0xed, 0xbf, 0xbf }),
/* #75 */
new DecoderFallbackExceptionTest (
"Paired UTF-16 surrogate U+DBFF U+DC00",
new int [] { 0, 2, 3, 5 },
new int [] { 2, 1, 2, 1 },
new byte [] {
0xed, 0xaf, 0xbf, 0xed, 0xb0, 0x80 }),
/* #76 */
new DecoderFallbackExceptionTest (
"Paired UTF-16 surrogate U+DBFF U+DFFF",
new int [] { 0, 2, 3, 5 },
new int [] { 2, 1, 2, 1 },
new byte [] {
0xed, 0xaf, 0xbf, 0xed, 0xbf, 0xbf }),
/* #77 */
new DecoderFallbackExceptionTest (
"Illegal code position U+FFFE",
new int [] { },
new int [] { },
new byte [] { 0xef, 0xbf, 0xbe }),
/* #78 */
new DecoderFallbackExceptionTest (
"Illegal code position U+FFFF",
new int [] { },
new int [] { },
new byte [] { 0xef, 0xbf, 0xbf }),
};
Encoding utf8 = Encoding.GetEncoding (
"utf-8",
new EncoderExceptionFallback(),
new DecoderExceptionFallback());
Decoder dec = utf8.GetDecoder ();
char [] chars;
for(int t = 0; t < tests.Length; t++) {
chars = new char [utf8.GetMaxCharCount (tests[t].bytes.Length)];
// #1 complete conversion
DecoderFallbackExceptions_GetChars (chars, t+1, dec, tests[t]);
// #2 convert with several block_sizes
for (int bs = 1; bs <= tests[t].bytes.Length; bs++)
DecoderFallbackExceptions_Convert (chars, t+1, dec, tests[t], bs);
}
}
// try to convert the all current test's bytes with Getchars()
// in only one step
private void DecoderFallbackExceptions_GetChars (
char [] chars,
int testno,
Decoder dec,
DecoderFallbackExceptionTest t)
{
try {
dec.GetChars (t.bytes, 0, t.bytes.Length, chars, 0, true);
Assert.IsTrue (
t.eindex.Length == 0,
String.Format (
"test#{0}-1: UNEXPECTED SUCCESS",
testno));
} catch(DecoderFallbackException ex) {
Assert.IsTrue (
t.eindex.Length > 0,
String.Format (
"test#{0}-1: UNEXPECTED FAIL",
testno));
Assert.IsTrue (
ex.Index == t.eindex[0],
String.Format (
"test#{0}-1: Expected exception at {1} not {2}.",
testno,
t.eindex[0],
ex.Index));
Assert.IsTrue (
ex.BytesUnknown.Length == t.elen[0],
String.Format (
"test#{0}-1: Expected BytesUnknown.Length of {1} not {2}.",
testno,
t.elen[0],
ex.BytesUnknown.Length));
for (int i = 0; i < ex.BytesUnknown.Length; i++)
Assert.IsTrue (
ex.BytesUnknown[i] == t.bytes[ex.Index + i],
String.Format (
"test#{0}-1: expected byte {1:X} not {2:X} at {3}.",
testno,
t.bytes[ex.Index + i],
ex.BytesUnknown[i],
ex.Index + i));
dec.Reset ();
}
}
