Code cleanup.

Jean-Noel Rouvignac

02.20.2014 c3bc48df326c110e5a2f9d07874190fbd83d2610

 opends/tests/unit-tests-testng/src/server/org/opends/server/replication/server/AssuredReplicationServerTest.java

@@ -452,8 +452,6 @@

    private final CSNGenerator gen;

    /** False if a received update had assured parameters not as expected */
    private boolean everyUpdatesAreOk = true;
    /** Number of received updates */
    private int nReceivedUpdates = 0;
    private int nWrongReceivedUpdates = 0;
@@ -482,21 +480,6 @@
      gen = new CSNGenerator(config.getServerId(), 0L);
    }

    private boolean receivedUpdatesOk()
    {
      return everyUpdatesAreOk;
    }

    public int getReceivedUpdates()
    {
      return nReceivedUpdates;
    }

    public int getWrongReceivedUpdates()
    {
      return nWrongReceivedUpdates;
    }

    @Override
    public long countEntries() throws DirectoryException
    {
@@ -581,7 +564,6 @@
      }
      else
      {
        everyUpdatesAreOk = false;
        nWrongReceivedUpdates++;
      }
    }
@@ -600,6 +582,18 @@
      publish(delMsg);
      waitForAckIfAssuredEnabled(delMsg);
    }

    private void assertReceivedWrongUpdates(int expectedNbUpdates,
        int expectedNbWrongUpdates)
    {
      assertEquals(nReceivedUpdates, expectedNbUpdates);
      assertEquals(nWrongReceivedUpdates, expectedNbWrongUpdates);
    }

    private void assertReceivedUpdates(int expectedNbUpdates)
    {
      assertReceivedWrongUpdates(expectedNbUpdates, 0);
    }
  }

  /**
@@ -912,16 +906,6 @@
      }
    }

    public boolean receivedUpdatesOk()
    {
      return everyUpdatesAreOk;
    }

    public int getReceivedUpdates()
    {
      return nReceivedUpdates;
    }

    /**
     * Test if the last received updates was acknowledged (ack sent with or
     * without errors).
@@ -939,6 +923,19 @@
      ackReplied = false;
      return result;
    }

    private void assertReceivedUpdates(int expectedNbUpdates)
    {
      assertEquals(nReceivedUpdates, expectedNbUpdates);
      assertTrue(everyUpdatesAreOk);
    }

    private void assertReceivedAckedUpdates(final int expectedNbUpdates,
        final boolean expectingAckReplied)
    {
      assertReceivedUpdates(expectedNbUpdates);
      assertEquals(ackReplied(), expectingAckReplied);
    }
  }

  /**
@@ -1096,18 +1093,14 @@

      // Sanity check
      Thread.sleep(500);           // Let time to update to reach other servers
      assertEquals(fakeRd1.getReceivedUpdates(), 0);
      assertTrue(fakeRd1.receivedUpdatesOk());
      fakeRd1.assertReceivedUpdates(0);
      if (otherFakeDS)
      {
        final FakeReplicationDomain fakeRd2 = fakeRDs[2];
        assertEquals(fakeRd2.getReceivedUpdates(), 1);
        assertTrue(fakeRd2.receivedUpdatesOk());
        fakeRDs[2].assertReceivedUpdates(1);
      }
      if (fakeRS)
      {
        assertEquals(fakeRs1.getReceivedUpdates(), 1);
        assertTrue(fakeRs1.receivedUpdatesOk());
        fakeRs1.assertReceivedUpdates(1);
      }
    } finally
    {
@@ -1521,59 +1514,35 @@
    final FakeReplicationDomain fakeRd2 = fakeRDs[2];

    // We should not receive our own update
    assertEquals(fakeRd1.getReceivedUpdates(), 0);
    assertTrue(fakeRd1.receivedUpdatesOk());
    fakeRd1.assertReceivedUpdates(0);

    // Check what received other fake DS
    if (otherFakeDS)
    {
      if (otherFakeDsGenId == DEFAULT_GENID)
      {
        // Update should have been received
        assertEquals(fakeRd2.getReceivedUpdates(), nSentUpdates);
        assertTrue(fakeRd2.receivedUpdatesOk());
      } else
      {
        assertEquals(fakeRd2.getReceivedUpdates(), 0);
        assertTrue(fakeRd2.receivedUpdatesOk());
      }
      fakeRd2.assertReceivedUpdates(otherFakeDsGenId == DEFAULT_GENID ? nSentUpdates : 0);
    }

    // Check what received/did fake Rss
    if (nSentUpdates < 4)  // Fake RS 3 is stopped after 3 updates sent
    {
      assertReceivedMsgs(fakeRs1, FRS1_ID, fakeRs1GenId, nSentUpdates,
          expectedServers);
      final int expectedNb = fakeRs1GenId == DEFAULT_GENID ? nSentUpdates : 0;
      fakeRs1.assertReceivedAckedUpdates(expectedNb, expectedServers.contains(FRS1_ID));
    }

    if (nSentUpdates < 3)  // Fake RS 3 is stopped after 2 updates sent
    {
      assertReceivedMsgs(fakeRs2, FRS2_ID, fakeRs2GenId, nSentUpdates,
          expectedServers);
      final int expectedNb = fakeRs2GenId == DEFAULT_GENID ? nSentUpdates : 0;
      fakeRs2.assertReceivedAckedUpdates(expectedNb, expectedServers.contains(FRS2_ID));
    }

    if (nSentUpdates < 2) // Fake RS 3 is stopped after 1 update sent
    {
      assertReceivedMsgs(fakeRs3, FRS3_ID, fakeRs3GenId, nSentUpdates,
          expectedServers);
      final int expectedNb = fakeRs3GenId == DEFAULT_GENID ? nSentUpdates : 0;
      fakeRs3.assertReceivedAckedUpdates(expectedNb, expectedServers.contains(FRS3_ID));
    }
  }

  /**
   * Asserts what messages were received by the {@link FakeReplicationServer}s.
   */
  private void assertReceivedMsgs(FakeReplicationServer fakeRs, int fakeRsId,
      long generationId, int nSentUpdates, List<Integer> expectedServers)
  {
    if (generationId != DEFAULT_GENID)
      assertEquals(fakeRs.getReceivedUpdates(), 0);
    else
      assertEquals(fakeRs.getReceivedUpdates(), nSentUpdates);
    assertTrue(fakeRs.receivedUpdatesOk());
    assertEquals(fakeRs.ackReplied(), expectedServers.contains(fakeRsId));
  }

  /**
   * Check the time the sending of the safe data assured update took and the monitoring
   * values according to the test configuration
   */
