public bool NegTest1()
{
bool retVal = true;
TestLibrary.TestFramework.BeginScenario("NegTest1: ArgumentOutOfRangeException is not thrown when charCount is less than zero.");
try
{
UTF8Encoding utf8 = new UTF8Encoding();
int charCount = -1;
int maxByteCount = utf8.GetMaxByteCount(charCount);
TestLibrary.TestFramework.LogError("101.1", "ArgumentOutOfRangeException is not thrown when charCount is less than zero. ");
retVal = false;
}
catch (ArgumentOutOfRangeException) { }
catch (Exception e)
{
TestLibrary.TestFramework.LogError("101.2", "Unexpected exception: " + e);
TestLibrary.TestFramework.LogInformation(e.StackTrace);
retVal = false;
}
return retVal;
}
public void NegTest1()
{
UTF8Encoding utf8 = new UTF8Encoding();
int charCount = -1;
Assert.Throws<ArgumentOutOfRangeException>(() =>
{
int maxByteCount = utf8.GetMaxByteCount(charCount);
});
}
public bool PosTest1()
{
bool retVal = true;
// Add your scenario description here
TestLibrary.TestFramework.BeginScenario("PosTest1: Verify method GetMaxByteCount");
try
{
UTF8Encoding utf8 = new UTF8Encoding();
int charCount = 0;
int maxByteCount = utf8.GetMaxByteCount(charCount);
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("001", "Unexpected exception: " + e);
TestLibrary.TestFramework.LogInformation(e.StackTrace);
retVal = false;
}
return retVal;
}
public void PosTest1()
{
UTF8Encoding utf8 = new UTF8Encoding();
int charCount = 0;
int maxByteCount = utf8.GetMaxByteCount(charCount);
}
public void PosTest1()
{
UTF8Encoding utf8 = new UTF8Encoding();
int charCount = 0;
int maxByteCount = utf8.GetMaxByteCount(charCount);
}
internal static ArraySegment <byte> ProcessBuffer(byte[] buffer, int offset, int count, Encoding encoding)
{
if (count < 4)
{
throw new XmlException(SR.UnexpectedEndOfFile);
}
try
{
int preserve;
ArraySegment <byte> seg;
SupportedEncoding expectedEnc = GetSupportedEncoding(encoding);
SupportedEncoding declEnc = ReadBOMEncoding(buffer[offset], buffer[offset + 1], buffer[offset + 2], buffer[offset + 3], encoding == null, out preserve);
if (expectedEnc != SupportedEncoding.None && expectedEnc != declEnc)
{
ThrowExpectedEncodingMismatch(expectedEnc, declEnc);
}
offset += 4 - preserve;
count -= 4 - preserve;
// Fastpath: UTF-8
char[] chars;
byte[] bytes;
Encoding localEnc;
if (declEnc == SupportedEncoding.UTF8)
{
// Fastpath: No declaration
if (buffer[offset + 1] != '?' || buffer[offset] != '<')
{
seg = new ArraySegment <byte>(buffer, offset, count);
return(seg);
}
CheckUTF8DeclarationEncoding(buffer, offset, count, declEnc, expectedEnc);
seg = new ArraySegment <byte>(buffer, offset, count);
return(seg);
}
// Convert to UTF-8
localEnc = GetSafeEncoding(declEnc);
int inputCount = Math.Min(count, BufferLength * 2);
chars = new char[localEnc.GetMaxCharCount(inputCount)];
int ccount = localEnc.GetChars(buffer, offset, inputCount, chars, 0);
bytes = new byte[s_validatingUTF8.GetMaxByteCount(ccount)];
int bcount = s_validatingUTF8.GetBytes(chars, 0, ccount, bytes, 0);
// Check for declaration
if (bytes[1] == '?' && bytes[0] == '<')
{
CheckUTF8DeclarationEncoding(bytes, 0, bcount, declEnc, expectedEnc);
}
else
{
// Declaration required if no out-of-band encoding
if (expectedEnc == SupportedEncoding.None)
{
throw new XmlException(SR.XmlDeclarationRequired);
}
}
seg = new ArraySegment <byte>(s_validatingUTF8.GetBytes(GetEncoding(declEnc).GetChars(buffer, offset, count)));
return(seg);
}
catch (DecoderFallbackException e)
{
throw new XmlException(SR.XmlInvalidBytes, e);
}
}
/// <summary>
/// Writes an error to a stream.
/// </summary>
protected static void WriteErrorMessageBody(BinaryEncoder encoder, ServiceResult error)
{
string reason = (error.LocalizedText != null) ? error.LocalizedText.Text : null;
// check that length is not exceeded.
if (reason != null)
{
UTF8Encoding encoding = new UTF8Encoding();
if (encoding.GetByteCount(reason) > TcpMessageLimits.MaxErrorReasonLength)
{
reason = reason.Substring(0, TcpMessageLimits.MaxErrorReasonLength / encoding.GetMaxByteCount(1));
}
}
encoder.WriteStatusCode(null, error.StatusCode);
encoder.WriteString(null, reason);
}
public static ByteStringContext.InternalScope GetLowerIdSliceAndStorageKey <TTransaction>(
TransactionOperationContext <TTransaction> context, string str, out Slice lowerIdSlice, out Slice idSlice)
where TTransaction : RavenTransaction
{
// Because we need to also store escape positions for the key when we store it
// we need to store it as a lazy string value.
// But lazy string value has two lengths, one is the string length, and the other
// is the actual data size with the escape positions
// In order to resolve this, we process the key to find escape positions, then store it
// in the table using the following format:
//
// [var int - string len, string bytes, number of escape positions, escape positions]
//
// The total length of the string is stored in the actual table (and include the var int size
// prefix.
if (_jsonParserState == null)
{
_jsonParserState = new JsonParserState();
}
_jsonParserState.Reset();
int originalStrLength = str.Length;
int strLength = originalStrLength;
if (strLength > MaxIdSize)
{
ThrowDocumentIdTooBig(str);
}
int maxStrSize = Encoding.GetMaxByteCount(strLength);
int idSize = JsonParserState.VariableSizeIntSize(strLength);
int escapePositionsSize = JsonParserState.FindEscapePositionsMaxSize(str);
var scope = context.Allocator.Allocate(maxStrSize // lower key
+ idSize // the size of var int for the len of the key
+ maxStrSize // actual key
+ escapePositionsSize, out ByteString buffer);
byte *ptr = buffer.Ptr;
fixed(char *pChars = str)
{
for (var i = 0; i < strLength; i++)
{
uint ch = pChars[i];
// PERF: Trick to avoid multiple compare instructions on hot loops.
// This is the same as (ch >= 65 && ch <= 90)
if (ch - 65 <= 90 - 65)
{
ptr[i] = (byte)(ch | 0x20);
}
else
{
if (ch > 127) // not ASCII, use slower mode
{
goto UnlikelyUnicode;
}
ptr[i] = (byte)ch;
}
ptr[i + idSize + maxStrSize] = (byte)ch;
}
_jsonParserState.FindEscapePositionsIn(ptr, ref strLength, escapePositionsSize);
if (strLength != originalStrLength)
{
var anotherStrLength = originalStrLength;
_jsonParserState.FindEscapePositionsIn(ptr + idSize + maxStrSize, ref anotherStrLength, escapePositionsSize);
#if DEBUG
if (strLength != anotherStrLength)
{
throw new InvalidOperationException($"String length mismatch between Id ({str}) and it's lowercased counterpart after finding escape positions. Original: {anotherStrLength}. Lowercased: {strLength}");
}
#endif
}
}
var writePos = ptr + maxStrSize;
JsonParserState.WriteVariableSizeInt(ref writePos, strLength);
escapePositionsSize = _jsonParserState.WriteEscapePositionsTo(writePos + strLength);
idSize = escapePositionsSize + strLength + idSize;
Slice.External(context.Allocator, ptr + maxStrSize, idSize, out idSlice);
Slice.External(context.Allocator, ptr, strLength, out lowerIdSlice);
return(scope);
UnlikelyUnicode:
scope.Dispose();
return(UnicodeGetLowerIdAndStorageKey(context, str, out lowerIdSlice, out idSlice, maxStrSize, escapePositionsSize));
}
/// <summary>
/// Returns true if the specified string can certainly be represented using
/// a 16-bit unsigned integer length prefix.
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public bool IsShortString(string value)
{
return(utf8Encoding.GetMaxByteCount(value.Length) <= UInt16.MaxValue);
}
// ------------------------------------------------------------------------------------
/// <summary>
/// Send message to Snarl.
/// Will UTF8 encode the message before sending.
/// </summary>
/// <param name="request"></param>
/// <param name="replyTimeout">(Optional - default = 1000)</param>
/// <returns>Return zero or positive on succes. Negative on error.</returns>
static public Int32 DoRequest(String request, UInt32 replyTimeout)
{
Int32 nReturn = -1;
IntPtr nSendMessageResult = IntPtr.Zero;
IntPtr ptrToUtf8Request = IntPtr.Zero;
IntPtr ptrToCds = IntPtr.Zero;
byte[] utf8Request = null;
// Test if Snarl is running
IntPtr hWnd = GetSnarlWindow();
if (!IsWindow(hWnd))
{
return(-(Int32)SnarlStatus.ErrorNotRunning);
}
try
{
// Convert to UTF8
// utf8Request = StringToUtf8(request);
UTF8Encoding utf8 = new UTF8Encoding();
utf8Request = new byte[utf8.GetMaxByteCount(request.Length)];
int convertCount = utf8.GetBytes(request, 0, request.Length, utf8Request, 0);
// Create interop struct
COPYDATASTRUCT cds = new COPYDATASTRUCT();
cds.dwData = (IntPtr)0x534E4C03; // "SNL",3
cds.cbData = convertCount;
// Create unmanaged byte[] and copy utf8Request into it
ptrToUtf8Request = Marshal.AllocHGlobal(convertCount);
Marshal.Copy(utf8Request, 0, ptrToUtf8Request, convertCount);
cds.lpData = ptrToUtf8Request;
// Create unmanaged pointer to COPYDATASTRUCT
ptrToCds = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(COPYDATASTRUCT)));
Marshal.StructureToPtr(cds, ptrToCds, false);
if (SendMessageTimeout(hWnd,
(uint)WindowsMessage.WM_COPYDATA,
(IntPtr)GetCurrentProcessId(),
ptrToCds,
SendMessageTimeoutFlags.SMTO_ABORTIFHUNG | SendMessageTimeoutFlags.SMTO_NOTIMEOUTIFNOTHUNG,
replyTimeout,
out nSendMessageResult) == IntPtr.Zero)
{
// Error
int nError = Marshal.GetLastWin32Error();
if (nError == ERROR_TIMEOUT)
{
nReturn = -(Int32)SnarlStatus.ErrorTimedOut;
}
else
{
nReturn = -(Int32)SnarlStatus.ErrorFailed;
}
}
else
{
nReturn = unchecked ((Int32)nSendMessageResult.ToInt64()); // Avoid aritmetic overflow error
}
}
finally
{
utf8Request = null;
Marshal.FreeHGlobal(ptrToCds);
Marshal.FreeHGlobal(ptrToUtf8Request);
}
return(nReturn);
}