'@TestMethod
Public Sub TestMethod1() 'TODO Rename test
    On Error GoTo TestFail

    Fakes.MsgBox.Returns 42
    MsgBox "Is logged"
    Assert.Inconclusive

TestExit:
    Exit Sub
TestFail:
    Assert.Fail "Test raised an error: #" & Err.Number & " - " & Err.Description
End Sub

With Fakes.MsgBox.Verify
    .Invocations 2
    .Parameter "prompt", "Hello from SomeSub", 1
    .Parameter "prompt", "Second call", 2
End With

Sub foo()

  Dim curr As Single
  Dim last As Single
  Dim cnt As Long

  last = Timer

  Do While cnt < 50
    curr = Timer
    If curr > last Then
      Debug.Print last, curr, curr > last
      last = curr
      cnt = cnt + 1
    End If
  Loop

End Sub

 40892.64      40892.64     True
 40892.64      40892.65     True
 40892.65      40892.65     True
 40892.65      40892.66     True
 40892.66      40892.66     True
 40892.66      40892.66     True
 40892.66      40892.67     True

42256.20000000000000        42256.21000000000000        True
42256.21000000000000        42256.21000000000000        True
42256.21000000000000        42256.21000000000000        True
42256.21000000000000        42256.22000000000000        True

Dim diff As Double
diff = curr - last
If curr > last Then
  Debug.Print Format$(last, f), Format$(curr, f), diff
  last = curr
  cnt = cnt + 1
End If

42336.82000000000000        42336.83000000000000         0.00390625
42336.83000000000000        42336.83000000000000         0.00390625
42336.83000000000000        42336.84000000000000         0.00390625
42336.84000000000000        42336.84000000000000         0.00390625
42336.84000000000000        42336.84000000000000         0.00390625
42336.84000000000000        42336.85000000000000         0.00390625

public interface IVerify
{
    void AtLeast(int invocations);
    void AtLeastOnce();
    void AtMost(int invocations);
    void AtMostOnce();
    void Between(int minimum, int maximum);
    void Exactly(int invocations);
    void Never();
    void Once();
    void Parameter(string parameter, object value, int invocation = 1);
    void ParameterIsPassed(string parameter, int invocation = 1);
    void ParameterIsType(string parameter, string typeName, int invocation = 1);
}

    //Any time the selected control changes in the hosted userform, the F3 Overlay has to be redrawn.  This is a good proxy
    //for child control selections, so raise a focus event.
    if ((int) msg == (int)WM.ERASEBKGND)
    {
        DispatchFocusEvent(FocusType.GotFocus);
    }

    //DO NOT REMOVE THIS CALL. Dockable windows are instantiated by the VBE, not directly by RD.  On top of that,
    //since we have to inherit from UserControl we don't have to keep handling window messages until the VBE gets
    //around to destroying the control's host or it results in an access violation when the base class is disposed.
    //We need to manually call base.Dispose() ONLY in response to a WM_DESTROY message.
    _thisHandle = GCHandle.Alloc(this, GCHandleType.Normal);

    if (value.GetType() == typeof(AssertClass))
    {
        AssertHandler.OnAssertInconclusive("Don't be ridiculous.");
    }

    if (value.GetType() == typeof(IVerify))
    {
        AssertHandler.OnAssertInconclusive("Woah! Meta IVerify.");
    }

    if (value.GetType() == typeof(IFake))
    {
        AssertHandler.OnAssertInconclusive("expected: Stack overflow?; actual: Guard clause.");
    }

    if (value.GetType() == typeof(IVerify))
    {
        AssertHandler.OnAssertInconclusive("IVerify too.");
    }

public interface IDeclaration
{
    [ComVisible(true)]
    string Name { get; }
    [ComVisible(true)]
    Accessibility Accessibility { get; }
    [ComVisible(true)]
    DeclarationType DeclarationType { get; }
    string TypeName { get; }
    [ComVisible(true)]
    bool IsArray { get; }
    [ComVisible(true)]
    Declaration ParentDeclaration { get; }
    [ComVisible(true)]
    IdentifierReference[] References { get; }
}

var components = GetDeclaration(parameter).Project.VBComponents;
{
    components.Add(ComponentType.StandardModule);
}

protected override void ExecuteImpl(object parameter)
{
    _newUnitTestModuleCommand.Execute(parameter != null
        ? GetDeclaration(parameter).Project
        : _vbe.ActiveVBProject);
}