public static void DecoderExceptionFallbackBufferTest()
{
Decoder decoder = Encoding.GetEncoding("us-ascii", new EncoderExceptionFallback(), new DecoderExceptionFallback()).GetDecoder();
byte [] bytes = new byte [] { 0xFF, 0xFF };
char [] chars = new char [bytes.Length];
Assert.Throws <DecoderFallbackException>(() => decoder.GetChars(bytes, 0, 2, chars, 2));
DecoderFallbackBuffer fallbackBuffer = decoder.FallbackBuffer;
Assert.True(fallbackBuffer is DecoderExceptionFallbackBuffer, "Expected to get DecoderExceptionFallbackBuffer type");
Assert.Throws <DecoderFallbackException>(() => fallbackBuffer.Fallback(bytes, 0));
Assert.Throws <DecoderFallbackException>(() => fallbackBuffer.Fallback(new byte [] { 0x40, 0x60 }, 0));
Assert.Equal(0, fallbackBuffer.Remaining);
Assert.Equal('\u0000', fallbackBuffer.GetNextChar());
Assert.False(fallbackBuffer.MovePrevious(), "MovePrevious expected to always return false");
fallbackBuffer.Reset();
Assert.Equal(0, fallbackBuffer.Remaining);
Assert.Equal('\u0000', fallbackBuffer.GetNextChar());
}
public override int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex)
{
int byteEnd = byteIndex + byteCount;
int outputChars = 0;
while (byteIndex < byteEnd)
{
byte b = bytes[byteIndex];
char val;
if (!_map.Mapping.TryGetValue(b, out val))
{
DecoderFallbackBuffer dfb = DecoderFallback.CreateFallbackBuffer();
if (dfb.Fallback(new[] { b }, 0))
{
while (dfb.Remaining != 0)
{
chars[charIndex++] = (char)((int)_map.Mapping[(int)dfb.GetNextChar()]);
outputChars++;
}
}
}
else
{
chars[charIndex++] = val;
outputChars++;
}
byteIndex++;
}
return(outputChars);
}
public override int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex)
{
int byteEnd = byteIndex + byteCount;
int outputChars = 0;
while (byteIndex < byteEnd)
{
byte b = bytes[byteIndex];
if (b > 0x7f)
{
DecoderFallbackBuffer dfb = DecoderFallback.CreateFallbackBuffer();
if (dfb.Fallback(new byte[] { b }, byteIndex))
{
while (dfb.Remaining != 0)
{
chars[charIndex++] = dfb.GetNextChar();
outputChars++;
}
}
}
else
{
chars[charIndex++] = (char)b;
outputChars++;
}
byteIndex++;
}
return(outputChars);
}
private int GetCharCount(byte[] bytes, int index, int count, DecoderFallbackBuffer dfb)
{
int byteEnd = index + count;
int outputChars = 0;
while (index < byteEnd)
{
byte b = bytes[index];
if (b > 0x7f)
{
if (dfb == null)
{
dfb = DecoderFallback.CreateFallbackBuffer();
}
try {
if (dfb.Fallback(new[] { b }, index))
{
outputChars += dfb.Remaining;
while (dfb.GetNextChar() != char.MinValue) /* empty */ } {
}
} catch (DecoderFallbackException ex) {
var dfe = new DecoderFallbackException("ordinal not in range(128)", ex.BytesUnknown, ex.Index);
dfe.Data.Add("encoding", EncodingName);
throw dfe;
}
}
else
{
outputChars++;
}
index++;
}
return(outputChars);
}
void DecodeInvalidBytes(Stream stream, Action <Stream, string> decodedText, params byte[] data)
{
DecoderFallbackBuffer fallback = DecoderFallback.CreateFallbackBuffer();
bool result = fallback.Fallback(data, 0);
while (result && fallback.Remaining > 0)
{
decodedText(stream, $"{fallback.GetNextChar()}");
}
}
public static void DecoderReplacementFallbackBufferTest()
{
Decoder decoder = Encoding.GetEncoding("us-ascii", new EncoderReplacementFallback(), new DecoderReplacementFallback()).GetDecoder();
byte [] bytes = new byte [] { 0xFF, 0xFF };
char [] chars = new char [bytes.Length];
DecoderFallbackBuffer fallbackBuffer = decoder.FallbackBuffer;
Assert.True(fallbackBuffer is DecoderReplacementFallbackBuffer, "Expected to get DecoderReplacementFallbackBuffer type");
Assert.True(fallbackBuffer.Fallback(bytes, 0), "Expected we fallback on the given buffer");
Assert.Equal(1, fallbackBuffer.Remaining);
Assert.False(fallbackBuffer.MovePrevious(), "Expected we cannot move back on the replacement buffer as we are at the Beginning of the buffer");
Assert.Equal('?', fallbackBuffer.GetNextChar());
Assert.True(fallbackBuffer.MovePrevious(), "Expected we can move back on the replacement buffer");
Assert.Equal('?', fallbackBuffer.GetNextChar());
fallbackBuffer.Reset();
Assert.Equal(0, fallbackBuffer.Remaining);
Assert.Equal('\u0000', fallbackBuffer.GetNextChar());
Assert.False(fallbackBuffer.MovePrevious(), "Expected we cannot move back on the replacement buffer as we are rest the buffer");
}
public override int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex)
{
int byteEnd = byteIndex + byteCount;
int outputChars = 0;
while (byteIndex < byteEnd)
{
byte b = bytes[byteIndex];
object val;
object obj = ScriptingRuntimeHelpers.Int32ToObject((int)b);
if (!_map.TryGetValue(obj, out val) || val == null)
{
DecoderFallbackBuffer dfb = DecoderFallback.CreateFallbackBuffer();
if (dfb.Fallback(new[] { b }, 0))
{
while (dfb.Remaining != 0)
{
chars[charIndex++] = dfb.GetNextChar();
outputChars++;
}
}
}
else if (val is string)
{
string v = val as string;
for (int i = 0; i < v.Length; i++)
{
chars[charIndex++] = v[i];
outputChars++;
}
}
else if (val is int)
{
chars[charIndex++] = (char)(int)val;
outputChars++;
}
else
{
throw PythonOps.TypeError("charmap must be an int, str, or None");
}
byteIndex++;
}
return(outputChars);
}
private int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex, DecoderFallbackBuffer dfb)
{
int byteEnd = byteIndex + byteCount;
int outputChars = 0;
while (byteIndex < byteEnd)
{
byte b = bytes[byteIndex];
#if FEATURE_ENCODING
if (b > 0x7f)
{
if (dfb == null)
{
dfb = DecoderFallback.CreateFallbackBuffer();
}
try {
if (dfb.Fallback(new[] { b }, byteIndex))
{
while (dfb.Remaining != 0)
{
chars[charIndex++] = dfb.GetNextChar();
outputChars++;
}
}
} catch (DecoderFallbackException ex) {
var dfe = new DecoderFallbackException("ordinal not in range(128)", ex.BytesUnknown, ex.Index);
dfe.Data.Add("encoding", EncodingName);
throw dfe;
}
}
else
{
chars[charIndex++] = (char)b;
outputChars++;
}
#else
chars[charIndex++] = (char)b;
outputChars++;
#endif
byteIndex++;
}
return(outputChars);
}
public override char GetNextChar()
{
return(_parentBuffer == null ? (char)0 : _parentBuffer.GetNextChar());
}
int GetChars(byte[] bytes, int byteIndex, int byteCount,
char[] chars, int charIndex,
ref DecoderFallbackBuffer buffer)
{
if (bytes == null)
throw new ArgumentNullException("bytes");
if (chars == null)
throw new ArgumentNullException("chars");
if (byteIndex < 0 || byteIndex > bytes.Length)
throw new ArgumentOutOfRangeException("byteIndex");
if (byteCount < 0 || byteCount > (bytes.Length - byteIndex))
throw new ArgumentOutOfRangeException("byteCount");
if (charIndex < 0 || charIndex > chars.Length)
throw new ArgumentOutOfRangeException("charIndex");
if ((chars.Length - charIndex) < byteCount)
throw new ArgumentException("Insufficient Space");
var count = byteCount;
while (count-- > 0)
{
var c = (char) bytes[byteIndex++];
if (c < '\x80')
chars[charIndex++] = c;
else
{
if (buffer == null)
buffer = DecoderFallback.CreateFallbackBuffer();
var thisByte = new byte[] {bytes[byteIndex - 1]};
buffer.Fallback(thisByte, 0);
while (buffer.Remaining > 0)
{
if (charIndex < chars.Length)
{
chars[charIndex++] = buffer.GetNextChar();
continue;
}
throw new ArgumentException(
"The output char buffer is too small to contain the " +
"decoded characters.");
}
}
}
return byteCount;
}
public override char GetNextChar()
{
return(buffer.GetNextChar());
}
private int GetCharsInternal(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex)
{
var outpos = byteIndex;
var escape = false;
for (var inpos = byteIndex; inpos < (byteIndex + byteCount); inpos++)
{
var @byte = bytes[inpos];
var codepoint = NOCODE;
var extended = false;
if (escape)
{
if (@byte == 0x65)
{
codepoint = '\x20AC';
}
else
{
codepoint = GsmToUcs2Extended[@byte];
}
// If char is not a valid codepoint, use NBSP.
if (codepoint == NOCODE)
{
codepoint = '\xA0';
}
extended = true;
escape = false;
}
else if (@byte < GsmToUcs2.Length)
{
codepoint = GsmToUcs2[@byte];
if (codepoint == UESCAPE)
{
escape = true;
continue;
}
}
if (codepoint == NOCODE)
{
char tmp;
DecoderFallbackBuffer.Fallback(extended ? new byte[] { 0x1b, @byte } : new[] { @byte }, inpos);
while ((tmp = DecoderFallbackBuffer.GetNextChar()) != 0)
{
if (chars != null)
{
chars[outpos++] = GsmToUcs2[tmp]; // FIXME: Character might not be a 7-bit one..
}
else
{
outpos++;
}
}
}
else
{
if (chars != null)
{
chars[outpos++] = codepoint;
}
else
{
outpos += 1;
}
}
}
return(outpos - charIndex);
}