Exemple #1
0
  @Test
  public void testMarshall_Embedded() {
    RootEntity rootObject = new RootEntity(); // one entity
    ChildEntity childObject = new ChildEntity("Test City");
    ChildEntity embeddedObject = new ChildEntity("Old Test City");
    embeddedObject.setId(1L);
    embeddedObject.setType("EmbeddedType");
    rootObject.setId("TestUser");
    rootObject.setCount(25);
    childObject.setParent(rootObject);
    rootObject.setNewChildEntity(childObject); // one entity
    rootObject.setEmbeddedEntity(embeddedObject); // not included, @Embedded

    IdentityHashMap<Object, Entity> stack = testMarshaller.marshall(null, rootObject);

    Entity rootObjectEntity = stack.get(rootObject);
    Entity childObjectEntity = stack.get(childObject);

    EmbeddedEntity ee = (EmbeddedEntity) rootObjectEntity.getProperty("embeddedEntity");
    Key childKey = (Key) rootObjectEntity.getProperty("newChildEntity");
    Key parentKey = childKey.getParent();

    assertEquals(2, stack.size());
    assertNotNull(parentKey);
    assertEquals(EmbeddedEntity.class, ee.getClass());
    assertTrue(childKey instanceof Key);
    assertEquals(rootObjectEntity.getKey().getId(), parentKey.getId());
    assertEquals(rootObjectEntity.getKey().getName(), parentKey.getName());

    assertEquals(1L, ee.getProperties().get("id"));
    assertEquals("EmbeddedType", ee.getProperties().get("type"));
  }
  @Test
  public void recycleEntity() {
    PooledEngine engine = new PooledEngine();

    int numEntities = 200;
    Array<Entity> entities = new Array<Entity>();

    for (int i = 0; i < numEntities; ++i) {
      Entity entity = engine.createEntity();
      assertEquals(0, entity.flags);
      engine.addEntity(entity);
      entities.add(entity);
      entity.flags = 1;
    }

    for (Entity entity : entities) {
      engine.removeEntity(entity);
      assertEquals(0, entity.flags);
    }

    for (int i = 0; i < numEntities; ++i) {
      Entity entity = engine.createEntity();
      assertEquals(0, entity.flags);
      engine.addEntity(entity);
      entities.add(entity);
    }
  }
  @Test
  public void recycleComponent() {
    int maxEntities = 10;
    int maxComponents = 10;
    PooledEngine engine = new PooledEngine(maxEntities, maxEntities, maxComponents, maxComponents);

    for (int i = 0; i < maxComponents; ++i) {
      Entity e = engine.createEntity();
      PooledComponentSpy c = engine.createComponent(PooledComponentSpy.class);

      assertEquals(false, c.recycled);

      e.add(c);

      engine.addEntity(e);
    }

    engine.removeAllEntities();

    for (int i = 0; i < maxComponents; ++i) {
      Entity e = engine.createEntity();
      PooledComponentSpy c = engine.createComponent(PooledComponentSpy.class);

      assertEquals(true, c.recycled);

      e.add(c);
    }

    engine.removeAllEntities();
  }
Exemple #4
0
  @Test
  public void componentListener() {
    EntityListenerMock addedListener = new EntityListenerMock();
    EntityListenerMock removedListener = new EntityListenerMock();

    Entity entity = new Entity();
    entity.componentAdded.add(addedListener);
    entity.componentRemoved.add(removedListener);

    assertEquals(0, addedListener.counter);
    assertEquals(0, removedListener.counter);

    entity.add(new ComponentA());

    assertEquals(1, addedListener.counter);
    assertEquals(0, removedListener.counter);

    entity.remove(ComponentA.class);

    assertEquals(1, addedListener.counter);
    assertEquals(1, removedListener.counter);

    entity.add(new ComponentB());

    assertEquals(2, addedListener.counter);

    entity.remove(ComponentB.class);

    assertEquals(2, removedListener.counter);
  }
Exemple #5
0
  @Test
  public void addAndReturnComponent() {
    Entity entity = new Entity();
    ComponentA componentA = new ComponentA();
    ComponentB componentB = new ComponentB();

    assertEquals(componentA, entity.addAndReturn(componentA));
    assertEquals(componentB, entity.addAndReturn(componentB));

    assertEquals(2, entity.getComponents().size());
  }
Exemple #6
0
  @Test
  public void noComponents() {
    Entity entity = new Entity();

    assertEquals(0, entity.getComponents().size());
    assertTrue(entity.getComponentBits().isEmpty());
    assertNull(am.get(entity));
    assertNull(bm.get(entity));
    assertFalse(am.has(entity));
    assertFalse(bm.has(entity));
  }
