// try to encode some bytes at once with GetBytes
private void EncoderFallbackExceptions_GetBytes (
byte [] bytes,
int testno,
Encoder enc,
EncoderFallbackExceptionTest t)
{
try {
enc.GetBytes (
t.str.ToCharArray (), 0, t.str.Length,
bytes, 0, true);
Assert.IsTrue (
t.eindex.Length == 0,
String.Format (
"test#{0}-1: UNEXPECTED SUCCESS",
testno));
} catch(EncoderFallbackException 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.IsUnknownSurrogate (),
String.Format (
"test#{0}-1: Expected false not {1} in IsUnknownSurrogate().",
testno,
ex.IsUnknownSurrogate ()));
// NOTE: I know that in the previous check we
// have asserted that ex.IsUnknownSurrogate()
// is always false, but this does not mean that
// we don't have to take in consideration its
// real value for the next check.
if (ex.IsUnknownSurrogate ())
Assert.IsTrue (
ex.CharUnknownHigh == t.str[ex.Index]
&& ex.CharUnknownLow == t.str[ex.Index + 1],
String.Format (
"test#{0}-1: expected ({1:X}, {2:X}) not ({3:X}, {4:X}).",
testno,
t.str[ex.Index],
t.str[ex.Index + 1],
ex.CharUnknownHigh,
ex.CharUnknownLow));
else
Assert.IsTrue (
ex.CharUnknown == t.str[ex.Index],
String.Format (
"test#{0}-1: expected ({1:X}) not ({2:X}).",
testno,
t.str[ex.Index],
ex.CharUnknown));
enc.Reset ();
}
}
private void EncoderFallbackExceptions_Convert (
byte [] bytes,
int testno,
Encoder enc,
EncoderFallbackExceptionTest t,
int block_size)
{
int charsUsed, bytesUsed;
bool completed;
int ce = 0; // current exception
for (int c = 0; c < t.str.Length; ) {
//Console.WriteLine ("test#{0}-2-{1}: c={2}", testno, block_size, c);
try {
int bu = c + block_size > t.str.Length
? t.str.Length - c
: block_size;
enc.Convert (
t.str.ToCharArray (), c, bu,
bytes, 0, bytes.Length,
c + bu >= t.str.Length,
out charsUsed, out bytesUsed,
out completed);
c += charsUsed;
} catch (EncoderFallbackException ex) {
//Console.WriteLine (
// "test#{0}-2-{1}#{2}: Exception (Index={3}, UnknownSurrogate={4})",
// testno, block_size, ce,
// ex.Index, ex.IsUnknownSurrogate ());
Assert.IsTrue (
ce < t.eindex.Length,
String.Format (
"test#{0}-2-{1}#{2}: UNEXPECTED EXCEPTION (Index={3}, UnknownSurrogate={4})",
testno, block_size, ce,
ex.Index,
ex.IsUnknownSurrogate ()));
Assert.IsTrue (
ex.Index + c == t.eindex[ce],
String.Format (
"test#{0}-2-{1}#{2}: Expected exception at {3} not {4}.",
testno, block_size, ce,
t.eindex[ce],
ex.Index + c));
Assert.IsTrue (
!ex.IsUnknownSurrogate (),
String.Format (
"test#{0}-2-{1}#{2}: Expected false not {3} in IsUnknownSurrogate().",
testno, block_size, ce,
ex.IsUnknownSurrogate ()));
if (ex.IsUnknownSurrogate ()) {
Assert.IsTrue (
ex.CharUnknownHigh == t.str[ex.Index + c]
&& ex.CharUnknownLow == t.str[ex.Index + c + 1],
String.Format (
"test#{0}-2-{1}#{2}: expected ({3:X}, {4:X}) not ({5:X}, {6:X}).",
testno, block_size, ce,
t.str[ex.Index + c], t.str[ex.Index + c + 1],
ex.CharUnknownHigh, ex.CharUnknownLow));
c += ex.Index + 2;
} else {
Assert.IsTrue (
ex.CharUnknown == t.str[ex.Index + c],
String.Format (
"test#{0}-2-{1}#{2}: expected ({3:X}) not ({4:X}).",
testno, block_size, ce,
t.str[ex.Index + c],
ex.CharUnknown));
c += ex.Index + 1;
}
enc.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));
}
