golang/delve
1
0
Fork 0
mirror of https://github.com/go-delve/delve.git synced 2025-10-29 09:46:56 +08:00
Code Issues Packages Projects Releases Wiki Activity

Refactor: Introduce fn to launch proc and run test

Browse Source
This commit is contained in:
Derek Parker
2014-05-30 10:12:18 -05:00
parent f6792c37f5
commit 6abfc19147
1 changed files with 105 additions and 151 deletions
Download Patch File Download Diff File Expand all files Collapse all files

256
proctl/proctl_test.go
View File

@ -7,6 +7,8 @@ import (
"testing" "testing"
) )
type testfunc func(p *DebuggedProcess)
func dataAtAddr(pid int, addr uint64) ([]byte, error) { func dataAtAddr(pid int, addr uint64) ([]byte, error) {
data := make([]byte, 1) data := make([]byte, 1)
_, err := syscall.PtracePeekData(pid, uintptr(addr), data) _, err := syscall.PtracePeekData(pid, uintptr(addr), data)
@ -26,6 +28,22 @@ func getRegisters(p *DebuggedProcess, t *testing.T) *syscall.PtraceRegs {
return regs return regs
} }
func withTestProcess(name string, t *testing.T, fn testfunc) {
cmd, err := StartTestProcess(name)
if err != nil {
t.Fatal("Starting test process:", err)
}
pid := cmd.Process.Pid
p, err := NewDebugProcess(pid)
if err != nil {
t.Fatal("NewDebugProcess():", err)
}
defer cmd.Process.Kill()
fn(p)
}
func StartTestProcess(name string) (*exec.Cmd, error) { func StartTestProcess(name string) (*exec.Cmd, error) {
cmd := exec.Command("../fixtures/" + name) cmd := exec.Command("../fixtures/" + name)
@ -38,187 +56,123 @@ func StartTestProcess(name string) (*exec.Cmd, error) {
} }
func TestAttachProcess(t *testing.T) { func TestAttachProcess(t *testing.T) {
cmd, err := StartTestProcess("testprog") withTestProcess("testprog", t, func(p *DebuggedProcess) {
if err != nil { if !p.ProcessState.Sys().(syscall.WaitStatus).Stopped() {
t.Fatal("Starting test process:", err) t.Errorf("Process was not stopped correctly")
} }
})
pid := cmd.Process.Pid
p, err := NewDebugProcess(pid)
if err != nil {
t.Fatal("NewDebugProcess():", err)
}
if !p.ProcessState.Sys().(syscall.WaitStatus).Stopped() {
t.Errorf("Process was not stopped correctly")
}
cmd.Process.Kill()
} }
func TestStep(t *testing.T) { func TestStep(t *testing.T) {
cmd, err := StartTestProcess("testprog") withTestProcess("testprog", t, func(p *DebuggedProcess) {
if err != nil { regs := getRegisters(p, t)
t.Fatal("Starting test process:", err) rip := regs.PC()
}
pid := cmd.Process.Pid err := p.Step()
p, err := NewDebugProcess(pid) if err != nil {
if err != nil { t.Fatal("Step():", err)
t.Fatal("NewDebugProcess():", err) }
}
regs := getRegisters(p, t) regs = getRegisters(p, t)
rip := regs.PC()
err = p.Step() if rip >= regs.PC() {
if err != nil { t.Errorf("Expected %#v to be greater than %#v", regs.PC(), rip)
t.Fatal("Step():", err) }
} })
regs = getRegisters(p, t)
if rip >= regs.PC() {
t.Errorf("Expected %#v to be greater than %#v", regs.PC(), rip)
}
cmd.Process.Kill()
} }
func TestContinue(t *testing.T) { func TestContinue(t *testing.T) {
cmd, err := StartTestProcess("continuetestprog") withTestProcess("continuetestprog", t, func(p *DebuggedProcess) {
if err != nil { if p.ProcessState.Exited() {
t.Fatal("Starting test process:", err) t.Fatal("Process already exited")
} }
pid := cmd.Process.Pid err := p.Continue()
p, err := NewDebugProcess(pid) if err != nil {
if err != nil { t.Fatal("Continue():", err)
t.Fatal("NewDebugProcess():", err) }
}
if p.ProcessState.Exited() { if !p.ProcessState.Success() {
t.Fatal("Process already exited") t.Fatal("Process did not exit successfully")
} }
})
err = p.Continue()
if err != nil {
t.Fatal("Continue():", err)
}
if !p.ProcessState.Success() {
t.Fatal("Process did not exit successfully")
}
} }
func TestBreakPoint(t *testing.T) { func TestBreakPoint(t *testing.T) {
cmd, err := StartTestProcess("testprog") withTestProcess("testprog", t, func(p *DebuggedProcess) {
if err != nil { sleepytimefunc := p.GoSymTable.LookupFunc("main.sleepytime")
t.Fatal("Starting test process:", err) sleepyaddr := sleepytimefunc.Entry
}
pid := cmd.Process.Pid bp, err := p.Break(uintptr(sleepyaddr))
p, err := NewDebugProcess(pid) if err != nil {
if err != nil { t.Fatal("Break():", err)
t.Fatal("NewDebugProcess():", err) }
}
sleepytimefunc := p.GoSymTable.LookupFunc("main.sleepytime") breakpc := bp.Addr + 1
sleepyaddr := sleepytimefunc.Entry err = p.Continue()
if err != nil {
t.Fatal("Continue():", err)
}
bp, err := p.Break(uintptr(sleepyaddr)) regs := getRegisters(p, t)
if err != nil {
t.Fatal("Break():", err)
}
breakpc := bp.Addr + 1 pc := regs.PC()
err = p.Continue() if pc != breakpc {
if err != nil { t.Fatalf("Break not respected:\nPC:%d\nFN:%d\n", pc, breakpc)
t.Fatal("Continue():", err) }
}
regs := getRegisters(p, t) err = p.Step()
if err != nil {
t.Fatal(err)
}
pc := regs.PC() regs = getRegisters(p, t)
if pc != breakpc {
t.Fatalf("Break not respected:\nPC:%d\nFN:%d\n", pc, breakpc)
}
err = p.Step() pc = regs.PC()
if err != nil { if pc == breakpc {
t.Fatal(err) t.Fatalf("Step not respected:\nPC:%d\nFN:%d\n", pc, breakpc)
} }
})
regs = getRegisters(p, t)
pc = regs.PC()
if pc == breakpc {
t.Fatalf("Step not respected:\nPC:%d\nFN:%d\n", pc, breakpc)
}
cmd.Process.Kill()
} }
func TestBreakPointWithNonExistantFunction(t *testing.T) { func TestBreakPointWithNonExistantFunction(t *testing.T) {
cmd, err := StartTestProcess("testprog") withTestProcess("testprog", t, func(p *DebuggedProcess) {
if err != nil { _, err := p.Break(uintptr(0))
t.Fatal("Starting test process:", err) if err == nil {
} t.Fatal("Should not be able to break at non existant function")
}
pid := cmd.Process.Pid })
p, err := NewDebugProcess(pid)
if err != nil {
t.Fatal("NewDebugProcess():", err)
}
_, err = p.Break(uintptr(0))
if err == nil {
t.Fatal("Should not be able to break at non existant function")
}
cmd.Process.Kill()
} }
func TestClearBreakPoint(t *testing.T) { func TestClearBreakPoint(t *testing.T) {
cmd, err := StartTestProcess("testprog") withTestProcess("testprog", t, func(p *DebuggedProcess) {
if err != nil { fn := p.GoSymTable.LookupFunc("main.sleepytime")
t.Fatal("Starting test process:", err) bp, err := p.Break(uintptr(fn.Entry))
} if err != nil {
t.Fatal("Break():", err)
}
pid := cmd.Process.Pid int3, err := dataAtAddr(p.Pid, bp.Addr)
p, err := NewDebugProcess(pid) if err != nil {
if err != nil { t.Fatal(err)
t.Fatal("NewDebugProcess():", err) }
}
fn := p.GoSymTable.LookupFunc("main.sleepytime") bp, err = p.Clear(fn.Entry)
bp, err := p.Break(uintptr(fn.Entry)) if err != nil {
if err != nil { t.Fatal("Break():", err)
t.Fatal("Break():", err) }
}
int3, err := dataAtAddr(pid, bp.Addr) data, err := dataAtAddr(p.Pid, bp.Addr)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
bp, err = p.Clear(fn.Entry) if bytes.Equal(data, int3) {
if err != nil { t.Fatalf("Breakpoint was not cleared data: %#v, int3: %#v", data, int3)
t.Fatal("Break():", err) }
}
data, err := dataAtAddr(pid, bp.Addr) if len(p.BreakPoints) != 0 {
if err != nil { t.Fatal("Breakpoint not removed internally")
t.Fatal(err) }
} })
if bytes.Equal(data, int3) {
t.Fatalf("Breakpoint was not cleared data: %#v, int3: %#v", data, int3)
}
if len(p.BreakPoints) != 0 {
t.Fatal("Breakpoint not removed internally")
}
cmd.Process.Kill()
} }