Exemple #7
0
 @Test
 public void testMarshall_Child_first() {
   ChildEntity child = new ChildEntity();
   RootEntity parent = new RootEntity();
   parent.setId("ParentKey");
   child.setParent(parent);
   IdentityHashMap<Object, Entity> stack = testMarshaller.marshall(null, child);
   Entity childEntity = stack.get(child);
   assertNotNull(stack);
   assertEquals(2, stack.size());
   assertEquals("ParentKey", childEntity.getParent().getName());
 }
Exemple #8
0
  @Test
  public void createTransactionReturnsOk() {
    // create "cars" transaction
    Response response =
        client
            .path("/transactionservice/transaction/10")
            .request()
            .put(Entity.json(new Transaction("cars", new BigDecimal(5000), 0l)));

    assertEquals(200, response.getStatus());
    assertEquals(
        TransactionService.OperationResult.OK,
        response.readEntity(TransactionService.OperationResult.class));

    // create "shopping" transaction
    response =
        client
            .path("/transactionservice/transaction/11")
            .request()
            .put(Entity.json(new Transaction("shopping", new BigDecimal(10000), 10l)));

    assertEquals(200, response.getStatus());
    assertEquals(
        TransactionService.OperationResult.OK,
        response.readEntity(TransactionService.OperationResult.class));

    // get "cars" transactions
    response = client.path("/transactionservice/type/cars").request().get();

    assertEquals(200, response.getStatus());
    @SuppressWarnings("unchecked")
    List<Integer> ids = response.readEntity(List.class);
    assertEquals(1, ids.size());
    assertEquals(10, ids.get(0).intValue());

    // get "sum" for transaction 10
    response = client.path("/transactionservice/sum/10").request().get();

    assertEquals(200, response.getStatus());
    AggregatorService.Sum sum = response.readEntity(AggregatorService.Sum.class);
    assertEquals(15000, sum.getSum().intValue());

    // get "sum" for transaction 11
    response = client.path("/transactionservice/sum/11").request().get();

    assertEquals(200, response.getStatus());
    sum = response.readEntity(AggregatorService.Sum.class);
    assertEquals(10000, sum.getSum().intValue());
  }
  /** @see DATAMONGO-468 */
  @Test
  public void rendersUpdateOfDbRefPropertyWithDomainObjectCorrectly() {

    Entity entity = new Entity();
    entity.id = "5";

    Update update = new Update().set("dbRefProperty", entity);
    DBObject mappedObject =
        mapper.getMappedObject(
            update.getUpdateObject(),
            context.getPersistentEntity(DocumentWithDBRefCollection.class));

    DBObject setClause = getAsDBObject(mappedObject, "$set");
    assertThat(setClause.get("dbRefProperty"), is((Object) new DBRef(null, "entity", entity.id)));
  }
Exemple #10
0
  @Test
  public void test_Marshall_List() {
    Post post = new Post();
    post.setTags(list("tag1", "tag2", "tag3"));

    IdentityHashMap<Object, Entity> stack = testMarshaller.marshall(null, post);
    Entity e = stack.get(post);
    Object tags = e.getProperty("tags");

    assertNotNull(e);
    assertTrue(tags instanceof List);
    assertEquals("tag1", ((List) tags).get(0));
    assertEquals("tag2", ((List) tags).get(1));
    assertEquals("tag3", ((List) tags).get(2));
  }
Exemple #11
0
  @Test
  public void addSameComponent() {
    Entity entity = new Entity();

    ComponentA a1 = new ComponentA();
    ComponentA a2 = new ComponentA();

    entity.add(a1);
    entity.add(a2);

    assertEquals(1, entity.getComponents().size());
    assertTrue(am.has(entity));
    assertNotEquals(a1, am.get(entity));
    assertEquals(a2, am.get(entity));
  }
  /** @see DATAMONGO-404 */
  @Test
  public void createsDbRefForEntityOnPulls() {

    Entity entity = new Entity();
    entity.id = "5";

    Update update = new Update().pull("dbRefAnnotatedList", entity);
    DBObject mappedObject =
        mapper.getMappedObject(
            update.getUpdateObject(),
            context.getPersistentEntity(DocumentWithDBRefCollection.class));

    DBObject pullClause = getAsDBObject(mappedObject, "$pull");
    assertThat(
        pullClause.get("dbRefAnnotatedList"), is((Object) new DBRef(null, "entity", entity.id)));
  }
 @Override
 public void update(float deltaTime) {
   Entity entity;
   PooledEngine engine = (PooledEngine) getEngine();
   for (int i = 0; i < 10; i++) {
     entity = engine.createEntity();
     assertEquals(0, entity.flags);
     entity.flags = 1;
     entity.add(engine.createComponent(PositionComponent.class));
     engine.addEntity(entity);
   }
   for (int i = 0; i < entities.size(); ++i) {
     entity = entities.get(i);
     engine.removeEntity(entity);
     engine.removeEntity(entity);
   }
 }
