public void Set_Breakpoints_Correctly()
{
var options = new IndexOptions()
{
BreakpointMasks = new []
{
new BreakpointMask("kernel32", "*create*"),
new BreakpointMask("kernel32", "*process*"),
},
AccessBreakpoints = new []
{
new AccessBreakpoint(0x100, 8, true, false),
}
};
var indexMethod = new IndexMethod();
BreakpointFacadeBuilder breakpointFacadeBuilder = new BreakpointFacadeBuilder();
indexMethod.BreakpointFacade = breakpointFacadeBuilder
.WithSetBreakpointByMask()
.WithSetReadAccessBreakpoint()
.Build();
indexMethod.SetBreakpoints(options);
breakpointFacadeBuilder.Mock.Verify(facade => facade.SetBreakpointByMask(It.IsAny <string>(), It.IsAny <string>()), Times.Exactly(2));
breakpointFacadeBuilder.Mock.Verify(facade => facade.SetReadAccessBreakpoint(It.IsAny <int>(), It.IsAny <ulong>()), Times.Once);
}
public void Set_Breakpoint_Correctly()
{
var builder = new BreakpointFacadeBuilder();
builder.WithSetBreakpointByMask();
var bp = BreakpointMask.Parse("kernel32!*");
bp.SetBreakpoint(builder.Mock.Object);
builder.Mock.Verify(facade => facade.SetBreakpointByMask("kernel32", "*"), Times.Once);
}
public void Set_Breakpoint_Correctly()
{
var bp = AccessBreakpoint.Parse("rw8:abc000");
var builder = new BreakpointFacadeBuilder();
var facade = builder
.WithSetReadAccessBreakpoint()
.WithSetWriteAccessBreakpoint()
.Build();
bp.SetBreakpoint(facade);
builder.Mock.Verify(breakpointFacade => breakpointFacade.SetReadAccessBreakpoint(8, 0xabc000), Times.Once);
builder.Mock.Verify(breakpointFacade => breakpointFacade.SetWriteAccessBreakpoint(8, 0xabc000), Times.Once);
}
public void Upsert_Frames_From_Breaks()
{
var dbg = new DebugEngineProxyBuilder();
var tt = new TimeTravelFacadeBuilder(dbg);
var sc = new ServerClientBuilder();
var bp = new BreakpointFacadeBuilder();
dbg.WithRunUntilBreak();
var count = 0;
dbg.SetRunUntilBreakCallback(() =>
{
if (count++ > 0)
{
tt.AdvanceToNextPosition();
}
});
var dbgEngProxy = dbg.Build();
var timeTravelFacade = tt.Build();
var serverClient = sc.Build();
var bpFacade = bp.Build();
dbg.CurrentThreadId = MockFrames.SingleThreaded0.First().ThreadId;
tt.WithFrames(MockFrames.SingleThreaded0);
sc.WithUpsertFrames(() => { });
var indexMethod = new IndexMethod
{
DebugEngineProxy = dbgEngProxy,
TimeTravelFacade = timeTravelFacade,
ServerClient = serverClient,
BreakpointFacade = bpFacade
};
indexMethod.ProcessInternal(new Position(0, 0), MockFrames.SingleThreaded0.Max(x => x.Position),
new IndexOptions());
sc.Mock.Verify(client =>
client.UpsertFrames(
It.Is <IEnumerable <Frame> >(frames => frames.SequenceEqual(MockFrames.SingleThreaded0))));
}
public void Set_Breakpoints_If_They_Are_Provided_In_The_Options()
{
// arrange
var indexMethod = new IndexMethod();
var indexOptions = new IndexOptions
{
AccessBreakpoints = new[]
{
AccessBreakpoint.Parse("r8:100"),
AccessBreakpoint.Parse("w8:200"),
AccessBreakpoint.Parse("rw4:300")
},
BreakpointMasks = new[]
{
BreakpointMask.Parse("kernel32!createprocess*"),
BreakpointMask.Parse("user32!*"),
BreakpointMask.Parse("mycustommod!myfancyfunction")
}
};
var builder = new BreakpointFacadeBuilder();
indexMethod.BreakpointFacade = builder.Build();
// act
indexMethod.SetBreakpoints(indexOptions);
// assert
builder.Mock.Verify(proxy => proxy.SetBreakpointByMask("kernel32", "createprocess*"), Times.Once);
builder.Mock.Verify(proxy => proxy.SetBreakpointByMask("user32", "*"), Times.Once);
builder.Mock.Verify(proxy => proxy.SetBreakpointByMask("mycustommod", "myfancyfunction"), Times.Once);
builder.Mock.Verify(proxy => proxy.SetReadAccessBreakpoint(0x8, 0x100), Times.Once);
builder.Mock.Verify(proxy => proxy.SetReadAccessBreakpoint(0x4, 0x300), Times.Once);
builder.Mock.Verify(proxy => proxy.SetWriteAccessBreakpoint(0x8, 0x200), Times.Once);
builder.Mock.Verify(proxy => proxy.SetWriteAccessBreakpoint(0x4, 0x300), Times.Once);
}