In think it over I decided to post a high level summary of the
problem:

1. The framework has it's own standalone GUI see
http://www.flosoft-systems.com/thisTest_screens.php for screen shots

2. When clicking on "run tests" any recompiling done since the last
test run (either from with in the GUI or restarting the app) needs to
be honored

3. I currently solved item 2 in a very adhoc and bug prone way:
    a. Have a custom class loader (see other treads) since the system
class loader will not honor
       updated .class files
    b. A side effect of using a custom class loader is you can not
directly cast to an instance created using the system class loader.
For example:

public class Main
{
       public static void main(String[] args)
               throws Throwable
       {
               ClassLoader loader=new MyClassLoader();
               Class klass=loader.loadClass("MyClass");

               MyClass m=(MyClass) klass.newInstance();
       }
}

Produces:
Exception in thread "main" java.lang.ClassCastException: MyClass
cannot be cast to MyClass
       at Main.main(Main.java:11)

Here is the support code:

import java.io.*;
import java.lang.reflect.*;

public class MyClassLoader extends ClassLoader
{
       public Class loadClass(String name)
       {
               try {
                       if(name.startsWith("java."))
                               return super.loadClass(name);

                       FileInputStream fis=new FileInputStream(name
+".class");
                       byte[] b=new byte[fis.available()];

                       fis.read(b);
                       fis.close();

                       return defineClass(name,b,0,b.length);
               } catch(Throwable e) {
                       e.printStackTrace();
               }

               return null;
        }
}

public class MyClass
{
       public MyClass()
       {
               ack=new Integer(0);
       }

       public Integer getAck()
       {
               return ack;
       }

       private int foo;
       private Integer ack;
}

If you want more detail and the threads proving the correctness of the
code see:

http://groups.google.com/group/comp.lang.java.programmer/browse_thread/thread/5c
d333290dc92e74/0169c9ea83253940#0169c9ea83253940

http://groups.google.com/group/comp.lang.java.programmer/browse_thread/thread/9f
84cb0f0a2ab367/f28ba3e0de4cc60f#f28ba3e0de4cc60f

One solution I have found to this problem (which I do in a adhoc and
bug baity way in the production code) is to create a second instance
of the class using the system class loader then copy the fields over
that way any getter/setter operates on stuff created by the system
class loader and not the custom class loader (this is fine because by
definition Unit tests only test the top level containing class).
Recently I have come up with the following experimental code to do
this is a more systematic way:

import java.lang.reflect.*;

public class Main
{
    public static void main(String[] args)
        throws Throwable
    {
        ClassLoader loader=new MyClassLoader();
        Class klass=loader.loadClass("MyClass");

        MyClass m=(MyClass) rebrand(MyClass.class,klass.newInstance());

        // cast to make sure rebrand works
        System.out.println((Integer) m.getAck());
    }

    public static Object rebrand(Class brand,Object obj)
        throws Throwable
    {
        ClassLoader loader=ClassLoader.getSystemClassLoader();
        Class klass=loader.loadClass(brand.getCanonicalName());
        Object real=klass.newInstance();

        for(Field f:real.getClass().getDeclaredFields()) {
            if(f.getType().isPrimitive())
                continue;

            Field oldField=obj.getClass().getDeclaredField(f.getName());
            boolean fVis=f.isAccessible();
            boolean oVis=oldField.isAccessible();

            try {
                f.setAccessible(true);
                oldField.setAccessible(true);
            } catch(Throwable e) {
                // if for some reason we can't mod the accessibility skip it
                continue;
            }

            f.set(real,oldField.get(obj));

            f.setAccessible(true);
            oldField.setAccessible(true);
        }

        return real;
    }
}

The only problem remaining is to call rebrand when ever the class
under test returns a field (see the println for an example).

This is where the proxy comes in I basically wrap Proxy.invoke(....)
around all method calls and if the return type needs to be rebranded
(made by the custom classloader) it does so.  This is safe because it
is conceptually illegal for a unit test to call any methods in the
returned value except to check it's values.

I still can not really see any reason why not to use AspectJ.

Yes - you need to distribute the aspectrt.jar, but most Java apps
require some jars.

Yes - developers will need the AspectJ tools, but they also need
an editor, a Java compiler etc..

Arne