@@ -1737,7 +1706,7 @@
   */
  private List<Integer> computeEligibleServersSafeData(int fakeRs1Gid, long fakeRs1GenId, int fakeRs2Gid, long fakeRs2GenId, int fakeRs3Gid, long fakeRs3GenId)
  {
    List<Integer> eligibleServers = new ArrayList<Integer>();
    List<Integer> eligibleServers = new ArrayList<Integer>(3);
    if (areGroupAndGenerationIdOk(fakeRs1Gid, fakeRs1GenId))
    {
      eligibleServers.add(FRS1_ID);
@@ -1759,8 +1728,10 @@
   */
  private boolean areGroupAndGenerationIdOk(int fakeRsGid, long fakeRsGenId)
  {
    return (fakeRsGid != -1) && (fakeRsGenId != -1L) &&
        ((fakeRsGid == DEFAULT_GID) && (fakeRsGenId == DEFAULT_GENID));
    return fakeRsGid != -1
        && fakeRsGenId != -1L
        && fakeRsGid == DEFAULT_GID
        && fakeRsGenId == DEFAULT_GENID;
  }

  /**
@@ -2037,11 +2008,9 @@

      // Check monitoring values (check that ack has been correctly received)
      Thread.sleep(500); // Sleep a while as counters are updated just after sending thread is unblocked
      checkDSSentAndAcked(fakeRd1, 1);

      // Sanity check
      assertEquals(fakeRd1.getReceivedUpdates(), 0);
      assertTrue(fakeRd1.receivedUpdatesOk());
      checkDSSentAndAcked(fakeRd1, 1);
      fakeRd1.assertReceivedUpdates(0);

      /*******************
       * Start another fake DS 2 connected to RS
@@ -2069,17 +2038,12 @@

      // Check monitoring values (check that ack has been correctly received)
      Thread.sleep(500); // Sleep a while as counters are updated just after sending thread is unblocked
      checkDSSentAndAcked(fakeRd1, 2);

      final FakeReplicationDomain fakeRd2 = fakeRDs[2];
      checkDSSentAndAcked(fakeRd1, 2);
      fakeRd1.assertReceivedUpdates(0);
      checkDSReceivedAndAcked(fakeRd2, 1);

      // Sanity check
      assertEquals(fakeRd1.getReceivedUpdates(), 0);
      assertTrue(fakeRd1.receivedUpdatesOk());

      assertEquals(fakeRd2.getReceivedUpdates(), 1);
      assertTrue(fakeRd2.receivedUpdatesOk());
      fakeRd2.assertReceivedUpdates(1);

      /*******************
       * Start a fake RS 1 connected to RS
@@ -2108,14 +2072,9 @@
      checkDSReceivedAndAcked(fakeRd2, 2);

      // Sanity check
      assertEquals(fakeRd1.getReceivedUpdates(), 0);
      assertTrue(fakeRd1.receivedUpdatesOk());

      assertEquals(fakeRd2.getReceivedUpdates(), 2);
      assertTrue(fakeRd2.receivedUpdatesOk());

      assertEquals(fakeRs1.getReceivedUpdates(), 1);
      assertTrue(fakeRs1.receivedUpdatesOk());
      fakeRd1.assertReceivedUpdates(0);
      fakeRd2.assertReceivedUpdates(2);
      fakeRs1.assertReceivedUpdates(1);

      /*******************
       * Shutdown fake DS 2
@@ -2142,11 +2101,8 @@
      checkDSSentAndAcked(fakeRd1, 4);

      // Sanity check
      assertEquals(fakeRd1.getReceivedUpdates(), 0);
      assertTrue(fakeRd1.receivedUpdatesOk());

      assertEquals(fakeRs1.getReceivedUpdates(), 2);
      assertTrue(fakeRs1.receivedUpdatesOk());
      fakeRd1.assertReceivedUpdates(0);
      fakeRs1.assertReceivedUpdates(2);

      /*******************
       * Shutdown fake RS 1
@@ -2171,11 +2127,9 @@

      // Check monitoring values (check that ack has been correctly received)
      Thread.sleep(500); // Sleep a while as counters are updated just after sending thread is unblocked
      checkDSSentAndAcked(fakeRd1, 5);

      // Sanity check
      assertEquals(fakeRd1.getReceivedUpdates(), 0);
      assertTrue(fakeRd1.receivedUpdatesOk());
      checkDSSentAndAcked(fakeRd1, 5);
      fakeRd1.assertReceivedUpdates(0);
    } finally
    {
      endTest();
@@ -2376,17 +2330,14 @@
      {
        // Call time should have been short
        assertThat(sendUpdateTime).isLessThan(MAX_SEND_UPDATE_TIME);
      } else // Timeout
      }
      else if (shouldSeeDsRsIdInError) // Virtual DS timeout
      {
        if (shouldSeeDsRsIdInError) // Virtual DS timeout
        {
          // Should have timed out
          assertBetweenInclusive(sendUpdateTime, MAX_SEND_UPDATE_TIME, LONG_TIMEOUT);
        } else // Normal rimeout case
        {
          // Should have timed out
          assertBetweenInclusive(sendUpdateTime, SMALL_TIMEOUT, LONG_TIMEOUT);
        }
        assertBetweenInclusive(sendUpdateTime, MAX_SEND_UPDATE_TIME, LONG_TIMEOUT);
      }
      else // Normal timeout case
      {
        assertBetweenInclusive(sendUpdateTime, SMALL_TIMEOUT, LONG_TIMEOUT);
      }

      // Sleep a while as counters are updated just after sending thread is unblocked
@@ -2408,27 +2359,13 @@
      }


      if (shouldSeeTimeout)
        assertEquals(fakeRd1.getAssuredSrTimeoutUpdates(), 1);
      else
        assertEquals(fakeRd1.getAssuredSrTimeoutUpdates(), 0);
      if (shouldSeeWrongStatus)
        assertEquals(fakeRd1.getAssuredSrWrongStatusUpdates(), 1);
      else
        assertEquals(fakeRd1.getAssuredSrWrongStatusUpdates(), 0);
      if (shouldSeeReplayError)
        assertEquals(fakeRd1.getAssuredSrReplayErrorUpdates(), 1);
      else
        assertEquals(fakeRd1.getAssuredSrReplayErrorUpdates(), 0);
      assertEquals(fakeRd1.getAssuredSrTimeoutUpdates(), shouldSeeTimeout ? 1 : 0);
      assertEquals(fakeRd1.getAssuredSrWrongStatusUpdates(), shouldSeeWrongStatus ? 1 : 0);
      assertEquals(fakeRd1.getAssuredSrReplayErrorUpdates(), shouldSeeReplayError ? 1 : 0);

      // Check for servers in error list
      Map<Integer, Integer> expectedErrors = new HashMap<Integer, Integer>();
      if (shouldSeeDsIdInError)
        expectedErrors.put(FDS3_ID, 1);
      if (shouldSeeRsIdInError)
        expectedErrors.put(FRS2_ID, 1);
      if (shouldSeeDsRsIdInError)
        expectedErrors.put(DS_FRS2_ID, 1);
      Map<Integer, Integer> expectedErrors =
          buildExpectedErrors(shouldSeeDsIdInError, shouldSeeRsIdInError, shouldSeeDsRsIdInError);
      checkServerErrorListsAreEqual(fakeRd1.getAssuredSrServerNotAcknowledgedUpdates(), expectedErrors);

      assertEquals(fakeRd1.getAssuredSrReceivedUpdates(), 0);
@@ -2449,7 +2386,7 @@
      assertEquals(fakeRd3.getAssuredSrTimeoutUpdates(), 0);
      assertEquals(fakeRd3.getAssuredSrWrongStatusUpdates(), 0);
      assertEquals(fakeRd3.getAssuredSrReplayErrorUpdates(), 0);
      assertEquals(fakeRd3.getAssuredSrServerNotAcknowledgedUpdates().size(), 0);
      assertThat(fakeRd3.getAssuredSrServerNotAcknowledgedUpdates()).isEmpty();
      if (dsIsEligible)
      {
        assertEquals(fakeRd3.getAssuredSrReceivedUpdates(), 1);
@@ -2457,18 +2394,17 @@
        {
          assertEquals(fakeRd3.getAssuredSrReceivedUpdatesAcked(), 1);
          assertEquals(fakeRd3.getAssuredSrReceivedUpdatesNotAcked(), 0);
        }
        else if (shouldSeeReplayError
            && otherFakeDsScen == REPLAY_ERROR_DS_SCENARIO)
        {
          // Replay error for the other DS
          assertEquals(fakeRd3.getAssuredSrReceivedUpdatesAcked(), 0);
          assertEquals(fakeRd3.getAssuredSrReceivedUpdatesNotAcked(), 1);
        } else
        {
          if (shouldSeeReplayError && (otherFakeDsScen == REPLAY_ERROR_DS_SCENARIO))
          {
            // Replay error for the other DS
            assertEquals(fakeRd3.getAssuredSrReceivedUpdatesAcked(), 0);
            assertEquals(fakeRd3.getAssuredSrReceivedUpdatesNotAcked(), 1);
          } else
          {
            assertEquals(fakeRd3.getAssuredSrReceivedUpdatesAcked(), 0);
            assertEquals(fakeRd3.getAssuredSrReceivedUpdatesNotAcked(), 0);
          }
          assertEquals(fakeRd3.getAssuredSrReceivedUpdatesAcked(), 0);
          assertEquals(fakeRd3.getAssuredSrReceivedUpdatesNotAcked(), 0);
        }
      }
      else
@@ -2479,28 +2415,12 @@
      }

      // Sanity check
      //
      assertEquals(fakeRd1.getReceivedUpdates(), 0);
      assertTrue(fakeRd1.receivedUpdatesOk());
      fakeRd1.assertReceivedUpdates(0);
      fakeRd2.assertReceivedUpdates(1);
      fakeRd3.assertReceivedUpdates(otherFakeDsGenId == DEFAULT_GENID ? 1 : 0);

      assertEquals(fakeRd2.getReceivedUpdates(), 1);
      assertTrue(fakeRd2.receivedUpdatesOk());

      if (otherFakeDsGenId == DEFAULT_GENID)
        assertEquals(fakeRd3.getReceivedUpdates(), 1);
      else
        assertEquals(fakeRd3.getReceivedUpdates(), 0);
      assertTrue(fakeRd3.receivedUpdatesOk());

      assertEquals(fakeRs1.getReceivedUpdates(), 1);
      assertTrue(fakeRs1.receivedUpdatesOk());

      if (otherFakeRsGenId == DEFAULT_GENID)
        assertEquals(fakeRs2.getReceivedUpdates(), 1);
      else
        assertEquals(fakeRs2.getReceivedUpdates(), 0);
      assertTrue(fakeRs2.receivedUpdatesOk());

      fakeRs1.assertReceivedUpdates(1);
      fakeRs2.assertReceivedUpdates(otherFakeRsGenId == DEFAULT_GENID ? 1 : 0);
    } finally
    {
      endTest();
@@ -2514,6 +2434,24 @@
        + "> inclusive");
  }

  private Map<Integer, Integer> buildExpectedErrors(boolean dsInError, boolean rsInError, boolean dsRsInError)
  {
    Map<Integer, Integer> expectedErrors = new HashMap<Integer, Integer>();
    if (dsInError)
    {
      expectedErrors.put(FDS3_ID, 1);
    }
    if (rsInError)
    {
      expectedErrors.put(FRS2_ID, 1);
    }
    if (dsRsInError)
    {
      expectedErrors.put(DS_FRS2_ID, 1);
    }
    return expectedErrors;
  }

  /**
   * Check that the passed server error lists are equivalent
   */
@@ -2692,15 +2630,14 @@
      assertFakeDSReceivedAndAcked(0, asList(10, 11, 12)); // different GENID DSs

      // Sanity check
      assertEquals(fakeRd1.getReceivedUpdates(), 0);
      assertTrue(fakeRd1.receivedUpdatesOk());
      fakeRd1.assertReceivedUpdates(0);

      assertFakeRDNbReceivedUpdates(1, asList(2, 3, 4, 5)); // normal DSs
      assertFakeRDNbReceivedUpdates(1, asList(6, 7, 8, 9)); // different GID DSs
      assertFakeRDNbReceivedUpdates(0, asList(10, 11, 12)); // different GENID DSs

      assertFakeRSNbReceivedUpdates(fakeRs1, 0);
      assertFakeRSNbReceivedUpdates(fakeRs2, 1);
      fakeRs1.assertReceivedAckedUpdates(0, false);
      fakeRs2.assertReceivedAckedUpdates(1, false);

      /*
       * Send a second update from DS 1 and check result
@@ -2722,15 +2659,14 @@
      assertFakeDSReceivedAndAcked(0, asList(10, 11, 12)); // different GENID DSs

      // Sanity check
      assertEquals(fakeRd1.getReceivedUpdates(), 0);
      assertTrue(fakeRd1.receivedUpdatesOk());
      fakeRd1.assertReceivedUpdates(0);

      assertFakeRDNbReceivedUpdates(2, asList(2, 3, 4, 5)); // normal DSs
      assertFakeRDNbReceivedUpdates(2, asList(6, 7, 8, 9)); // different GID DSs
      assertFakeRDNbReceivedUpdates(0, asList(10, 11, 12)); // different GENID DSs

      assertFakeRSNbReceivedUpdates(fakeRs1, 0);
      assertFakeRSNbReceivedUpdates(fakeRs2, 2);
      fakeRs1.assertReceivedAckedUpdates(0, false);
      fakeRs2.assertReceivedAckedUpdates(2, false);
    } finally
    {
      endTest();
@@ -2749,18 +2685,10 @@
  {
    for (int i : fakeDSIndexes)
    {
      assertEquals(fakeRDs[i].getReceivedUpdates(), expectedNbReceived);
      assertTrue(fakeRDs[i].receivedUpdatesOk());
      fakeRDs[i].assertReceivedUpdates(expectedNbReceived);
    }
  }

  private void assertFakeRSNbReceivedUpdates(FakeReplicationServer fakeRs, int expectedNbReceived)
  {
    assertEquals(fakeRs.getReceivedUpdates(), expectedNbReceived);
    assertTrue(fakeRs.receivedUpdatesOk());
    assertFalse(fakeRs.ackReplied());
  }

  /** Helper method for some safe read test methods */
  private void checkDSReceivedAndAcked(FakeReplicationDomain fakeRd, int nPacket)
  {
@@ -2770,7 +2698,7 @@
    assertEquals(fakeRd.getAssuredSrTimeoutUpdates(), 0);
    assertEquals(fakeRd.getAssuredSrWrongStatusUpdates(), 0);
    assertEquals(fakeRd.getAssuredSrReplayErrorUpdates(), 0);
    assertEquals(fakeRd.getAssuredSrServerNotAcknowledgedUpdates().size(), 0);
    assertThat(fakeRd.getAssuredSrServerNotAcknowledgedUpdates()).isEmpty();
    assertEquals(fakeRd.getAssuredSrReceivedUpdates(), nPacket);
    assertEquals(fakeRd.getAssuredSrReceivedUpdatesAcked(), nPacket);
    assertEquals(fakeRd.getAssuredSrReceivedUpdatesNotAcked(), 0);
@@ -2785,7 +2713,7 @@
    assertEquals(fakeRd.getAssuredSrTimeoutUpdates(), 0);
    assertEquals(fakeRd.getAssuredSrWrongStatusUpdates(), 0);
    assertEquals(fakeRd.getAssuredSrReplayErrorUpdates(), 0);
    assertEquals(fakeRd.getAssuredSrServerNotAcknowledgedUpdates().size(), 0);
    assertThat(fakeRd.getAssuredSrServerNotAcknowledgedUpdates()).isEmpty();
    assertEquals(fakeRd.getAssuredSrReceivedUpdates(), 0);
    assertEquals(fakeRd.getAssuredSrReceivedUpdatesAcked(), 0);
    assertEquals(fakeRd.getAssuredSrReceivedUpdatesNotAcked(), 0);
@@ -2799,7 +2727,7 @@
    assertEquals(fakeRd.getAssuredSrTimeoutUpdates(), 0);
    assertEquals(fakeRd.getAssuredSrWrongStatusUpdates(), 0);
    assertEquals(fakeRd.getAssuredSrReplayErrorUpdates(), 0);
    assertEquals(fakeRd.getAssuredSrServerNotAcknowledgedUpdates().size(), 0);
    assertThat(fakeRd.getAssuredSrServerNotAcknowledgedUpdates()).isEmpty();
    assertEquals(fakeRd.getAssuredSrReceivedUpdates(), 0);
    assertEquals(fakeRd.getAssuredSrReceivedUpdatesAcked(), 0);
    assertEquals(fakeRd.getAssuredSrReceivedUpdatesNotAcked(), 0);
@@ -2880,14 +2808,10 @@
      checkDSNothingReceivedOrSent(fakeRDs[3]);
      checkDSNothingReceivedOrSent(fakeRDs[4]);

      assertEquals(fakeRDs[1].getReceivedUpdates(), 0);
      assertTrue(fakeRDs[1].receivedUpdatesOk());
      assertEquals(fakeRDs[2].getReceivedUpdates(), 1);
      assertTrue(fakeRDs[2].receivedUpdatesOk());
      assertEquals(fakeRDs[3].getReceivedUpdates(), 1);
      assertTrue(fakeRDs[3].receivedUpdatesOk());
      assertEquals(fakeRDs[4].getReceivedUpdates(), 1);
      assertTrue(fakeRDs[4].receivedUpdatesOk());
      fakeRDs[1].assertReceivedUpdates(0);
      fakeRDs[2].assertReceivedUpdates(1);
      fakeRDs[3].assertReceivedUpdates(1);
      fakeRDs[4].assertReceivedUpdates(1);
    }
    finally
    {
@@ -2991,7 +2915,7 @@
            assertEquals(fakeRd1.getAssuredSrTimeoutUpdates(), 1);
            assertEquals(fakeRd1.getAssuredSrWrongStatusUpdates(), 0);
            assertEquals(fakeRd1.getAssuredSrReplayErrorUpdates(), 0);
            assertContainsOnly(fakeRd1.getAssuredSrServerNotAcknowledgedUpdates(), FDS2_ID, 1);
            assertThat(fakeRd1.getAssuredSrServerNotAcknowledgedUpdates()).containsOnly(entry(FDS2_ID, 1));
            assertEquals(fakeRd1.getAssuredSrReceivedUpdates(), 0);
            assertEquals(fakeRd1.getAssuredSrReceivedUpdatesAcked(), 0);
            assertEquals(fakeRd1.getAssuredSrReceivedUpdatesNotAcked(), 0);
@@ -3002,7 +2926,7 @@
            assertEquals(fakeRd2.getAssuredSrTimeoutUpdates(), 0);
            assertEquals(fakeRd2.getAssuredSrWrongStatusUpdates(), 0);
            assertEquals(fakeRd2.getAssuredSrReplayErrorUpdates(), 0);
            assertEquals(fakeRd2.getAssuredSrServerNotAcknowledgedUpdates().size(), 0);
            assertThat(fakeRd2.getAssuredSrServerNotAcknowledgedUpdates()).isEmpty();
            assertEquals(fakeRd2.getAssuredSrReceivedUpdates(), 1);
            assertEquals(fakeRd2.getAssuredSrReceivedUpdatesAcked(), 0);
            assertEquals(fakeRd2.getAssuredSrReceivedUpdatesNotAcked(), 0);
@@ -3014,7 +2938,7 @@
            assertEquals(fakeRd1.getAssuredSrTimeoutUpdates(), 0);
            assertEquals(fakeRd1.getAssuredSrWrongStatusUpdates(), 0);
            assertEquals(fakeRd1.getAssuredSrReplayErrorUpdates(), 1);
            assertContainsOnly(fakeRd1.getAssuredSrServerNotAcknowledgedUpdates(), FDS2_ID, 1);
            assertThat(fakeRd1.getAssuredSrServerNotAcknowledgedUpdates()).containsOnly(entry(FDS2_ID, 1));
            assertEquals(fakeRd1.getAssuredSrReceivedUpdates(), 0);
            assertEquals(fakeRd1.getAssuredSrReceivedUpdatesAcked(), 0);
            assertEquals(fakeRd1.getAssuredSrReceivedUpdatesNotAcked(), 0);
@@ -3025,7 +2949,7 @@
            assertEquals(fakeRd2.getAssuredSrTimeoutUpdates(), 0);
            assertEquals(fakeRd2.getAssuredSrWrongStatusUpdates(), 0);
            assertEquals(fakeRd2.getAssuredSrReplayErrorUpdates(), 0);
            assertEquals(fakeRd2.getAssuredSrServerNotAcknowledgedUpdates().size(), 0);
            assertThat(fakeRd2.getAssuredSrServerNotAcknowledgedUpdates()).isEmpty();
            assertEquals(fakeRd2.getAssuredSrReceivedUpdates(), 1);
            assertEquals(fakeRd2.getAssuredSrReceivedUpdatesAcked(), 0);
            assertEquals(fakeRd2.getAssuredSrReceivedUpdatesNotAcked(), 1);
@@ -3039,13 +2963,8 @@
        checkDSReceivedAndAcked(fakeRd2, 0);
      }

      assertEquals(fakeRd1.getReceivedUpdates(), 0);
      assertTrue(fakeRd1.receivedUpdatesOk());
      if (fakeDsGenId == DEFAULT_GENID)
        assertEquals(fakeRd2.getReceivedUpdates(), 1);
      else
        assertEquals(fakeRd2.getReceivedUpdates(), 0);
      assertTrue(fakeRd2.receivedUpdatesOk());
      fakeRd1.assertReceivedUpdates(0);
      fakeRd2.assertReceivedUpdates(fakeDsGenId == DEFAULT_GENID ? 1 : 0);
    } finally
    {
      endTest();
@@ -3127,7 +3046,7 @@
      assertEquals(fakeRd1.getAssuredSrTimeoutUpdates(), 4);
      assertEquals(fakeRd1.getAssuredSrWrongStatusUpdates(), 0);
      assertEquals(fakeRd1.getAssuredSrReplayErrorUpdates(), 0);
      assertContainsOnly(fakeRd1.getAssuredSrServerNotAcknowledgedUpdates(), FDS2_ID, 4);
      assertThat(fakeRd1.getAssuredSrServerNotAcknowledgedUpdates()).containsOnly(entry(FDS2_ID, 4));
      assertEquals(fakeRd1.getAssuredSrReceivedUpdates(), 0);
      assertEquals(fakeRd1.getAssuredSrReceivedUpdatesAcked(), 0);
      assertEquals(fakeRd1.getAssuredSrReceivedUpdatesNotAcked(), 0);
@@ -3135,12 +3054,8 @@
      final FakeReplicationDomain fakeRd2 = fakeRDs[2];
      checkDSNothingReceivedOrSent(fakeRd2);

      assertEquals(fakeRd1.getReceivedUpdates(), 0);
      assertEquals(fakeRd1.getWrongReceivedUpdates(), 0);

      assertEquals(fakeRd2.getReceivedUpdates(), 0);
      assertEquals(fakeRd2.getWrongReceivedUpdates(), 0);
      assertTrue(fakeRd2.receivedUpdatesOk());
      fakeRd1.assertReceivedUpdates(0);
      fakeRd2.assertReceivedUpdates(0);

      /*
       * Send an assured update from DS 1 : should be acked as DS2 is degraded
@@ -3159,19 +3074,15 @@
      assertEquals(fakeRd1.getAssuredSrTimeoutUpdates(), 4);
      assertEquals(fakeRd1.getAssuredSrWrongStatusUpdates(), 0);
      assertEquals(fakeRd1.getAssuredSrReplayErrorUpdates(), 0);
      assertContainsOnly(fakeRd1.getAssuredSrServerNotAcknowledgedUpdates(), FDS2_ID, 4);
      assertThat(fakeRd1.getAssuredSrServerNotAcknowledgedUpdates()).containsOnly(entry(FDS2_ID, 4));
      assertEquals(fakeRd1.getAssuredSrReceivedUpdates(), 0);
      assertEquals(fakeRd1.getAssuredSrReceivedUpdatesAcked(), 0);
      assertEquals(fakeRd1.getAssuredSrReceivedUpdatesNotAcked(), 0);

      checkDSNothingReceivedOrSent(fakeRd2);

      assertEquals(fakeRd1.getReceivedUpdates(), 0);
      assertEquals(fakeRd1.getWrongReceivedUpdates(), 0);

      assertEquals(fakeRd2.getReceivedUpdates(), 0);
      assertEquals(fakeRd2.getWrongReceivedUpdates(), 0);
      assertTrue(fakeRd2.receivedUpdatesOk());
      fakeRd1.assertReceivedUpdates(0);
      fakeRd2.assertReceivedUpdates(0);

      /*
       * Put DS2 in normal status again (start listen service)
@@ -3189,7 +3100,7 @@
      assertEquals(fakeRd1.getAssuredSrTimeoutUpdates(), 4);
      assertEquals(fakeRd1.getAssuredSrWrongStatusUpdates(), 0);
      assertEquals(fakeRd1.getAssuredSrReplayErrorUpdates(), 0);
      assertContainsOnly(fakeRd1.getAssuredSrServerNotAcknowledgedUpdates(), FDS2_ID, 4);
      assertThat(fakeRd1.getAssuredSrServerNotAcknowledgedUpdates()).containsOnly(entry(FDS2_ID, 4));
      assertEquals(fakeRd1.getAssuredSrReceivedUpdates(), 0);
      assertEquals(fakeRd1.getAssuredSrReceivedUpdatesAcked(), 0);
      assertEquals(fakeRd1.getAssuredSrReceivedUpdatesNotAcked(), 0);
@@ -3200,18 +3111,15 @@
      assertEquals(fakeRd2.getAssuredSrTimeoutUpdates(), 0);
      assertEquals(fakeRd2.getAssuredSrWrongStatusUpdates(), 0);
      assertEquals(fakeRd2.getAssuredSrReplayErrorUpdates(), 0);
      assertEquals(fakeRd2.getAssuredSrServerNotAcknowledgedUpdates().size(), 0);
      assertThat(fakeRd2.getAssuredSrServerNotAcknowledgedUpdates()).isEmpty();
      assertEquals(fakeRd2.getAssuredSrReceivedUpdates(), 4);
      assertEquals(fakeRd2.getAssuredSrReceivedUpdatesAcked(), 4);
      assertEquals(fakeRd2.getAssuredSrReceivedUpdatesNotAcked(), 0);

      assertEquals(fakeRd1.getReceivedUpdates(), 0);
      assertEquals(fakeRd1.getWrongReceivedUpdates(), 0);
      fakeRd1.assertReceivedUpdates(0);

      // DS2 should have received the 5 updates (one with not assured)
      assertEquals(fakeRd2.getReceivedUpdates(), 5);
      assertEquals(fakeRd2.getWrongReceivedUpdates(), 1);
      assertFalse(fakeRd2.receivedUpdatesOk());
      fakeRd2.assertReceivedWrongUpdates(5, 1);

      /*
       * Send again an assured update, DS2 should be taken into account for ack
@@ -3229,7 +3137,7 @@
      assertEquals(fakeRd1.getAssuredSrTimeoutUpdates(), 4);
      assertEquals(fakeRd1.getAssuredSrWrongStatusUpdates(), 0);
      assertEquals(fakeRd1.getAssuredSrReplayErrorUpdates(), 0);
      assertContainsOnly(fakeRd1.getAssuredSrServerNotAcknowledgedUpdates(), FDS2_ID, 4);
      assertThat(fakeRd1.getAssuredSrServerNotAcknowledgedUpdates()).containsOnly(entry(FDS2_ID, 4));
      assertEquals(fakeRd1.getAssuredSrReceivedUpdates(), 0);
      assertEquals(fakeRd1.getAssuredSrReceivedUpdatesAcked(), 0);
      assertEquals(fakeRd1.getAssuredSrReceivedUpdatesNotAcked(), 0);
@@ -3240,17 +3148,13 @@
      assertEquals(fakeRd2.getAssuredSrTimeoutUpdates(), 0);
      assertEquals(fakeRd2.getAssuredSrWrongStatusUpdates(), 0);
      assertEquals(fakeRd2.getAssuredSrReplayErrorUpdates(), 0);
      assertEquals(fakeRd2.getAssuredSrServerNotAcknowledgedUpdates().size(), 0);
      assertThat(fakeRd2.getAssuredSrServerNotAcknowledgedUpdates()).isEmpty();
      assertEquals(fakeRd2.getAssuredSrReceivedUpdates(), 5);
      assertEquals(fakeRd2.getAssuredSrReceivedUpdatesAcked(), 5);
      assertEquals(fakeRd2.getAssuredSrReceivedUpdatesNotAcked(), 0);

      assertEquals(fakeRd1.getReceivedUpdates(), 0);
      assertEquals(fakeRd1.getWrongReceivedUpdates(), 0);

      assertEquals(fakeRd2.getReceivedUpdates(), 6);
      assertEquals(fakeRd2.getWrongReceivedUpdates(), 1);
      assertFalse(fakeRd2.receivedUpdatesOk());
      fakeRd1.assertReceivedUpdates(0);
      fakeRd2.assertReceivedWrongUpdates(6, 1);
    }
    finally
    {
@@ -3273,13 +3177,4 @@
    Assert.fail("DS(" + dsId + ") did not have expected status "
        + expectedStatus + " after 12 seconds");
  }

  private void assertContainsOnly(Map<Integer, Integer> map, int key,
      int expectedValue)
  {
    assertEquals(map.size(), 1);
    final Integer nError = map.get(key);
    assertNotNull(nError);
    assertEquals(nError.intValue(), expectedValue);
  }
}