public object WithRefsWithReturn(
ref string param1,
ref int param2,
ref short param3,
ref long param4,
ref uint param5,
ref ushort param6,
ref ulong param7,
ref bool param8,
ref double param9,
ref decimal param10,
ref int? param11,
ref object param12,
ref char param13,
ref DateTime param14,
ref Single param15,
ref IntPtr param16,
ref UInt16 param17,
ref UInt32 param18,
ref UInt64 param19,
ref UIntPtr param20
)
{
throw new Exception("Foo");
}
public bool PosTest1()
{
bool retVal = true;
const string c_TEST_ID = "P001";
const string c_TEST_DESC = "PosTest1: random valid UInt64 value";
string errorDesc;
UIntPtr actualUIntPtr;
bool actualResult;
TestLibrary.TestFramework.BeginScenario(c_TEST_DESC);
try
{
UInt64 ui = this.GetValidUInt64();
actualUIntPtr = new UIntPtr(ui);
actualResult = actualUIntPtr.ToUInt64() == ui;
if (!actualResult)
{
errorDesc = "Actual UIntPtr value is not " + ui + " as expected: Actual(" + actualUIntPtr + ")";
TestLibrary.TestFramework.LogError("001" + " TestId-" + c_TEST_ID, errorDesc);
retVal = false;
}
}
catch (Exception e)
{
errorDesc = "Unexpected exception: " + e;
TestLibrary.TestFramework.LogError("002" + " TestId-" + c_TEST_ID, errorDesc);
retVal = false;
}
return retVal;
}
public static unsafe void TestCtor_VoidPointer_ToPointer()
{
void* pv = new UIntPtr(42).ToPointer();
VerifyPointer(new UIntPtr(pv), 42);
VerifyPointer((UIntPtr)pv, 42);
}
private void WorkOnInstanceAndLocal()
{
UIntPtr localInt;
int i, j;
for ( i = 0; i < 100; i++ )
{
int index = randomNumGen.Next(0, ValueArraySize);
instanceInt_1 = ValueArray[index];
Thread.Sleep(index);
localInt = instanceInt_1;
for ( j = 0; j < ValueArraySize; j++ )
if ( ValueArray[j] == localInt )
break;
if (j == ValueArraySize )
throw new Exception("WorkOnInstanceAndLocal: Atomicity of Read/Write violated - " + localInt);
}
UIntPtr localInt_1;
localInt_1 = (UIntPtr)(1 + 1);
if((UInt32)localInt_1 != 2)
throw new Exception("Loc_7453fg! Major Error here");
localInt_1 = (UIntPtr)(UInt32.MaxValue + UInt32.MinValue);
if((UInt32)localInt_1 != UInt32.MaxValue)
throw new Exception("Loc_2375dsfg! Major Error here");
localInt_1 = (UIntPtr)(Int16.MaxValue * 2);
if((UInt32)localInt_1 != 65534)
throw new Exception("Loc_3975sg! Major Error here, " + localInt_1);
localInt_1 = (UIntPtr)UInt32.MaxValue;
if(localInt_1.GetHashCode() != 2147483647)
throw new Exception("Loc_5086dsfg! Major Error here, " + localInt_1.GetHashCode());
if(localInt_1.ToString() != "4294967295")
throw new Exception("Loc_24967esdfg! Major Error here, " + localInt_1.ToString());
}
public bool PosTest1()
{
bool retVal = true;
const string c_TEST_ID = "P001";
const string c_TEST_DESC = "PosTest1: UIntPtr.Zero vs UIntPtr(0)";
string errorDesc;
UIntPtr srcUIntPtr, expUIntPtr;
bool actualResult;
TestLibrary.TestFramework.BeginScenario(c_TEST_DESC);
try
{
expUIntPtr = new UIntPtr();
srcUIntPtr = UIntPtr.Zero;
actualResult = srcUIntPtr.Equals(expUIntPtr);
if (!actualResult)
{
errorDesc = "Source UIntPtr value does not equal" + expUIntPtr + " as expected: Actual(" + srcUIntPtr + ")";
TestLibrary.TestFramework.LogError("001" + " TestId-" + c_TEST_ID, errorDesc);
retVal = false;
}
}
catch (Exception e)
{
errorDesc = "Unexpected exception: " + e;
TestLibrary.TestFramework.LogError("002" + " TestId-" + c_TEST_ID, errorDesc);
retVal = false;
}
return retVal;
}
static extern bool ReadProcessMemory(
IntPtr hProcess,
IntPtr lpBaseAddress,
[Out] byte[] lpBuffer,
UIntPtr nSize,
[Out] out UIntPtr lpNumberOfBytesRead
);
public virtual bool runTest()
{
Console.Error.WriteLine(s_strTFPath + " " + s_strTFName + " , for " + s_strClassMethod + " , Source ver " + s_strDtTmVer);
int iCountErrors = 0;
int iCountTestcases = 0;
String strLoc = "Loc_000oo";
UIntPtr ip1;
UIntPtr ip2;
UInt32 iValue;
try {
strLoc = "Loc_743wg";
iValue = 16;
ip1 = new UIntPtr(iValue);
ip2 = new UIntPtr(iValue);
iCountTestcases++;
if(!ip1.Equals(ip2)){
iCountErrors++;
Console.WriteLine("Err_865sg! Wrong value returned");
}
strLoc = "Loc_9047tdsg";
iValue = 16;
ip1 = new UIntPtr(iValue);
ip2 = new UIntPtr(iValue*2);
iCountTestcases++;
if(ip1.Equals(ip2)){
iCountErrors++;
Console.WriteLine("Err_9765sgf! Wrong value returned");
}
strLoc = "Loc_98736zdg";
iValue = 16;
ip1 = new UIntPtr(iValue);
iCountTestcases++;
if(ip1.Equals(iValue)){
iCountErrors++;
Console.WriteLine("Err_9756gf! Wrong value returned");
}
strLoc = "Loc_98736zdg";
iValue = 16;
ip1 = new UIntPtr(iValue);
iCountTestcases++;
if(ip1.Equals(null)){
iCountErrors++;
Console.WriteLine("Err_973sdg! Wrong value returned");
}
} catch (Exception exc_general ) {
++iCountErrors;
Console.WriteLine(s_strTFAbbrev +" Error Err_8888yyy! strLoc=="+ strLoc +", exc_general=="+exc_general);
}
if ( iCountErrors == 0 )
{
Console.Error.WriteLine( "paSs. "+s_strTFPath +" "+s_strTFName+" ,iCountTestcases=="+iCountTestcases);
return true;
}
else
{
Console.Error.WriteLine("FAiL! "+s_strTFPath+" "+s_strTFName+" ,iCountErrors=="+iCountErrors+" , BugNums?: "+s_strActiveBugNums );
return false;
}
}
public static IntPtr VirtualAlloc(
SafeHandle baseAddress,
UIntPtr size,
int allocationType,
int protection)
{
return Interop.Kernel32.VirtualAlloc(baseAddress, size, allocationType, protection);
}
public static SafeMemoryMappedViewHandle MapViewOfFile(
SafeMemoryMappedFileHandle hFileMappingObject,
int desiredAccess,
long fileOffset,
UIntPtr numberOfBytesToMap)
{
return Interop.mincore.MapViewOfFileFromApp(hFileMappingObject, desiredAccess, fileOffset, numberOfBytesToMap);
}
private static void Outer()
{
float f = 42.0f;
double d = 43.0;
IntPtr ptr = new IntPtr(0x42424242);
UIntPtr uptr = new UIntPtr(0x43434343);
Middle();
}
public static IntPtr VirtualAlloc(
SafeHandle baseAddress,
UIntPtr size,
int allocationType,
int protection)
{
return Interop.mincore.VirtualAllocFromApp(baseAddress, size, allocationType, protection);
}
internal unsafe static IntPtr MemReAlloc(IntPtr ptr, UIntPtr newSize)
{
IntPtr allocatedMemory = Interop.Sys.MemReAlloc(ptr, newSize);
if (allocatedMemory == IntPtr.Zero)
{
throw new OutOfMemoryException();
}
return allocatedMemory;
}
internal static IntPtr MemAlloc(UIntPtr sizeInBytes, uint flags)
{
IntPtr allocatedMemory = Interop.mincore.HeapAlloc(Interop.mincore.GetProcessHeap(), flags, sizeInBytes);
if (allocatedMemory == IntPtr.Zero)
{
throw new OutOfMemoryException();
}
return allocatedMemory;
}
internal static IntPtr MemReAlloc(IntPtr ptr, UIntPtr oldSize, UIntPtr newSize, uint flags)
{
IntPtr allocatedMemory = Interop.mincore.HeapReAlloc(Interop.mincore.GetProcessHeap(), flags, ptr, newSize);
if (allocatedMemory == IntPtr.Zero)
{
throw new OutOfMemoryException();
}
return allocatedMemory;
}
internal static IntPtr MemAlloc(UIntPtr sizeInBytes)
{
IntPtr allocatedMemory = Interop.Sys.MemAlloc(sizeInBytes);
if (allocatedMemory == IntPtr.Zero)
{
throw new OutOfMemoryException();
}
return allocatedMemory;
}
internal static void FirstPassFrameEntered(object exceptionObj, byte* enteredFrameIP, UIntPtr enteredFrameSP)
{
s_cachedEventMask = InternalCalls.RhpGetRequestedExceptionEvents();
if ((s_cachedEventMask & ExceptionEventKind.FirstPassFrameEntered) == 0)
return;
InternalCalls.RhpSendExceptionEventToDebugger(ExceptionEventKind.FirstPassFrameEntered, enteredFrameIP, enteredFrameSP);
}
internal static void BeginFirstPass(object exceptionObj, byte* faultingIP, UIntPtr faultingFrameSP)
{
s_cachedEventMask = InternalCalls.RhpGetRequestedExceptionEvents();
if ((s_cachedEventMask & ExceptionEventKind.Thrown) == 0)
return;
InternalCalls.RhpSendExceptionEventToDebugger(ExceptionEventKind.Thrown, faultingIP, faultingFrameSP);
}
public virtual bool runTest()
{
Console.Error.WriteLine(s_strTFPath + " " + s_strTFName + " , for " + s_strClassMethod + " , Source ver " + s_strDtTmVer);
int iCountErrors = 0;
int iCountTestcases = 0;
String strLoc = "Loc_000oo";
UIntPtr ip1;
UInt32 iValue;
try {
strLoc = "Loc_743wg";
iValue = 16;
ip1 = new UIntPtr(iValue);
iCountTestcases++;
if(ip1.GetHashCode() != iValue){
iCountErrors++;
Console.WriteLine("Err_865sg! Wrong value returned");
}
strLoc = "Loc_87453sg";
iValue = 0;
ip1 = new UIntPtr(iValue);
iCountTestcases++;
if(ip1.GetHashCode() != iValue){
iCountErrors++;
Console.WriteLine("Err_9743sg! Wrong value returned");
}
strLoc = "Loc_87453sg";
iValue = UInt32.MaxValue;
ip1 = new UIntPtr(iValue);
iCountTestcases++;
if(ip1.GetHashCode() != 2147483647){
iCountErrors++;
Console.WriteLine("Err_97253rdg! Wrong value returned, {0} {1}", ip1.GetHashCode(), iValue);
}
strLoc = "Loc_87453sg";
iValue = UInt32.MinValue;
ip1 = new UIntPtr(iValue);
iCountTestcases++;
if(ip1.GetHashCode() != iValue){
iCountErrors++;
Console.WriteLine("Err_93756sg! Wrong value returned");
}
} catch (Exception exc_general ) {
++iCountErrors;
Console.WriteLine(s_strTFAbbrev +" Error Err_8888yyy! strLoc=="+ strLoc +", exc_general=="+exc_general);
}
if ( iCountErrors == 0 )
{
Console.Error.WriteLine( "paSs. "+s_strTFPath +" "+s_strTFName+" ,iCountTestcases=="+iCountTestcases);
return true;
}
else
{
Console.Error.WriteLine("FAiL! "+s_strTFPath+" "+s_strTFName+" ,iCountErrors=="+iCountErrors+" , BugNums?: "+s_strActiveBugNums );
return false;
}
}
internal static unsafe IntPtr MemReAllocWithZeroInitializeNoThrow(IntPtr ptr, UIntPtr oldSize, UIntPtr newSize)
{
IntPtr allocatedMemory = Interop.Sys.MemReAlloc(ptr, newSize);
if (allocatedMemory != IntPtr.Zero && (long) newSize > (long) oldSize)
{
IntPtr pBuffer = (IntPtr) (((byte *) allocatedMemory) + (long) oldSize);
Interop.Sys.MemSet(pBuffer, 0, (UIntPtr) ((long) newSize - (long) oldSize));
}
return allocatedMemory;
}
public virtual bool runTest()
{
Console.Error.WriteLine(s_strTFPath + " " + s_strTFName + " , for " + s_strClassMethod + " , Source ver " + s_strDtTmVer);
int iCountErrors = 0;
int iCountTestcases = 0;
String strLoc = "Loc_000oo";
UInt32 iValue;
UIntPtr ip1;
try {
strLoc = "Loc_743wg";
iValue = 16;
ip1 = new UIntPtr(iValue);
iCountTestcases++;
if(ip1.ToString() != iValue.ToString()){
iCountErrors++;
Console.WriteLine("Err_2975sf! Wrong value returned");
}
strLoc = "Loc_0084wf";
iValue = 0;
ip1 = new UIntPtr(iValue);
iCountTestcases++;
if(ip1.ToString() != iValue.ToString()){
iCountErrors++;
Console.WriteLine("Err_974325sdg! Wrong value returned");
}
strLoc = "Loc_93476sdg";
iValue = UInt32.MaxValue;
ip1 = new UIntPtr(iValue);
iCountTestcases++;
if(ip1.ToString() != iValue.ToString()){
iCountErrors++;
Console.WriteLine("Err_07536tsg! Wrong value returned");
}
iValue = UInt32.MinValue;
ip1 = new UIntPtr(iValue);
if(ip1.ToString() != iValue.ToString()){
iCountErrors++;
Console.WriteLine("Err_9875wrsg! Wrong value returned");
}
} catch (Exception exc_general ) {
++iCountErrors;
Console.WriteLine(s_strTFAbbrev +" Error Err_8888yyy! strLoc=="+ strLoc +", exc_general=="+exc_general);
}
if ( iCountErrors == 0 )
{
Console.Error.WriteLine( "paSs. "+s_strTFPath +" "+s_strTFName+" ,iCountTestcases=="+iCountTestcases);
return true;
}
else
{
Console.Error.WriteLine("FAiL! "+s_strTFPath+" "+s_strTFName+" ,iCountErrors=="+iCountErrors+" , BugNums?: "+s_strActiveBugNums );
return false;
}
}
public static void TestSubtract(UIntPtr ptr, int offset, ulong expected)
{
UIntPtr p1 = UIntPtr.Subtract(ptr, offset);
VerifyPointer(p1, expected);
UIntPtr p2 = ptr - offset;
VerifyPointer(p2, expected);
UIntPtr p3 = ptr;
p3 -= offset;
VerifyPointer(p3, expected);
}
public static void TestAdd(UIntPtr ptr, int offset, ulong expected)
{
UIntPtr p1 = UIntPtr.Add(ptr, offset);
VerifyPointer(p1, expected);
UIntPtr p2 = ptr + offset;
VerifyPointer(p2, expected);
UIntPtr p3 = ptr;
p3 += offset;
VerifyPointer(p3, expected);
}
public static SafeMemoryMappedViewHandle MapViewOfFile(
SafeMemoryMappedFileHandle hFileMappingObject,
int desiredAccess,
long fileOffset,
UIntPtr numberOfBytesToMap)
{
// split the long into two ints
int offsetHigh, offsetLow;
SplitLong(fileOffset, out offsetHigh, out offsetLow);
return Interop.Kernel32.MapViewOfFile(hFileMappingObject, desiredAccess, offsetHigh, offsetLow, numberOfBytesToMap);
}
internal static unsafe IntPtr MemReAlloc(IntPtr ptr, UIntPtr oldSize, UIntPtr newSize, uint flags)
{
IntPtr allocatedMemory = Interop.Sys.MemReAlloc(ptr, newSize);
if (allocatedMemory == IntPtr.Zero)
{
throw new OutOfMemoryException();
}
if ((flags & HEAP_ZERO_MEMORY) != 0 && (int) newSize > (int) oldSize)
{
IntPtr pBuffer = (IntPtr) (((byte *) allocatedMemory) + (int) oldSize);
Interop.Sys.MemSet(pBuffer, 0, (UIntPtr) ((int) newSize - (int) oldSize));
}
return allocatedMemory;
}
internal static void EndFirstPass(object exceptionObj, byte* handlerIP, UIntPtr handlingFrameSP)
{
if (handlerIP == null)
{
if ((s_cachedEventMask & ExceptionEventKind.Unhandled) == 0)
return;
InternalCalls.RhpSendExceptionEventToDebugger(ExceptionEventKind.Unhandled, null, UIntPtr.Zero);
}
else
{
if ((s_cachedEventMask & ExceptionEventKind.CatchHandlerFound) == 0)
return;
InternalCalls.RhpSendExceptionEventToDebugger(ExceptionEventKind.CatchHandlerFound, handlerIP, handlingFrameSP);
}
}
public bool PosTest1()
{
bool retVal = true;
const string c_TEST_ID = "P001";
string testDesc = string.Format("PosTest1: value is a random {0}-bit c-style generic pointer",
8*UIntPtr.Size);
string errorDesc;
UIntPtr actualUIntPtr;
bool actualResult;
TestLibrary.TestFramework.BeginScenario(testDesc);
try
{
void * ptr;
if(UIntPtr.Size == 4) //32-bit platform
{
ptr = (void *)TestLibrary.Generator.GetInt32(-55);
}
else //64-bit platform
{
ptr = (void *)TestLibrary.Generator.GetInt64(-55);
}
actualUIntPtr = new UIntPtr(ptr);
actualResult = actualUIntPtr.ToPointer() == ptr;
if (!actualResult)
{
errorDesc = "Actual UIntPtr value is not " + (UInt64)ptr + " as expected: Actual(" + actualUIntPtr + ")";
TestLibrary.TestFramework.LogError("001" + " TestId-" + c_TEST_ID, errorDesc);
retVal = false;
}
}
catch (Exception e)
{
errorDesc = "Unexpected exception: " + e;
TestLibrary.TestFramework.LogError("002" + " TestId-" + c_TEST_ID, errorDesc);
retVal = false;
}
return retVal;
}
static public string getRegKeyValue( UIntPtr root_key, String key_name, RegSAM is32or64key, String inPropertyName)
{
int phkResult = 0;
try
{
uint lResult = RegOpenKeyEx( root_key, key_name, 0, (int) RegSAM.QueryValue | (int) is32or64key, out phkResult );
if ( lResult != 0 )
return null;
uint lpType = 0;
uint lpcbData = 1024;
StringBuilder value_buffer = new StringBuilder( 1024 );
RegQueryValueEx( phkResult, inPropertyName, 0, ref lpType, value_buffer, ref lpcbData );
string value = value_buffer.ToString();
return value;
}
finally
{
if ( phkResult != 0 )
RegCloseKey( phkResult );
}
}
protected internal RegisterDeviceCommand(UIntPtr dummy) : base(dummy)
{
}
internal static extern void keybd_event(byte bVk, byte bScan, uint dwFlags, UIntPtr dwExtraInfo);
protected internal ChatItemElements(UIntPtr dummy)
{
}
public static UIntPtr VolatileRead (ref UIntPtr address)
{
throw new System.NotImplementedException();
}
public static extern IntPtr OpenCLDevice_GetKernelProfileRecords(IntPtr Instance, out UIntPtr length);
internal static void ScopeEnter(IntPtr hID, UIntPtr src, UIntPtr info, out IntPtr hScp, string fmtPrintfW, System.String a1, System.String a2);
public static extern IntPtr GetKeyboardLayout(UIntPtr idThread);
internal static extern unsafe void memcpy(void *dst, void *src, UIntPtr length);
protected internal LevelMap(UIntPtr dummy)
{
}
public static extern UIntPtr SetTimer(IntPtr hWnd, UIntPtr nIDEvent, uint uElapse, TimerProc lpTimerFunc);
public static extern IntPtr Statistics_GetInstance(IntPtr list, UIntPtr channel);
public static extern byte *MapViewOfFileEx(IntPtr hFileMappingObject,
NativeFileMapAccessType dwDesiredAccess,
uint dwFileOffsetHigh,
uint dwFileOffsetLow,
UIntPtr dwNumberOfBytesToMap,
byte *lpBaseAddress);
internal static void ScopeEnter(IntPtr hID, UIntPtr src, UIntPtr info, out IntPtr hScp, string fmtPrintfW, System.Int32 a1, System.Boolean a2, System.Int32 a3);
internal static void Trace(IntPtr hID, UIntPtr src, UIntPtr info, string fmtPrintfW, System.Int32 a1, System.String a2, System.Boolean a3);
internal static extern bool PostThreadMessage(
uint idThread,
uint Msg,
UIntPtr wParam,
IntPtr lParam);
internal static extern unsafe void memset(void *dst, int c, UIntPtr length);
static extern void mouse_event(MouseEventFlag flags, int dx, int dy, uint data, UIntPtr extraInfo);
public static extern IntPtr OpenCLDevice_GetKernelProfileRecord(IntPtr list, UIntPtr index);
internal static void Trace(IntPtr hID, UIntPtr src, UIntPtr info, string fmtPrintfW, System.Int32 a1, System.Int32 a2, System.Int64 a3, System.UInt32 a4, System.Int32 a5, System.UInt32 a6, System.UInt32 a7);
internal static extern /* from(size_t) */ UIntPtr TurnBasedMatchConfig_PlayerIdsToInvite_GetElement(
HandleRef self,
/* from(size_t) */ UIntPtr index,
/* from(char *) */ StringBuilder out_arg,
/* from(size_t) */ UIntPtr out_size);
internal static void Trace(IntPtr hID, UIntPtr src, UIntPtr info, string fmtPrintfW, System.String a1, System.String a2);
private static extern void *HeapReAlloc(IntPtr hHeap, int flags, void *block, UIntPtr size);
internal static extern IntPtr MapViewOfFile(
IntPtr hFileMappingObject,
uint dwDesiredAccess,
uint dwFileOffsetHigh,
uint dwFileOffsetLow,
UIntPtr dwNumberOfBytesToMap);
private static extern void *HeapAlloc(IntPtr hHeap, int flags, UIntPtr size);
internal static extern IntPtr HeapAlloc(IntPtr hHeap, uint dwFlags, UIntPtr dwBytes);
internal static extern bool WriteProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, byte[] lpBuffer, uint nSize, out UIntPtr lpNumberOfBytesWritten);
internal static extern bool VirtualProtect(
IntPtr lpAddress,
UIntPtr dwSize,
uint flNewProtect,
out uint lpflOldProtect);
public static void VolatileWrite (ref UIntPtr address, UIntPtr value)
{
throw new System.NotImplementedException();
}
internal static extern bool VirtualFree(
IntPtr lpAddress,
UIntPtr dwSize,
uint dwFreeType);
internal static extern SafeOverlappedFree LocalAlloc_SafeOverlappedFree(int uFlags, UIntPtr sizetdwBytes);
internal static extern IntPtr VirtualAlloc(
IntPtr lpAddress,
UIntPtr dwSize,
uint flAllocationType,
uint flProtect);
public extern static bool PrefetchVirtualMemory(IntPtr hProcess, UIntPtr NumberOfEntries,
WIN32_MEMORY_RANGE_ENTRY *VirtualAddresses, ulong Flags);
internal static void Trace(IntPtr hID, UIntPtr src, UIntPtr info, string fmtPrintfW, System.Int32 a1, System.Int32 a2, System.String a3, System.String a4, System.Int32 a5);
