/// <summary>
/// Non-critical failure, should only crash on debug
/// </summary>
/// <param name="text"></param>
public static void SoftFail(string text)
{
if (Debugger.IsAttached)
{
Debug.Fail(text);
}
}
/// <summary>
/// Returns true if a button was clicked.
/// </summary>
private static void TryClickNextNsisButton(IUIItemContainer target)
{
var badButtons = new[] { NsisCancelAutomationId, NsisNoAutomationId };
var goodButtons = new[] { NsisForwardAutomationId, NsisYesAutomationId };
var allButtons =
target.GetMultiple(SearchCriteria.ByControlType(typeof(Button), WindowsFramework.Win32))
.Cast <Button>();
// Filter out buttons that should not be pressed like "Cancel".
var filteredButtons = allButtons.Where(x => x.Enabled).Where(NotControlBoxButton).ToList();
var buttons = filteredButtons.Count > 1
? filteredButtons
.Where(x => !badButtons.Any(y => x.Id.Equals(y, StringComparison.InvariantCulture)))
.ToList()
: filteredButtons;
if (buttons.Any())
{
var nextButton = buttons.FirstOrDefault(x =>
goodButtons.Any(
y => x.Id.Equals(y, StringComparison.InvariantCulture)));
if (nextButton == null)
{
nextButton = TryGetByName(buttons);
if (nextButton == null)
{
Debug.Fail("Nothing to press!");
return;
}
}
// Finally press the button, doesn't require messing with the mouse.
//nextButton.RaiseClickEvent();
nextButton.Focus();
nextButton.KeyIn(KeyboardInput.SpecialKeys.RETURN);
}
}
internal static void Fail(string message)
{
#if NETFRAMEWORK
SystemDebug.Fail(message);
#else
SystemDebug.WriteLine("Debug failure occurred - " + (message ?? "No message"));
// preventing the attach dialog come up if already attached it once
if (!everAttached)
{
everAttached = Debugger.IsAttached;
}
if (!everAttached)
{
Debugger.Launch();
everAttached = true;
}
else
{
Debugger.Break();
}
#endif
}
private bool CompareTypeSigs(ref NativeParser parser1, NativeFormatModuleInfo moduleHandle1, ref NativeParser parser2, NativeFormatModuleInfo moduleHandle2)
{
// startOffset lets us backtrack to the TypeSignatureKind for external types since the TypeLoader
// expects to read it in.
uint data1;
uint startOffset1 = parser1.Offset;
var typeSignatureKind1 = parser1.GetTypeSignatureKind(out data1);
// If the parser is at a lookback type, get a new parser for it and recurse.
// Since we haven't read the element type of parser2 yet, we just pass it in unchanged
if (typeSignatureKind1 == TypeSignatureKind.Lookback)
{
NativeParser lookbackParser1 = parser1.GetLookbackParser(data1);
return(CompareTypeSigs(ref lookbackParser1, moduleHandle1, ref parser2, moduleHandle2));
}
uint data2;
var typeSignatureKind2 = parser2.GetTypeSignatureKind(out data2);
// If parser2 is a lookback type, we need to rewind parser1 to its startOffset1
// before recursing.
if (typeSignatureKind2 == TypeSignatureKind.Lookback)
{
NativeParser lookbackParser2 = parser2.GetLookbackParser(data2);
parser1 = new NativeParser(parser1.Reader, startOffset1);
return(CompareTypeSigs(ref parser1, moduleHandle1, ref lookbackParser2, moduleHandle2));
}
if (typeSignatureKind1 != typeSignatureKind2)
{
return(false);
}
switch (typeSignatureKind1)
{
case TypeSignatureKind.Lookback:
{
// Recursion above better have removed all lookbacks
Debug.Fail("Unexpected lookback type");
return(false);
}
case TypeSignatureKind.Modifier:
{
// Ensure the modifier kind (vector, pointer, byref) is the same
if (data1 != data2)
{
return(false);
}
return(CompareTypeSigs(ref parser1, moduleHandle1, ref parser2, moduleHandle2));
}
case TypeSignatureKind.Variable:
{
// variable index is in data
if (data1 != data2)
{
return(false);
}
break;
}
case TypeSignatureKind.MultiDimArray:
{
// rank is in data
if (data1 != data2)
{
return(false);
}
if (!CompareTypeSigs(ref parser1, moduleHandle1, ref parser2, moduleHandle2))
{
return(false);
}
uint boundCount1 = parser1.GetUnsigned();
uint boundCount2 = parser2.GetUnsigned();
if (boundCount1 != boundCount2)
{
return(false);
}
for (uint i = 0; i < boundCount1; i++)
{
if (parser1.GetUnsigned() != parser2.GetUnsigned())
{
return(false);
}
}
uint lowerBoundCount1 = parser1.GetUnsigned();
uint lowerBoundCount2 = parser2.GetUnsigned();
if (lowerBoundCount1 != lowerBoundCount2)
{
return(false);
}
for (uint i = 0; i < lowerBoundCount1; i++)
{
if (parser1.GetUnsigned() != parser2.GetUnsigned())
{
return(false);
}
}
break;
}
case TypeSignatureKind.FunctionPointer:
{
// callingConvention is in data
if (data1 != data2)
{
return(false);
}
uint argCount1 = parser1.GetUnsigned();
uint argCount2 = parser2.GetUnsigned();
if (argCount1 != argCount2)
{
return(false);
}
for (uint i = 0; i < argCount1; i++)
{
if (!CompareTypeSigs(ref parser1, moduleHandle1, ref parser2, moduleHandle2))
{
return(false);
}
}
break;
}
case TypeSignatureKind.Instantiation:
{
// Type parameter count is in data
if (data1 != data2)
{
return(false);
}
if (!CompareTypeSigs(ref parser1, moduleHandle1, ref parser2, moduleHandle2))
{
return(false);
}
for (uint i = 0; i < data1; i++)
{
if (!CompareTypeSigs(ref parser1, moduleHandle1, ref parser2, moduleHandle2))
{
return(false);
}
}
break;
}
case TypeSignatureKind.BuiltIn:
RuntimeTypeHandle typeHandle3 = ((WellKnownType)data1).GetRuntimeTypeHandle();
RuntimeTypeHandle typeHandle4 = ((WellKnownType)data2).GetRuntimeTypeHandle();
if (!typeHandle3.Equals(typeHandle4))
{
return(false);
}
break;
case TypeSignatureKind.External:
{
RuntimeTypeHandle typeHandle1 = GetExternalTypeHandle(moduleHandle1, data1);
RuntimeTypeHandle typeHandle2 = GetExternalTypeHandle(moduleHandle2, data2);
if (!typeHandle1.Equals(typeHandle2))
{
return(false);
}
break;
}
default:
return(false);
}
return(true);
}