Exemple #14
0
  @Test
  public void testMarshall_JSONEntity() {
    JSONEntity json = new JSONEntity();

    json.setKind("MyDocument");
    json.setId("abcdef12345");
    json.getFields().put("age", 28);
    json.getFields().put("name", "Name");

    IdentityHashMap<Object, Entity> stack = testMarshaller.marshall(null, json);
    Entity e = stack.get(json);

    assertNotNull(stack);
    assertTrue(!stack.isEmpty());

    assertEquals("MyDocument", e.getKind());
  }
Exemple #15
0
  @Test
  public void getComponentByClass() {
    ComponentA compA = new ComponentA();
    ComponentB compB = new ComponentB();

    Entity entity = new Entity();
    entity.add(compA).add(compB);

    ComponentA retA = entity.getComponent(ComponentA.class);
    ComponentB retB = entity.getComponent(ComponentB.class);

    assertNotNull(retA);
    assertNotNull(retB);

    assertTrue(retA == compA);
    assertTrue(retB == compB);
  }
Exemple #16
0
  @Test
  public void addAndRemoveComponent() {
    Entity entity = new Entity();

    entity.add(new ComponentA());

    assertEquals(1, entity.getComponents().size());

    Bits componentBits = entity.getComponentBits();
    int componentAIndex = ComponentType.getIndexFor(ComponentA.class);

    for (int i = 0; i < componentBits.length(); ++i) {
      assertEquals(i == componentAIndex, componentBits.get(i));
    }

    assertNotNull(am.get(entity));
    assertNull(bm.get(entity));
    assertTrue(am.has(entity));
    assertFalse(bm.has(entity));

    entity.remove(ComponentA.class);

    assertEquals(0, entity.getComponents().size());

    for (int i = 0; i < componentBits.length(); ++i) {
      assertFalse(componentBits.get(i));
    }

    assertNull(am.get(entity));
    assertNull(bm.get(entity));
    assertFalse(am.has(entity));
    assertFalse(bm.has(entity));
  }
  @Test
  public void entityRemovalListenerOrder() {
    PooledEngine engine = new PooledEngine();

    CombinedSystem combinedSystem = new CombinedSystem();

    engine.addSystem(combinedSystem);
    engine.addEntityListener(Family.all(PositionComponent.class).get(), new MyPositionListener());

    for (int i = 0; i < 10; i++) {
      Entity entity = engine.createEntity();
      entity.add(engine.createComponent(PositionComponent.class));
      engine.addEntity(entity);
    }

    assertEquals(10, combinedSystem.allEntities.size());

    for (int i = 0; i < 10; i++) {
      engine.update(deltaTime);
    }

    engine.removeAllEntities();
  }
Exemple #18
0
  @Test
  public void testMarshall_Child() {
    RootEntity rootObject = new RootEntity(); // one entity
    ChildEntity childObject = new ChildEntity("Test City");
    rootObject.setId("TestUser");
    rootObject.setCount(25);
    childObject.setParent(rootObject);
    rootObject.setNewChildEntity(childObject); // one entity

    IdentityHashMap<Object, Entity> stack = testMarshaller.marshall(null, rootObject);

    Entity rootObjectEntity = stack.get(rootObject);
    Entity childObjectEntity = stack.get(childObject);

    Key childKey = (Key) rootObjectEntity.getProperty("newChildEntity");
    Key parentKey = childKey.getParent();

    assertEquals(2, stack.size());
    assertNotNull(parentKey);
    assertTrue(childKey instanceof Key);
    assertEquals(rootObjectEntity.getKey().getId(), parentKey.getId());
    assertEquals(rootObjectEntity.getKey().getName(), parentKey.getName());
  }
Exemple #19
0
  @Test
  public void test() {
    Entity parent = new Entity("Parent");
    // set parent properties...
    List<EmbeddedEntity> children = new ArrayList<EmbeddedEntity>();
    for (int i = 0; i < 5; i++) {
      EmbeddedEntity child = new EmbeddedEntity();
      // set child properties...
      children.add(child);
    }
    parent.setUnindexedProperty("children", children);
    parent.setUnindexedProperty("children2", list("tag1", "tag2", "tag3"));

    DatastoreServiceFactory.getDatastoreService().put(parent);

    try {
      Entity e = DatastoreServiceFactory.getDatastoreService().get(parent.getKey());
      e.getKey();
      Object children2 = e.getProperty("children2");
      assertTrue(children2 instanceof List);
    } catch (EntityNotFoundException e1) {
      e1.printStackTrace();
    }
  }
Exemple #20
0
 @Test
 public void testGetter2FieldName() {
   assertEquals("THIS_IS_A_FILED", Entity.getter2FieldName("getThisIsAFiled"));
 }