Query clone: add a QueryThreadLocal and test (#34)

Author: greenrobot-team

objectbox-java/src/main/java/io/objectbox/query/QueryThreadLocal.java

@@ -0,0 +1,22 @@
+package io.objectbox.query;
+
+/**
+ * A {@link ThreadLocal} that, given an original {@link Query} object,
+ * returns a {@link Query#copy() copy}, for each thread.
+ */
+public class QueryThreadLocal<T> extends ThreadLocal<Query<T>> {
+
+    private final Query<T> original;
+
+    /**
+     * See {@link QueryThreadLocal}.
+     */
+    public QueryThreadLocal(Query<T> original) {
+        this.original = original;
+    }
+
+    @Override
+    protected Query<T> initialValue() {
+        return original.copy();
+    }
+}

tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryCopyTest.java

@@ -6,6 +6,9 @@
 
 import java.util.Comparator;
 import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
 
 import static org.junit.Assert.*;
 
@@ -79,4 +82,35 @@ private void assertTestEntityEquals(TestEntity expected, TestEntity actual) {
         assertEquals(expected.getId(), actual.getId());
         assertEquals(expected.getSimpleString(), actual.getSimpleString());
     }
+
+    @Test
+    public void queryThreadLocal() throws InterruptedException {
+        Query<TestEntity> queryOriginal = box.query().build();
+        QueryThreadLocal<TestEntity> threadLocal = new QueryThreadLocal<>(queryOriginal);
+
+        AtomicReference<Query<TestEntity>> queryThreadAtomic = new AtomicReference<>();
+        CountDownLatch latch = new CountDownLatch(1);
+        new Thread(() -> {
+            queryThreadAtomic.set(threadLocal.get());
+            latch.countDown();
+        }).start();
+
+        assertTrue(latch.await(1, TimeUnit.SECONDS));
+
+        Query<TestEntity> queryThread = queryThreadAtomic.get();
+        Query<TestEntity> queryMain = threadLocal.get();
+
+        // Assert that initialValue returns something.
+        assertNotNull(queryThread);
+        assertNotNull(queryMain);
+
+        // Assert that initialValue returns clones.
+        assertNotEquals(queryThread.handle, queryOriginal.handle);
+        assertNotEquals(queryMain.handle, queryOriginal.handle);
+        assertNotEquals(queryThread.handle, queryMain.handle);
+
+        queryOriginal.close();
+        queryMain.close();
+        queryThread.close();
+    }
 }