@Test public void testPutAndGet() { TestEntity entity = new TestEntity(); entity.setSimpleInt(1977); entity.setSimpleBoolean(true); entity.setSimpleByte((byte) 42); byte[] bytes = {77, 78}; entity.setSimpleByteArray(bytes); entity.setSimpleDouble(3.141); entity.setSimpleFloat(3.14f); entity.setSimpleLong(789437444354L); entity.setSimpleShort((short) 233); entity.setSimpleString("foo"); long key = box.put(entity); TestEntity entityRead = box.get(key); assertNotNull(entityRead); assertTrue(entityRead.noArgsConstructorCalled); assertEquals(1977, entityRead.getSimpleInt()); assertTrue(entityRead.getSimpleBoolean()); assertEquals(42, entityRead.getSimpleByte()); assertEquals(233, entityRead.getSimpleShort()); assertEquals(789437444354L, entityRead.getSimpleLong()); assertEquals(3.14f, entityRead.getSimpleFloat(), 0.000001f); assertEquals(3.141f, entityRead.getSimpleDouble(), 0.000001); assertTrue(Arrays.equals(bytes, entityRead.getSimpleByteArray())); assertEquals("foo", entityRead.getSimpleString()); }
@Test public void testPutAndGet() { TestEntity entity = new TestEntity(); entity.setSimpleInt(1977); long key = box.put(entity); assertTrue(key != 0); assertEquals(key, entity.getId()); TestEntity entityRead = box.get(key); assertNotNull(entityRead); assertEquals(1977, entityRead.getSimpleInt()); }
protected TestEntity createTestEntity(@Nullable String simpleString, int nr) { TestEntity entity = new TestEntity(); entity.setSimpleString(simpleString); entity.setSimpleInt(nr); entity.setSimpleByte((byte) (10 + nr)); entity.setSimpleBoolean(nr % 2 == 0); entity.setSimpleShort((short) (100 + nr)); entity.setSimpleLong(1000 + nr); entity.setSimpleFloat(200 + nr / 10f); entity.setSimpleDouble(2000 + nr / 100f); entity.setSimpleByteArray(new byte[]{1, 2, (byte) nr}); return entity; }
private TestEntity putEntity(Cursor<TestEntity> cursor, String text, int number) { TestEntity entity = new TestEntity(); entity.setSimpleString(text); entity.setSimpleInt(number); cursor.put(entity); return entity; }
@Override public Long call() throws Exception { TestEntity entity = new TestEntity(); entity.setId(-1); getTestEntityBox().put(entity); return null; } };
@Test public void testPutGetUpdateGetRemove() { // create an entity TestEntity entity = new TestEntity(); entity.setSimpleInt(1977); entity.setSimpleLong(54321); String value1 = "lulu321"; entity.setSimpleString(value1); long key = box.put(entity); // get it TestEntity entityRead = box.get(key); assertNotNull(entityRead); assertEquals(1977, entityRead.getSimpleInt()); assertEquals(54321, entityRead.getSimpleLong()); assertEquals(value1, entityRead.getSimpleString()); // put with changed values String value2 = "lala123"; entityRead.setSimpleString(value2); entityRead.setSimpleLong(12345); box.put(entityRead); // get the changed entity entityRead = box.get(key); assertNotNull(entityRead); assertEquals(1977, entityRead.getSimpleInt()); assertEquals(12345, entityRead.getSimpleLong()); assertEquals(value2, entityRead.getSimpleString()); // and remove it box.remove(key); assertNull(box.get(key)); }
@Override public Long call() throws Exception { assertNotSame(mainTestThread, Thread.currentThread()); for (int i = 0; i < countEntities; i++) { TestEntity entity = new TestEntity(); final int value = number.incrementAndGet(); entity.setSimpleInt(value); long key = box.put(entity); TestEntity read = box.get(key); assertEquals(value, read.getSimpleInt()); } return box.count(); } };
@Test public void testPutSameIndexValue() { TestEntity entity = new TestEntity(); String value = "lulu321"; entity.setSimpleString(value); Transaction transaction = store.beginTx(); TestEntity read; try { Cursor<TestEntity> cursor = transaction.createCursor(TestEntity.class); long key = cursor.put(entity); // And again entity.setSimpleInt(1977); cursor.put(entity); assertEquals(key, cursor.lookupKeyUsingIndex(9, value)); read = cursor.get(key); cursor.close(); } finally { transaction.close(); } assertEquals(1977, read.getSimpleInt()); assertEquals(value, read.getSimpleString()); }
@Override public void run() { box.put(new TestEntity()); counts[0] = box.count(); try { store.callInTx(new Callable<Void>() { @Override public Void call() { store.runInTx(new Runnable() { @Override public void run() { box.put(new TestEntity()); counts[1] = box.count(); } }); box.put(new TestEntity()); counts[2] = box.count(); return null; } }); } catch (Exception e) { throw new RuntimeException(e); } } });
@Test public void testSumDoubleOfFloats() { TestEntity entity = new TestEntity(); entity.setSimpleFloat(0); TestEntity entity2 = new TestEntity(); entity2.setSimpleFloat(-2.05f); box.put(entity, entity2); double sum = box.query().build().property(simpleFloat).sumDouble(); assertEquals(-2.05, sum, 0.0001); }
@Test public void testOr() { putTestEntitiesScalars(); Query<TestEntity> query = box.query().equal(simpleInt, 2007).or().equal(simpleLong, 3002).build(); List<TestEntity> entities = query.find(); assertEquals(2, entities.size()); assertEquals(3002, entities.get(0).getSimpleLong()); assertEquals(2007, entities.get(1).getSimpleInt()); }
@Test public void testPutAndGetTwoEntities() { store.close(); store.deleteAllFiles(); store = createBoxStoreBuilderWithTwoEntities(false).build(); box = store.boxFor(TestEntity.class); long key = putTestEntity(null, 1977).getId(); TestEntity entityRead = box.get(key); assertEquals(1977, entityRead.getSimpleInt()); Box<TestEntityMinimal> box2 = store.boxFor(TestEntityMinimal.class); TestEntityMinimal entity2 = new TestEntityMinimal(); entity2.setText("foo"); long key2 = box2.put(entity2); TestEntityMinimal entity2Read = box2.get(key2); assertEquals("foo", entity2Read.getText()); }
@Test public void testByteArrayLess() { putTestEntitiesScalars(); byte[] value = {1, 2, (byte) 2005}; Query<TestEntity> query = box.query().less(simpleByteArray, value).build(); List<TestEntity> results = query.find(); assertEquals(5, results.size()); // Java does not have compareTo for arrays, so just make sure its not equal to the value for (TestEntity result : results) { assertFalse(Arrays.equals(value, result.getSimpleByteArray())); } }
@Test public void testOffsetLimit() { putTestEntitiesScalars(); Query<TestEntity> query = box.query().greater(simpleInt, 2002).less(simpleShort, 2108).build(); assertEquals(5, query.count()); assertEquals(4, query.find(1, 0).size()); assertEquals(1, query.find(4, 0).size()); assertEquals(2, query.find(0, 2).size()); List<TestEntity> list = query.find(1, 2); assertEquals(2, list.size()); assertEquals(2004, list.get(0).getSimpleInt()); assertEquals(2005, list.get(1).getSimpleInt()); }
TestEntity entity = new TestEntity(); entity.setSimpleInt(1977); entity.setSimpleLong(54321); String value1 = "lulu321"; entity.setSimpleString(value1); Transaction transaction = store.beginTx(); Cursor<TestEntity> cursor = transaction.createCursor(TestEntity.class); assertEquals(1977, entityRead.getSimpleInt()); assertEquals(54321, entityRead.getSimpleLong()); assertEquals(value1, entityRead.getSimpleString()); entityRead.setSimpleString(value2); entityRead.setSimpleLong(12345); assertEquals(1977, entityRead.getSimpleInt()); assertEquals(12345, entityRead.getSimpleLong()); assertEquals(value2, entityRead.getSimpleString());
@Test public void testPutManyAndGetAll() { List<TestEntity> entities = new ArrayList<>(); for (int i = 0; i < 10; i++) { TestEntity entity = new TestEntity(); entity.setSimpleInt(2000 + i); entities.add(entity); } box.put(entities); assertEquals(entities.size(), box.count()); List<TestEntity> entitiesRead = box.getAll(); assertEquals(entities.size(), entitiesRead.size()); for (int i = 0; i < entities.size(); i++) { assertEquals(2000 + i, entitiesRead.get(i).getSimpleInt()); } }
@Test public void testGetIds() { List<TestEntity> entities = putTestEntities(5); List<Long> ids = new ArrayList<>(); ids.add(entities.get(1).getId()); ids.add(entities.get(3).getId()); List<TestEntity> readEntities = box.get(ids); assertEquals(2, readEntities.size()); assertEquals((long) ids.get(0), readEntities.get(0).getId()); assertEquals((long) ids.get(1), readEntities.get(1).getId()); Map<Long, TestEntity> map = box.getMap(ids); assertEquals(2, map.size()); assertEquals((long) ids.get(0), map.get(ids.get(0)).getId()); assertEquals((long) ids.get(1), map.get(ids.get(1)).getId()); }
@Test(expected = IllegalArgumentException.class) public void testPutEntityWithInvalidId() { TestEntity entity = new TestEntity(); entity.setId(777); Transaction transaction = store.beginTx(); Cursor<TestEntity> cursor = transaction.createCursor(TestEntity.class); try { cursor.put(entity); } finally { cursor.close(); transaction.close(); } }
@Override public void run() { box.put(new TestEntity()); counts[0] = box.count(); box.put(new TestEntity()); counts[1] = box.count(); } });