コード例 #1
0
  @Test
  public void testIndexDoesNotReturnStaleResultsAfterSplit() {
    String mapName = randomMapName();
    Config config = newConfig(LatestUpdateMapMergePolicy.class.getName(), mapName);
    HazelcastInstance h1 = Hazelcast.newHazelcastInstance(config);
    HazelcastInstance h2 = Hazelcast.newHazelcastInstance(config);

    TestMembershipListener membershipListener = new TestMembershipListener(1);
    h2.getCluster().addMembershipListener(membershipListener);
    TestLifecycleListener lifecycleListener = new TestLifecycleListener(1);
    h2.getLifecycleService().addLifecycleListener(lifecycleListener);

    RealtimeCall call = new RealtimeCall();
    String key = generateKeyOwnedBy(h1);
    call.setId(key);
    call.setClusterUUID(key);

    IMap<PartitionAwareKey<String, String>, RealtimeCall> map1 = h1.getMap(mapName);
    IMap<PartitionAwareKey<String, String>, RealtimeCall> map2 = h2.getMap(mapName);

    map1.put(call.getAffinityKey(), call);

    sleepMillis(1);
    assertNotNull("entry should be in map2 before split", map2.get(call.getAffinityKey()));

    closeConnectionBetween(h1, h2);

    assertOpenEventually(membershipListener.latch);
    assertClusterSizeEventually(1, h1);
    assertClusterSizeEventually(1, h2);

    map1 = h1.getMap(mapName);
    map1.remove(call.getAffinityKey());

    sleepMillis(1);
    map2 = h2.getMap(mapName);
    assertNotNull("entry should be in map2 in split", map2.get(call.getAffinityKey()));

    assertOpenEventually(lifecycleListener.latch);
    assertClusterSizeEventually(2, h1);
    assertClusterSizeEventually(2, h2);

    map1 = h1.getMap(mapName);
    assertNotNull("entry should be in map1", map1.get(call.getAffinityKey()));

    map1.remove(call.getAffinityKey());
    assertNull("map1 should be null", map1.get(call.getAffinityKey()));
    assertNull("map2 should be null", map2.get(call.getAffinityKey()));

    for (int i = 0; i < 100; i++) {
      Collection<RealtimeCall> calls = map1.values(Predicates.equal("id", call.getId()));
      System.out.println("Map 1 query by uuid: " + calls.size());
      assert calls.size() == 0;
      calls = map2.values(Predicates.equal("id", call.getId()));
      System.out.println("Map 2 query by uuid: " + calls.size());
      assert calls.size() == 0;
      sleepMillis(5);
    }
  }
コード例 #2
0
 @Test
 public void null_collection_length_reduced() {
   execute(
       Input.of(HUNT_NULL_LIMB),
       Query.of(Predicates.equal("limbs_[any].fingers_.length", 1), mv),
       Expected.empty());
 }
コード例 #3
0
 @Test
 public void null_collection_length_compared_to_null() {
   execute(
       Input.of(HUNT_NULL_LIMB),
       Query.of(Predicates.equal("limbs_[0].fingers_.length", null), mv),
       Expected.of(HUNT_NULL_LIMB));
 }
コード例 #4
0
 @Test
 public void length_property_atLeaf() {
   execute(
       Input.of(BOND, KRUEGER),
       Query.of(Predicates.equal("limbs_[0].tattoos_.length", 1), mv),
       Expected.of(KRUEGER));
 }
コード例 #5
0
 @Test
 public void length_property() {
   execute(
       Input.of(BOND, KRUEGER),
       Query.of(Predicates.equal("limbs_.length", 2), mv),
       Expected.of(BOND, KRUEGER));
 }
コード例 #6
0
 @Test
 public void null_collection_length_atLeaf_reduced_compared_to_null() {
   execute(
       Input.of(HUNT_NULL_TATTOOS),
       Query.of(Predicates.equal("limbs_[any].tattoos_.length", null), mv),
       Expected.of(HUNT_NULL_TATTOOS));
 }
コード例 #7
0
 @Test
 public void null_collection_length_atLeaf() {
   execute(
       Input.of(HUNT_NULL_TATTOOS),
       Query.of(Predicates.equal("limbs_[0].tattoos_.length", 1), mv),
       Expected.empty());
 }
コード例 #8
0
    @Override
    protected void timeStep(Operation operation) throws Exception {
      int key = getRandomKey();

      switch (operation) {
        case PUT:
          SillySequence sillySequence = new SillySequence(key, nestedValuesCount);
          map.put(key, sillySequence);
          break;
        case QUERY:
          int index = key % nestedValuesCount;
          String query = format("payloadFromExtractor[%d]", index);
          Predicate predicate = Predicates.equal(query, key);
          queryProbe.started();
          Collection<SillySequence> result = null;
          try {
            result = map.values(predicate);
          } finally {
            queryProbe.done();
          }
          THROTTLING_LOGGER.info(
              format(
                  "Query 'payloadFromExtractor[%d]= %d' returned %d results.",
                  index, key, result.size()));
          for (SillySequence resultSillySequence : result) {
            assertValidSequence(key, resultSillySequence);
          }
          break;
        default:
          throw new UnsupportedOperationException("Unsupported operation: " + operation);
      }
    }
コード例 #9
0
  @Test
  public void runFullQuery() throws Exception {
    Predicate predicate = Predicates.equal("this", value);
    QueryResult result = queryRunner.run(map.getName(), predicate, ENTRY);

    assertEquals(1, result.getRows().size());
    assertEquals(map.get(key), toObject(result.getRows().iterator().next().getValue()));
  }
コード例 #10
0
  @Test
  public void runPartitionScanQueryOnSinglePartition() {
    Predicate predicate = Predicates.equal("this", value);
    QueryResult result =
        queryRunner.runUsingPartitionScanOnSinglePartition(
            map.getName(), predicate, partitionId, ENTRY);

    assertEquals(1, result.getRows().size());
    assertEquals(map.get(key), toObject(result.getRows().iterator().next().getValue()));
  }
コード例 #11
0
    private void pagingPredicate() {
      double maxSal = getRandom().nextDouble() * Employee.MAX_SALARY;

      Predicate predicate = Predicates.lessThan("salary", maxSal);
      PagingPredicate pagingPredicate = new PagingPredicate(predicate, pageSize);

      Collection<Employee> employees;
      do {
        employees = map.values(pagingPredicate);
        for (Employee emp : employees) {
          assertTrue(
              basename + ": " + emp + " not matching " + predicate, emp.getSalary() < maxSal);
        }
        pagingPredicate.nextPage();
      } while (!employees.isEmpty());

      operationCounter.pagePredicateCount++;
    }