Can we test an object that needs initialization and teardown?

[Adam Retter]

Hi there,

I am trying to use JCStress to stress test the concurrent actions of a
small embedded database engine. My idea was to write tests that
concurrently modify the database, and then use the arbiter to read
back the result and report whether it is as expected.

I think to make things simple, let's not worry about the database
itself too much. It runs as a library in the same JVM. We can pretend
that it is just a dictionary of key/value mappings.

Each @JCStressTest test should have its own instance of the database.
I have tried to follow the example of other tests by placing an
instance of this in the @State class.

I basically need something similar to JUnit's @Before and @After to
start and stop the database.

I figured that to start the database instance I could do this in the
constructor of the state class. To stop the database after the actors
have run, I figured that I could do this within a `finally` block at
the end of the arbiter method.

I just want to check whether this approach is sane? ...or if I am
doing something totally nuts here?

My code looks something like:


public class DBTest {

    @State
    public static class S {
        public final Database db = new Database();

        public S() {
            try {
                // startup the database
                db.start();

                // create initial entry
                db.put("key1", "value1");

            } catch (DatabaseException e) {
                throw new RuntimeException(e);
            }
        }

        public void put(final String key, final String value) {
            try {
                db.put(key, value);
            } catch (DatabaseException e) {
                throw new RuntimeException(e);
            }
        }

        public String get(final String key) {
            try {
                return db.get(key);
            } catch (DatabaseException e) {
                throw new RuntimeException(e);
            }
        }

        public void stopDb() {
            try {
                db.stop();
            } catch (DatabaseException e) {
                throw new RuntimeException(e);
            }
        }
    }

    @JCStressTest
    @Outcome(id = "a1", expect = Expect.ACCEPTABLE, desc = "key1 was
set by actor1")
    @Outcome(id = "a2", expect = Expect.ACCEPTABLE, desc = "key2 was
set by actor2")
    public static class put_put {

        @Actor
        public void actor1(final S s) {
            s.put("key1", "a1");
        }

        @Actor
        public void actor2(final S s) {
            s.put("key1", "a2");
        }

        @Arbiter
        public void arbiter(final S s, final L_Result r) {
            try {
                r.r1 = s.get("key1");
            } finally {
                // shutdown the database
                s.stopDb();
            }
        }
    }
}




-- 
Adam Retter

skype: adam.retter
tweet: adamretter
http://www.adamretter.org.uk