/// <summary>
/// Checks if the string contains special char and returns the first index
/// of special char if present.
/// </summary>
/// <param name="inputString">string that might contain special characters.</param>
/// <param name="stringEscapeOption">The string escape option.</param>
/// <param name="firstIndex">first index of the special char</param>
/// <returns>A value indicating whether the string contains special character</returns>
private static bool CheckIfStringHasSpecialChars(string inputString, ODataStringEscapeOption stringEscapeOption, out int firstIndex)
{
Debug.Assert(inputString != null, "The string value must not be null.");
firstIndex = -1;
int inputStringLength = inputString.Length;
for (int currentIndex = 0; currentIndex < inputStringLength; currentIndex++)
{
char c = inputString[currentIndex];
if (stringEscapeOption == ODataStringEscapeOption.EscapeOnlyControls && c >= 0x7F)
{
continue;
}
// Append the un-handled characters (that do not require special treatment)
// to the string builder when special characters are detected.
if (JsonValueUtils.SpecialCharToEscapedStringMap[c] != null)
{
firstIndex = currentIndex;
return(true);
}
}
return(false);
}
/// <summary>
/// Creates a new instance of Json writer.
/// </summary>
/// <param name="writer">Writer to which text needs to be written.</param>
/// <param name="isIeee754Compatible">if it is IEEE754Compatible.</param>
/// <param name="stringEscapeOption">Specifies how to escape string.</param>
internal JsonWriter(TextWriter writer, bool isIeee754Compatible, ODataStringEscapeOption stringEscapeOption)
{
this.writer = new NonIndentedTextWriter(writer);
this.scopes = new Stack <Scope>();
this.isIeee754Compatible = isIeee754Compatible;
this.stringEscapeOption = stringEscapeOption;
}
/// <summary>
/// Writes the string value with special characters escaped.
/// </summary>
/// <param name="writer">The text writer to write the output to.</param>
/// <param name="inputString">Input string value.</param>
/// <param name="stringEscapeOption">The string escape option.</param>
/// <param name="buffer">Char buffer to use for streaming data.</param>
/// <param name="bufferPool">Array pool for renting a buffer.</param>
internal static void WriteEscapedJsonStringValue(TextWriter writer, string inputString,
ODataStringEscapeOption stringEscapeOption, ref char[] buffer, ICharArrayPool bufferPool)
{
Debug.Assert(writer != null, "writer != null");
Debug.Assert(inputString != null, "The string value must not be null.");
int firstIndex;
if (!JsonValueUtils.CheckIfStringHasSpecialChars(inputString, stringEscapeOption, out firstIndex))
{
writer.Write(inputString);
}
else
{
int inputStringLength = inputString.Length;
Debug.Assert(firstIndex < inputStringLength, "First index of the special character should be within the string");
buffer = BufferUtils.InitializeBufferIfRequired(bufferPool, buffer);
int bufferLength = buffer.Length;
int bufferIndex = 0;
int currentIndex = 0;
// Let's copy and flush strings up to the first index of the special char
while (currentIndex < firstIndex)
{
int subStrLength = firstIndex - currentIndex;
Debug.Assert(subStrLength > 0, "SubStrLength should be greater than 0 always");
// If the first index of the special character is larger than the buffer length,
// flush everything to the buffer first and reset the buffer to the next chunk.
// Otherwise copy to the buffer and go on from there.
if (subStrLength >= bufferLength)
{
inputString.CopyTo(currentIndex, buffer, 0, bufferLength);
writer.Write(buffer, 0, bufferLength);
currentIndex += bufferLength;
}
else
{
inputString.CopyTo(currentIndex, buffer, 0, subStrLength);
bufferIndex = subStrLength;
currentIndex += subStrLength;
}
}
// start writing escaped strings
for (; currentIndex < inputStringLength; currentIndex++)
{
bufferIndex = EscapeAndWriteCharToBuffer(writer, inputString[currentIndex], buffer, bufferIndex, stringEscapeOption);
}
// write any remaining chars to the writer
if (bufferIndex > 0)
{
writer.Write(buffer, 0, bufferIndex);
}
}
}
public void WriteStringWithNoSpecialCharShouldLeaveBufferUntouched(ODataStringEscapeOption stringEscapeOption)
{
this.TestInit();
char[] charBuffer = null;
JsonValueUtils.WriteEscapedJsonString(this.writer, "StartMiddleEnd", stringEscapeOption, ref charBuffer);
Assert.Equal("\"StartMiddleEnd\"", this.StreamToString());
Assert.Null(charBuffer);
}
public void WriteStringWithNoSpecialCharShouldLeaveBufferUntouched(ODataStringEscapeOption stringEscapeOption)
{
this.TestInit();
char[] charBuffer = null;
JsonValueUtils.WriteEscapedJsonString(this.writer, "StartMiddleEnd", stringEscapeOption, ref charBuffer);
this.StreamToString().Should().Be("\"StartMiddleEnd\"");
charBuffer.Should().BeNull("Char Buffer for cases with zero special characters should need to use buffer");
}
/// <summary>
/// Writes the string value with special characters escaped.
/// </summary>
/// <param name="writer">The text writer to write the output to.</param>
/// <param name="inputString">Input string value.</param>
/// <param name="stringEscapeOption">The string escape option.</param>
/// <param name="buffer">Char buffer to use for streaming data.</param>
/// <param name="bufferPool">Array pool for renting a buffer.</param>
internal static async Task WriteEscapedJsonStringValueAsync(
this TextWriter writer,
string inputString,
ODataStringEscapeOption stringEscapeOption,
Ref <char[]> buffer,
ICharArrayPool bufferPool)
{
Debug.Assert(writer != null, "writer != null");
Debug.Assert(inputString != null, "The string value must not be null.");
int firstIndex;
if (!CheckIfStringHasSpecialChars(inputString, stringEscapeOption, out firstIndex))
{
await writer.WriteAsync(inputString).ConfigureAwait(false);
}
else
{
Debug.Assert(firstIndex < inputString.Length, "First index of the special character should be within the string");
buffer.Value = BufferUtils.InitializeBufferIfRequired(bufferPool, buffer.Value);
int bufferLength = buffer.Value.Length;
int bufferIndex = 0;
int currentIndex = 0;
// Let's copy and flush strings up to the first index of the special char
while (currentIndex < firstIndex)
{
int substrLength = firstIndex - currentIndex;
Debug.Assert(substrLength > 0, "SubStrLength should be greater than 0 always");
// If the first index of the special character is larger than the buffer length,
// flush everything to the buffer first and reset the buffer to the next chunk.
// Otherwise copy to the buffer and go on from there.
if (substrLength >= bufferLength)
{
inputString.CopyTo(currentIndex, buffer.Value, 0, bufferLength);
await writer.WriteAsync(buffer.Value, 0, bufferLength).ConfigureAwait(false);
currentIndex += bufferLength;
}
else
{
WriteSubstringToBuffer(inputString, ref currentIndex, buffer.Value, ref bufferIndex, substrLength);
}
}
// Write escaped string to buffer
WriteEscapedStringToBuffer(writer, inputString, ref currentIndex, buffer.Value, ref bufferIndex, stringEscapeOption);
// write any remaining chars to the writer
if (bufferIndex > 0)
{
await writer.WriteAsync(buffer.Value, 0, bufferIndex).ConfigureAwait(false);
}
}
}
public async Task WriteStringWithNoSpecialCharShouldLeaveBufferUntouched(ODataStringEscapeOption stringEscapeOption)
{
this.Reset();
Ref <char[]> charBuffer = new Ref <char[]>(null);
await JsonValueUtils.WriteEscapedJsonStringAsync(this.writer, "StartMiddleEnd", stringEscapeOption, charBuffer);
Assert.Equal("\"StartMiddleEnd\"", this.StreamToString());
Assert.Null(charBuffer.Value);
}
/// <summary>
/// Returns the string value with special characters escaped.
/// </summary>
/// <param name="writer">The text writer to write the output to.</param>
/// <param name="inputString">Input string value.</param>
/// <param name="stringEscapeOption">The string escape option.</param>
/// <param name="buffer">Char buffer to use for streaming data</param>
/// <param name="bufferPool">Array pool for renting a buffer.</param>
internal static void WriteEscapedJsonString(TextWriter writer, string inputString,
ODataStringEscapeOption stringEscapeOption, ref char[] buffer, ICharArrayPool bufferPool = null)
{
Debug.Assert(writer != null, "writer != null");
Debug.Assert(inputString != null, "The string value must not be null.");
writer.Write(JsonConstants.QuoteCharacter);
WriteEscapedJsonStringValue(writer, inputString, stringEscapeOption, ref buffer, bufferPool);
writer.Write(JsonConstants.QuoteCharacter);
}
public void WriteControllCharactersWithStringEscapeOptionShouldWork(ODataStringEscapeOption escapeOption)
{
foreach (string specialChar in this.controlCharsMap.Keys)
{
this.TestInit();
char[] charBuffer = new char[6];
JsonValueUtils.WriteEscapedJsonString(this.writer, string.Format("S{0}M{0}E{0}", specialChar),
escapeOption, ref charBuffer);
Assert.Equal(string.Format("\"S{0}M{0}E{0}\"", this.controlCharsMap[specialChar]), this.StreamToString());
}
}
public void WriteStringShouldIgnoreExistingContentsOfTheBuffer(ODataStringEscapeOption stringEscapeOption)
{
this.TestInit();
char[] charBuffer = new char[128];
for (int index = 0; index < 128; index++)
{
charBuffer[index] = (char)index;
}
JsonValueUtils.WriteEscapedJsonString(this.writer, "StartVeryVeryLongMiddleEnd", stringEscapeOption, ref charBuffer);
Assert.Equal("\"StartVeryVeryLongMiddleEnd\"", this.StreamToString());
}
/// <summary>
/// Returns the string value with special characters escaped.
/// </summary>
/// <param name="writer">The text writer to write the output to.</param>
/// <param name="inputString">Input string value.</param>
/// <param name="stringEscapeOption">The string escape option.</param>
/// <param name="buffer">Char buffer to use for streaming data.</param>
/// <param name="bufferPool">Array pool for renting a buffer.</param>
internal static async Task WriteEscapedJsonStringAsync(this TextWriter writer, string inputString,
ODataStringEscapeOption stringEscapeOption, Ref <char[]> buffer, ICharArrayPool bufferPool = null)
{
Debug.Assert(writer != null, "writer != null");
Debug.Assert(inputString != null, "The string value must not be null.");
await writer.WriteAsync(JsonConstants.QuoteCharacter).ConfigureAwait(false);
await writer.WriteEscapedJsonStringValueAsync(inputString, stringEscapeOption, buffer, bufferPool).ConfigureAwait(false);
await writer.WriteAsync(JsonConstants.QuoteCharacter).ConfigureAwait(false);
}
public async Task WriteControllCharactersWithStringEscapeOptionShouldWork(ODataStringEscapeOption escapeOption)
{
foreach (string specialChar in this.controlCharsMap.Keys)
{
this.Reset();
Ref <char[]> charBuffer = new Ref <char[]>(new char[6]);
await JsonValueUtils.WriteEscapedJsonStringAsync(this.writer, string.Format("S{0}M{0}E{0}", specialChar),
escapeOption, charBuffer);
Assert.Equal(string.Format("\"S{0}M{0}E{0}\"", this.controlCharsMap[specialChar]), this.StreamToString());
}
}
public async Task WriteStringShouldIgnoreExistingContentsOfTheBuffer(ODataStringEscapeOption stringEscapeOption)
{
Ref <char[]> charBuffer = new Ref <char[]>(new char[128]);
for (int index = 0; index < 128; index++)
{
charBuffer.Value[index] = (char)index;
}
await JsonValueUtils.WriteEscapedJsonStringAsync(this.writer, "StartVeryVeryLongMiddleEnd", stringEscapeOption, charBuffer);
Assert.Equal("\"StartVeryVeryLongMiddleEnd\"", this.StreamToString());
}
/// <summary>
/// Write a string value.
/// </summary>
/// <param name="writer">The text writer to write the output to.</param>
/// <param name="value">String value to be written.</param>
/// <param name="stringEscapeOption">The string escape option.</param>
/// <param name="buffer">Char buffer to use for streaming data</param>
internal static void WriteValue(TextWriter writer, string value, ODataStringEscapeOption stringEscapeOption, ref char[] buffer, ICharArrayPool arrayPool = null)
{
Debug.Assert(writer != null, "writer != null");
if (value == null)
{
writer.Write(JsonConstants.JsonNullLiteral);
}
else
{
JsonValueUtils.WriteEscapedJsonString(writer, value, stringEscapeOption, ref buffer, arrayPool);
}
}
/// <summary>
/// Write a char value.
/// </summary>
/// <param name="writer">The text writer to write the output to.</param>
/// <param name="value">The char value to write.</param>
/// <param name="stringEscapeOption">The ODataStringEscapeOption to use in escaping the string.</param>
internal static Task WriteValueAsync(this TextWriter writer, char value, ODataStringEscapeOption stringEscapeOption)
{
Debug.Assert(writer != null, "writer != null");
if (stringEscapeOption == ODataStringEscapeOption.EscapeNonAscii || value <= 0x7F)
{
string escapedString = SpecialCharToEscapedStringMap[value];
if (escapedString != null)
{
return(writer.WriteAsync(escapedString));
}
}
return(writer.WriteAsync(value));
}
/// <summary>
/// Writes an escaped string to the buffer.
/// </summary>
/// <param name="writer">The text writer to write the output to.</param>
/// <param name="inputString">Input string value.</param>
/// <param name="currentIndex">The index in the string at which copying should begin.</param>
/// <param name="buffer">Char buffer to use for streaming data.</param>
/// <param name="bufferIndex">Current position in the buffer after the string has been written.</param>
/// <param name="stringEscapeOption">The string escape option.</param>
/// <remarks>
/// IMPORTANT: After all characters have been written,
/// caller is responsible for writing the final buffer contents to the writer.
/// </remarks>
private static void WriteEscapedStringToBuffer(
TextWriter writer,
string inputString,
ref int currentIndex,
char[] buffer,
ref int bufferIndex,
ODataStringEscapeOption stringEscapeOption)
{
Debug.Assert(inputString != null, "inputString != null");
Debug.Assert(buffer != null, "buffer != null");
for (; currentIndex < inputString.Length; currentIndex++)
{
bufferIndex = EscapeAndWriteCharToBuffer(writer, inputString[currentIndex], buffer, bufferIndex, stringEscapeOption);
}
}
/// <summary>
/// Write a char value.
/// </summary>
/// <param name="writer">The text writer to write the output to.</param>
/// <param name="value">The char value to write.</param>
/// <param name="stringEscapeOption">The ODataStringEscapeOption to use in escaping the string.</param>
internal static void WriteValue(TextWriter writer, char value, ODataStringEscapeOption stringEscapeOption)
{
Debug.Assert(writer != null, "writer != null");
if (stringEscapeOption == ODataStringEscapeOption.EscapeNonAscii || value <= 0x7F)
{
string escapedString = JsonValueUtils.SpecialCharToEscapedStringMap[value];
if (escapedString != null)
{
writer.Write(escapedString);
return;
}
}
writer.Write(value);
}
/// <summary>
/// Writes an escaped char array to the buffer.
/// </summary>
/// <param name="writer">The text writer to write the output to.</param>
/// <param name="inputArray">Character array to write.</param>
/// <param name="inputArrayOffset">How many characters to skip in the input array.</param>
/// <param name="inputArrayCount">How many characters to write from the input array.</param>
/// <param name="buffer">Char buffer to use for streaming data.</param>
/// <param name="bufferIndex">Current position in the buffer after the string has been written.</param>
/// <param name="stringEscapeOption">The string escape option.</param>
/// <remarks>
/// IMPORTANT: After all characters have been written,
/// caller is responsible for writing the final buffer contents to the writer.
/// </remarks>
private static void WriteEscapedCharArrayToBuffer(
TextWriter writer,
char[] inputArray,
ref int inputArrayOffset,
int inputArrayCount,
char[] buffer,
ref int bufferIndex,
ODataStringEscapeOption stringEscapeOption)
{
Debug.Assert(inputArray != null, "inputArray != null");
Debug.Assert(buffer != null, "buffer != null");
for (; inputArrayOffset < inputArrayCount; inputArrayOffset++)
{
bufferIndex = EscapeAndWriteCharToBuffer(writer, inputArray[inputArrayOffset], buffer, bufferIndex, stringEscapeOption);
}
}
/// <summary>
/// Write a string value.
/// </summary>
/// <param name="writer">The text writer to write the output to.</param>
/// <param name="value">String value to be written.</param>
/// <param name="stringEscapeOption">The string escape option.</param>
/// <param name="buffer">Char buffer to use for streaming data.</param>
/// <param name="arrayPool">Array pool for renting a buffer.</param>
internal static Task WriteValueAsync(
this TextWriter writer,
string value,
ODataStringEscapeOption stringEscapeOption,
Ref <char[]> buffer,
ICharArrayPool arrayPool = null)
{
Debug.Assert(writer != null, "writer != null");
if (value == null)
{
return(writer.WriteAsync(JsonConstants.JsonNullLiteral));
}
else
{
return(writer.WriteEscapedJsonStringAsync(value, stringEscapeOption, buffer, arrayPool));
}
}
/// <summary>
/// Escapes and writes a character array to a writer.
/// </summary>
/// <param name="writer">The text writer to write the output to.</param>
/// <param name="inputArray">Character array to write.</param>
/// <param name="inputArrayOffset">How many characters to skip in the input array.</param>
/// <param name="inputArrayCount">How many characters to write from the input array.</param>
/// <param name="stringEscapeOption">The string escape option.</param>
/// <param name="buffer">Char buffer to use for streaming data.</param>
/// <param name="bufferPool">Character buffer pool.</param>
internal static void WriteEscapedCharArray(
TextWriter writer,
char[] inputArray,
int inputArrayOffset,
int inputArrayCount,
ODataStringEscapeOption stringEscapeOption,
Ref <char[]> buffer, ICharArrayPool bufferPool)
{
int bufferIndex = 0;
buffer.Value = BufferUtils.InitializeBufferIfRequired(bufferPool, buffer.Value);
WriteEscapedCharArrayToBuffer(writer, inputArray, ref inputArrayOffset, inputArrayCount, buffer.Value, ref bufferIndex, stringEscapeOption);
// write remaining bytes in buffer
if (bufferIndex > 0)
{
writer.Write(buffer.Value, 0, bufferIndex);
}
}
/// <summary>
/// Escapes and writes a character array to a writer.
/// </summary>
/// <param name="writer">The text writer to write the output to.</param>
/// <param name="inputArray">Character array to write.</param>
/// <param name="inputArrayOffset">How many characters to skip in the input array.</param>
/// <param name="inputArrayCount">How many characters to write from the input array.</param>
/// <param name="stringEscapeOption">The string escape option.</param>
/// <param name="buffer">Char buffer to use for streaming data.</param>
/// <param name="bufferPool">Character buffer pool.</param>
internal static async Task WriteEscapedCharArrayAsync(
this TextWriter writer,
char[] inputArray,
int inputArrayOffset,
int inputArrayCount,
ODataStringEscapeOption stringEscapeOption,
Ref <char[]> buffer,
ICharArrayPool bufferPool)
{
int bufferIndex = 0;
buffer.Value = BufferUtils.InitializeBufferIfRequired(bufferPool, buffer.Value);
WriteEscapedCharArrayToBuffer(writer, inputArray, ref inputArrayOffset, inputArrayCount, buffer.Value, ref bufferIndex, stringEscapeOption);
// write remaining bytes in buffer
if (bufferIndex > 0)
{
await writer.WriteAsync(buffer.Value, 0, bufferIndex).ConfigureAwait(false);
}
}
public async Task WriteEmptyStringShouldWork(ODataStringEscapeOption stringEscapeOption)
{
await JsonValueUtils.WriteEscapedJsonStringAsync(this.writer, string.Empty, stringEscapeOption, this.buffer);
Assert.Equal("\"\"", this.StreamToString());
}
/// <summary>
/// Initializes a new instance of the <see cref="DefaultJsonWriterFactory" />.
/// </summary>
/// <param name="stringEscapeOption">The string escape option.</param>
public DefaultJsonWriterFactory(ODataStringEscapeOption stringEscapeOption)
{
this.stringEscapeOption = stringEscapeOption;
}
public async Task WriteNonSpecialCharactersShouldWork(ODataStringEscapeOption stringEscapeOption)
{
await JsonValueUtils.WriteEscapedJsonStringAsync(this.writer, "abcdefg123", stringEscapeOption, this.buffer);
Assert.Equal("\"abcdefg123\"", this.StreamToString());
}
/// <summary>
/// Returns the string value with special characters escaped.
/// </summary>
/// <param name="writer">The text writer to write the output to.</param>
/// <param name="inputString">Input string value.</param>
/// <param name="stringEscapeOption">The string escape option.</param>
/// <param name="buffer">Char buffer to use for streaming data</param>
internal static void WriteEscapedJsonString(TextWriter writer, string inputString,
ODataStringEscapeOption stringEscapeOption, ref char[] buffer, ICharArrayPool bufferPool = null)
{
Debug.Assert(writer != null, "writer != null");
Debug.Assert(inputString != null, "The string value must not be null.");
writer.Write(JsonConstants.QuoteCharacter);
int firstIndex;
if (!JsonValueUtils.CheckIfStringHasSpecialChars(inputString, stringEscapeOption, out firstIndex))
{
writer.Write(inputString);
}
else
{
int inputStringLength = inputString.Length;
Debug.Assert(firstIndex < inputStringLength, "First index of the special character should be within the string");
buffer = BufferUtils.InitializeBufferIfRequired(bufferPool, buffer);
int bufferLength = buffer.Length;
int bufferIndex = 0;
int currentIndex = 0;
// Let's copy and flush strings up to the first index of the special char
while (currentIndex < firstIndex)
{
int subStrLength = firstIndex - currentIndex;
Debug.Assert(subStrLength > 0, "SubStrLength should be greater than 0 always");
// If the first index of the special character is larger than the buffer length,
// flush everything to the buffer first and reset the buffer to the next chunk.
// Otherwise copy to the buffer and go on from there.
if (subStrLength >= bufferLength)
{
inputString.CopyTo(currentIndex, buffer, 0, bufferLength);
writer.Write(buffer, 0, bufferLength);
currentIndex += bufferLength;
}
else
{
inputString.CopyTo(currentIndex, buffer, 0, subStrLength);
bufferIndex = subStrLength;
currentIndex += subStrLength;
}
}
for (; currentIndex < inputStringLength; currentIndex++)
{
char c = inputString[currentIndex];
string escapedString = null;
if (stringEscapeOption == ODataStringEscapeOption.EscapeNonAscii || c <= 0x7F)
{
escapedString = JsonValueUtils.SpecialCharToEscapedStringMap[c];
}
// Append the unhandled characters (that do not require special treament)
// to the buffer.
if (escapedString == null)
{
buffer[bufferIndex] = c;
bufferIndex++;
}
else
{
// Okay, an unhandled character was deteced.
// First lets check if we can fit it in the existing buffer, if not,
// flush the current buffer and reset. Add the escaped string to the buffer
// and continue.
int escapedStringLength = escapedString.Length;
Debug.Assert(escapedStringLength <= bufferLength, "Buffer should be larger than the escaped string");
if ((bufferIndex + escapedStringLength) > bufferLength)
{
writer.Write(buffer, 0, bufferIndex);
bufferIndex = 0;
}
escapedString.CopyTo(0, buffer, bufferIndex, escapedStringLength);
bufferIndex += escapedStringLength;
}
if (bufferIndex >= bufferLength)
{
Debug.Assert(bufferIndex == bufferLength,
"We should never encounter a situation where the buffer index is greater than the buffer length");
writer.Write(buffer, 0, bufferIndex);
bufferIndex = 0;
}
}
if (bufferIndex > 0)
{
writer.Write(buffer, 0, bufferIndex);
}
}
writer.Write(JsonConstants.QuoteCharacter);
}
public void WriteEmptyStringShouldWork(ODataStringEscapeOption stringEscapeOption)
{
this.TestInit();
JsonValueUtils.WriteEscapedJsonString(this.writer, string.Empty, stringEscapeOption, ref this.buffer);
this.StreamToString().Should().Be("\"\"");
}
/// <summary>
/// Escapes and writes a character buffer, flushing to the writer as the buffer fills.
/// </summary>
/// <param name="writer">The text writer to write the output to.</param>
/// <param name="character">The character to write to the buffer.</param>
/// <param name="buffer">Char buffer to use for streaming data.</param>
/// <param name="bufferIndex">The index into the buffer in which to write the character.</param>
/// <param name="stringEscapeOption">The string escape option.</param>
/// <returns>Current position in the buffer after the character has been written.</returns>
/// <remarks>
/// IMPORTANT: After all characters have been written,
/// caller is responsible for writing the final buffer contents to the writer.
/// </remarks>
private static int EscapeAndWriteCharToBuffer(TextWriter writer, char character, char[] buffer, int bufferIndex, ODataStringEscapeOption stringEscapeOption)
{
int bufferLength = buffer.Length;
string escapedString = null;
if (stringEscapeOption == ODataStringEscapeOption.EscapeNonAscii || character <= 0x7F)
{
escapedString = JsonValueUtils.SpecialCharToEscapedStringMap[character];
}
// Append the unhandled characters (that do not require special treatment)
// to the buffer.
if (escapedString == null)
{
buffer[bufferIndex] = character;
bufferIndex++;
}
else
{
// Okay, an unhandled character was detected.
// First lets check if we can fit it in the existing buffer, if not,
// flush the current buffer and reset. Add the escaped string to the buffer
// and continue.
int escapedStringLength = escapedString.Length;
Debug.Assert(escapedStringLength <= bufferLength, "Buffer should be larger than the escaped string");
if ((bufferIndex + escapedStringLength) > bufferLength)
{
writer.Write(buffer, 0, bufferIndex);
bufferIndex = 0;
}
escapedString.CopyTo(0, buffer, bufferIndex, escapedStringLength);
bufferIndex += escapedStringLength;
}
if (bufferIndex >= bufferLength)
{
Debug.Assert(bufferIndex == bufferLength,
"We should never encounter a situation where the buffer index is greater than the buffer length");
writer.Write(buffer, 0, bufferIndex);
bufferIndex = 0;
}
return(bufferIndex);
}
/// <summary>
/// Escapes and writes a character array to a writer.
/// </summary>
/// <param name="writer">The text writer to write the output to.</param>
/// <param name="inputArray">Character array to write.</param>
/// <param name="inputArrayOffset">How many characters to skip in the input array.</param>
/// <param name="inputArrayCount">How many characters to write from the input array.</param>
/// <param name="stringEscapeOption">The string escape option.</param>
/// <param name="buffer">Char buffer to use for streaming data.</param>
/// <param name="bufferPool">Character buffer pool.</param>
internal static void WriteEscapedCharArray(TextWriter writer, char[] inputArray, int inputArrayOffset, int inputArrayCount, ODataStringEscapeOption stringEscapeOption, ref char[] buffer, ICharArrayPool bufferPool)
{
int bufferIndex = 0;
buffer = BufferUtils.InitializeBufferIfRequired(bufferPool, buffer);
for (; inputArrayOffset < inputArrayCount; inputArrayOffset++)
{
bufferIndex = EscapeAndWriteCharToBuffer(writer, inputArray[inputArrayOffset], buffer, bufferIndex, stringEscapeOption);
}
// write remaining bytes in buffer
if (bufferIndex > 0)
{
writer.Write(buffer, 0, bufferIndex);
}
}
public void WriteNonSpecialCharactersShouldWork(ODataStringEscapeOption stringEscapeOption)
{
this.TestInit();
JsonValueUtils.WriteEscapedJsonString(this.writer, "abcdefg123", stringEscapeOption, ref this.buffer);
this.StreamToString().Should().Be("\"abcdefg123\"");
}
public void WriteLowSpecialCharactersShouldWorkForEscapeOption(ODataStringEscapeOption stringEscapeOption)
{
this.TestInit();
JsonValueUtils.WriteEscapedJsonString(this.writer, "cA_\n\r\b", stringEscapeOption, ref this.buffer);
Assert.Equal("\"cA_\\n\\r\\b\"", this.StreamToString());
}
