* Re: [SCM] master: Add two new tests. Comment all tests. Add some specialized test observers.
[not found] <20080410085934.30578.qmail@sourceware.org>
@ 2008-04-11 17:30 ` Phil Muldoon
0 siblings, 0 replies; only message in thread
From: Phil Muldoon @ 2008-04-11 17:30 UTC (permalink / raw)
To: Frysk Hackers
pmuldoon@sourceware.org wrote:
This patch adds two new tests. Add watchpoint then delete watchpoint;
this tests that the delete really did happen (From the observer pool
down to the hardware). The second test tests Action.Continue; if a a
watchpoint triggers, does the inferior really continue.
This test also adds come explanation comments on what all the tests are
trying to achieve.
Regards
Phil
> The branch, master has been updated
> via 8ec6d823176230b7305b13861c58cc2f609c93e0 (commit)
> from 43514553d00994f50595dfcc218884a76ba2667c (commit)
>
> Those revisions listed above that are new to this repository have
> not appeared on any other notification email.
>
> - Log -----------------------------------------------------------------
> commit 8ec6d823176230b7305b13861c58cc2f609c93e0
> Author: Phil Muldoon <pmuldoon@redhat.com>
> Date: Thu Apr 10 09:58:52 2008 +0100
>
> Add two new tests. Comment all tests. Add some specialized test observers.
>
> 2008-04-10 Phil Muldoon <pmuldoon@redhat.com>
>
> * TestTaskObserverWatchpoint.java (testAddthenDeleteWatchpoint): New Test.
> (testWatchpointActionContinue): Ditto..
> (WatchObserver.setBlock): New. Set blocking strategy.
> (FailingWatchObserver): New Class.
> (OkToTerminateObserver): New Class.
>
> -----------------------------------------------------------------------
>
> Summary of changes:
> frysk-core/frysk/proc/ChangeLog | 8 +
> .../frysk/proc/TestTaskObserverWatchpoint.java | 183 +++++++++++++++++++-
> 2 files changed, 187 insertions(+), 4 deletions(-)
>
> First 500 lines of diff:
> diff --git a/frysk-core/frysk/proc/ChangeLog b/frysk-core/frysk/proc/ChangeLog
> index ee466c5..c6cdbd1 100644
> --- a/frysk-core/frysk/proc/ChangeLog
> +++ b/frysk-core/frysk/proc/ChangeLog
> @@ -1,3 +1,11 @@
> +2008-04-10 Phil Muldoon <pmuldoon@redhat.com>
> +
> + * TestTaskObserverWatchpoint.java (testAddthenDeleteWatchpoint): New Test.
> + (testWatchpointActionContinue): Ditto..
> + (WatchObserver.setBlock): New. Set blocking strategy.
> + (FailingWatchObserver): New Class.
> + (OkToTerminateObserver): New Class.
> +
> 2008-04-09 Phil Muldoon <pmuldoon@redhat.com>
>
> * TestTaskObserverWatchpoint.java: New.
> diff --git a/frysk-core/frysk/proc/TestTaskObserverWatchpoint.java b/frysk-core/frysk/proc/TestTaskObserverWatchpoint.java
> index a3ff13d..59b8c33 100644
> --- a/frysk-core/frysk/proc/TestTaskObserverWatchpoint.java
> +++ b/frysk-core/frysk/proc/TestTaskObserverWatchpoint.java
> @@ -58,6 +58,12 @@ extends TestLib
>
> private static final Log fine = Log.fine(TestTaskObserverWatchpoint.class);
>
> + // This test case test whether watchpoints are caught when stepping. This is an important yet subtle
> + // test. As a sigtrap is generated from ptrace each time "an event" happens, when one steps over a
> + // watchpoint "hitting" instruction there will be two sigtraps. One for the single-step completing
> + // and one for the watchpoint being triggered. This test tests the notion that both events occurred,
> + // that one of the two states was not starved of its sigtrap, that the watchpoint is hit, and the
> + // process blocked.
> public void testSteppingInstructionAndWatchpoint()
> {
> if (unresolvedOnPPC(5991))
> @@ -116,7 +122,12 @@ extends TestLib
>
> }
>
> -
> + // This test case tests whether watchpoints are caught when a task is in a straight
> + // "running" condition. This really tests the basic and advertised functionality of watchpoints:
> + // to be caught by hardware, not software. In this test: set up the watchpoint, set up
> + // a terminated observer to guard the watchpoint was caught, and simply set the task to run.
> + // If the watchpoint observer is called, and the test is blocked then the test passes. If the
> + // process terminates and the watchpoint is not caught, then this signified an error condition.
> public void testRunningAndWatchpoint () {
> if (unresolvedOnPPC(5991))
> return;
> @@ -166,6 +177,125 @@ extends TestLib
>
> }
>
> +
> + // This test tests that a watchpoint is properly deleted: from the othe observer lists
> + // and the hardware. In this case, if the watchpoint is caught, then it fails. It should have
> + // been deleted. This test adds the watchpoint, then runs to main, then deletes the watchpoint.
> + // After that, the test then steps the thread until termination. If the Terminated observer is
> + // called, and the watchpoint did not "hit", then the test passes.
> + public void testAddthenDeleteWatchpoint()
> + {
> + if (unresolvedOnPPC(5991))
> + return;
> +
> + // Create a blocked child.
> + DaemonBlockedAtEntry ackProc = new DaemonBlockedAtEntry(
> + Config.getPkgLibFile("funit-watchpoint"));
> + assertNotNull(ackProc);
> +
> + // Get Proc/Task.
> + Proc proc = ackProc.getMainTask().getProc();
> + Task task = proc.getMainTask();
> +
> + // Very early on, find Variable source for watch
> + long address = getGlobalSymbolAddress(task,"source");
> +
> + // Very early on, add watch observer
> + FailingWatchObserver watch = new FailingWatchObserver();
> + task.requestAddWatchObserver(watch, address, 4, true);
> +
> +
> + // Watch for any expected terminations of the child process.
> + OkToTerminateObserver to = new OkToTerminateObserver();
> + task.requestAddTerminatedObserver(to);
> +
> + // Break at main
> + long mainAddress = getGlobalSymbolAddress(task, "main");
> + CodeObserver co = new CodeObserver();
> + task.requestAddCodeObserver(co, mainAddress);
> + ackProc.requestUnblock();
> + assertRunUntilStop("Run to main");
> +
> + // Test the watch was added
> + assertTrue("added", watch.added);
> +
> + // Test the bp was added, and hit
> + assertTrue("added", co.added);
> + assertEquals("code bp hit", 1, co.hit);
> +
> + // Now Delete the watch observer, it should never be hit.
> + task.requestDeleteWatchObserver(watch, address, 4, true);
> +
> + // Add a stepping observer.
> + InstructionObserver instr = new InstructionObserver(task);
> + task.requestAddInstructionObserver(instr);
> + instr.setContinue(true);
> +
> + // Remove the bp, and run.
> + task.requestUnblock(co);
> + assertRunUntilStop("Run and test watchpoint ");
> +
> + // Task should have terminated now.
> + // Make sure the watchpoint was deleted
> + assertTrue("deleted watch", watch.deleted);
> +
> + // Make sure the watchpoint never triggered.
> + assertEquals("hit code", 0, watch.hit);
> +
> + // Make sure the task has terminated
> + assertEquals("task terminated", 1, to.hit);
> +
> + }
> +
> + // This test case tests whether watchpoints are caught when a task is in a straight
> + // "running" condition. When caught, the observer sets the task to Action.CONTINUE.
> + // Test that the task does continue, the the hardware debug registers have been
> + // properly set to allow this to happen, and that the task does continue
> + // until termination.
> + public void testWatchpointActionContinue () {
> + if (unresolvedOnPPC(5991))
> + return;
> +
> + DaemonBlockedAtEntry ackProc = new DaemonBlockedAtEntry(
> + Config.getPkgLibFile("funit-watchpoint"));
> + assertNotNull(ackProc);
> +
> + // Get Proc/Task.
> + Proc proc = ackProc.getMainTask().getProc();
> + Task task = proc.getMainTask();
> +
> + // Watch for expected terminations of the child process.
> + OkToTerminateObserver to = new OkToTerminateObserver();
> + task.requestAddTerminatedObserver(to);
> +
> + // Break at main
> + long mainAddress = getGlobalSymbolAddress(task, "main");
> + CodeObserver co = new CodeObserver();
> + task.requestAddCodeObserver(co, mainAddress);
> + ackProc.requestUnblock();
> + assertRunUntilStop("Run to main");
> +
> + // Find Variable source for watch
> + long address = getGlobalSymbolAddress(task,"source");
> +
> + // Add watch observer
> + WatchObserver watch = new WatchObserver(task, address, 4);
> +
> + // Do not block on trigger
> + watch.setBlock(false);
> + task.requestAddWatchObserver(watch, address, 4, true);
> +
> + // Unblock task from breakpoint
> + task.requestUnblock(co);
> + assertRunUntilStop("Run and test watchpoint ");
> +
> + // Make sure it triggered.
> + assertTrue("added", watch.added);
> + assertEquals("hit code", 1, watch.hit);
> + assertEquals("Task terminated", 1, to.hit);
> + }
> +
> +
> // Base class for this tests observers.
> // Keeps track of added, deleted and hit counts.
> static abstract class TestObserver implements TaskObserver
> @@ -198,6 +328,7 @@ extends TestLib
>
> public Action updateHit(Task task, long address) {
> fine.log("Hit breakpoint at ", address);
> + hit++;
> Manager.eventLoop.requestStop();
> return Action.BLOCK;
> }
> @@ -216,6 +347,20 @@ extends TestLib
> }
> }
>
> + // Simple observer to count termination of a thread when it
> + // is ok to do so.
> + static class OkToTerminateObserver extends TestObserver
> + implements TaskObserver.Terminated
> + {
> + // Shouldn't be triggered ever.
> + public Action updateTerminated(Task task, Signal signal, int value) {
> + hit++;
> + Manager.eventLoop.requestStop();
> + return Action.BLOCK;
> + }
> +
> + }
> +
>
> // Instruction Observer to simulate stepping
> static class InstructionObserver
> @@ -259,7 +404,7 @@ extends TestLib
> }
> }
>
> - // And watchpoint observer to block our process
> + // Watchpoint observer to block our process
> // when it (should) trigger.
> static class WatchObserver
> extends TestObserver
> @@ -268,7 +413,8 @@ extends TestLib
> private final Task task;
> private final long address;
> private final long length;
> -
> + private boolean block = true;
> +
> public WatchObserver(Task task, long address, int length)
> {
> this.task = task;
> @@ -294,8 +440,37 @@ extends TestLib
> + this.length);
>
> hit++;
> + if (this.block) {
> + Manager.eventLoop.requestStop();
> + return Action.BLOCK;
> + }
> + else
> + return Action.CONTINUE;
> + }
> +
> + public void setBlock(boolean block) {
> + this.block = block;
> + }
> + }
> +
> +
> + // Add watchpoint observer to block our process
> + // when it (should) trigger. This is a test case
> + // observer that should never fire. Used to test if
> + // a watchpoint is really deleted.
> + static class FailingWatchObserver
> + extends TestObserver
> + implements TaskObserver.Watch
> + {
> +
> +
> + public Action updateHit(Task task, long address, int length) {
> + fine.log("Hit watchpoint, addess ", address);
> + hit++;
> Manager.eventLoop.requestStop();
> - return Action.BLOCK;
> + fail(task + " hit watchpoint at 0x"+Long.toHexString(address)+
> + " but should not as the watchpoint was deleted");
> + return null; // not reached
> }
> }
>
>
>
> hooks/post-receive
> --
> frysk system monitor/debugger
>
^ permalink raw reply [flat|nested] only message in thread