How do I apply synchronization?

Question

I have UI automation tests. Tests involve three entities -

Data object class - data to be filled in forms. Herein each form on a page could be represented by a different data object.
Helper class - which fills in data in a form on page Test class - which uses data object and helper class to perform test.

Following is the cut down version of test -

public class ParallelDataObject {

    HelperClass helperClass = new HelperClass();
    Data data;

    @BeforeMethod
    public void setTestData() {
        data = new Data();
        helperClass.setData(data);
    }

    @Test
    public void passM1() {
        helperClass.verifyFlag();
    }

    @Test
    public void failM2() {
        data.setFlag(false);
        helperClass.setData(data);
        helperClass.verifyFlag();
    }

    @Test
    public void passM3() {
        helperClass.verifyFlag();
    }

    @Test
    public void failM4() {
        data.setFlag(false);
        helperClass.setData(data);
        helperClass.verifyFlag();
    }
}

class HelperClass {
    Data data;  

    public void setData(Data data) {
        synchronized (data) {
            this.data = data;
        }
    }

    public void verifyFlag() {
        synchronized (data) {
            assert data.getFlag();
        }
    }
}

class Data {
    private boolean flag;

    public Data() {
        flag = true;
    }

    public Data setFlag(boolean flag) {
        synchronized (this) {
            this.flag = flag;
            return this;
        }
    }

    public boolean getFlag() {
        synchronized (this) {
            return flag;
        }
    }

When executing methods in parallel I encountered weird results as data is not thread safe. Then I incorporated synchronize blocks but yet I encounter weird results. I am sure I have messed up how synchronization should be used here in. Any insight?

I did one more exercise. I set up another Test class exactly same as first test class. I removed all synchronization from helper and data class. When I run classes in parallel (instead of methods). Test results are as expected. Why don't I run in to concurrency when I execute classes in parallel, even though they user same helper class and data object?

Answer 1

Consider using ThreadLocal. This way each thread has its own copy of HelperClass. Note that synchronizing separate methods won't give you anything - changes made in one test (in one thread) are visible by other tests

class ParallelDataObject {

    private final ThreadLocal<HelperClass> helperClassThreadLocal = new ThreadLocal<HelperClass>() {

        @Override
        protected HelperClass initialValue() {
            return new HelperClass(new Data());
        }
    };

    private HelperClass helperClass() {
        return helperClassThreadLocal.get();
    }

    @Test
    public void passM1() {
        helperClass().verifyFlag();
    }

    @Test
    public void failM2() {
        helperClass().getData().setFlag(false);
        helperClass().verifyFlag();
    }

}

class HelperClass {

    private final Data data;

    public HelperClass(Data data) {
        this.data = data;
    }

    public Data getData() {
        return data;
    }

    public void verifyFlag() {
        assert data.getFlag();
    }
}

class Data {
    private boolean flag = true;

    public Data setFlag(boolean flag) {
        this.flag = flag;
        return this;
    }

    public boolean getFlag() {
        return flag;
    }
}

Other improvements:

• passM3 and failM4 were superfluous
• since HelperClass requires an instance of Data to work, it should declare it using constructor dependency

• when using:

  synchronized(this)
  

  wrapping whole method body, consider using synchronized keyword in method declaration instead (more readable).

• synchronization is no longer needed with ThreadLocals

Test statelessness

@gpeche makes a good suggestion that tests should be independent. Unfortunately (why, oh why!?) JUnit reuses the same test case class instance (ParallelDataObject in this case) for all test methods execution. This means that assigning any stateful objects to test case class fields is dangerous and must be avoided.

In this particular case the OP would have to create a new instance of HelperClass in each test method (which, in fact, isn't such a bad idea):

class ParallelDataObject {

    @Test
    public void passM1() {
        final HelperClass helperClass = new HelperClass(new Data());

        helperClass.verifyFlag();
    }

    @Test
    public void failM2() {
        final Data data = new Data();
        data.setFlag(false);

        final HelperClass helperClass = new HelperClass(data);

        helperClass.verifyFlag();
    }

}

Answer 2

HelperClass and Data are thread-safe.

The problem is that some of your test methods perform several operations. And sequence of the operations in test method is not atomic as long as it not synchronized.

For example during failM4 execution the state of helperClass might be modified by other thread.

I'd recommend you to not use shared state between test methods because synchronization will nullify the advantages of concurrent tests execution.