private void mockFetchManagerRestartAnyTimes() throws InterruptedException {
   this.fetchManager.stopFetchRunner();
   EasyMock.expectLastCall().anyTimes();
   this.fetchManager.resetFetchState();
   EasyMock.expectLastCall().anyTimes();
   this.fetchManager.startFetchRunner();
   EasyMock.expectLastCall().anyTimes();
 }
  @SuppressWarnings({"ThrowableInstanceNeverThrown"})
  private void expectEvaluateCalled(
      final I_EncodeBusinessProcess mockBusinessProcess,
      final CleanableProcessExtByRef mockCleanableProcess,
      final CleanableProcessExtByRefBuilder mockCleanableProcessBuilder)
      throws Exception {

    File mockDirectoryFile = mockControl.createMock(File.class);
    I_GetConceptData mockRefset = mockControl.createMock(I_GetConceptData.class);

    EasyMock.expect(mockTerminologyWrapper.get()).andReturn(mockTermFactory);
    EasyMock.expect(mockBusinessProcess.getProperty(DIRECTORY_KEY)).andReturn(mockDirectoryFile);
    EasyMock.expect(mockBusinessProcess.getProperty(WORKING_REFSET_KEY)).andReturn(mockRefset);
    mockPropertyValidator.validate(mockDirectoryFile, "output directory");
    mockPropertyValidator.validate(mockRefset, "selected refset");

    EasyMock.expect(mockCleanableProcessBuilder.withTermFactory(mockTermFactory))
        .andReturn(mockCleanableProcessBuilder);
    EasyMock.expect(mockCleanableProcessBuilder.withSelectedDir(mockDirectoryFile))
        .andReturn(mockCleanableProcessBuilder);
    EasyMock.expect(mockCleanableProcessBuilder.withLogger(EasyMock.isA(Logger.class)))
        .andReturn(mockCleanableProcessBuilder);
    EasyMock.expect(mockCleanableProcessBuilder.build()).andReturn(mockCleanableProcess);
    I_ExtendByRef mockExt1 = mockControl.createMock(I_ExtendByRef.class);
    I_ExtendByRef mockExt2 = mockControl.createMock(I_ExtendByRef.class);
    EasyMock.expect(mockRefset.getConceptId()).andReturn(REFSET_CONCEPT_ID);
    // TODO fix this one
    // EasyMock.expect(mockTermFactory.getRefsetExtensionMembers(REFSET_CONCEPT_ID)).andReturn(Arrays.asList(mockExt1, mockExt2));

    mockCleanableProcess.processExtensionByReference(mockExt1);
    mockCleanableProcess.processExtensionByReference(mockExt2);
    EasyMock.expectLastCall().andThrow(new IllegalStateException());

    mockCleanableProcess.clean();
  }
Beispiel #3
0
  @Test
  public void testHandleRequestPartitionClosedSlave() throws Exception {
    final int partition = 1;
    final int opaque = 0;
    final int maxSize = 1024;
    final long offset = 10;

    this.metaConfig.setTopics(Arrays.asList(this.topic));
    this.metaConfig.closePartitions(this.topic, partition, partition);

    final MessageStore store = this.mocksControl.createMock(MessageStore.class);
    EasyMock.expect(this.storeManager.getMessageStore(this.topic, partition)).andReturn(store);
    final MessageSet set = this.mocksControl.createMock(MessageSet.class);
    EasyMock.expect(store.slice(offset, maxSize)).andReturn(set);

    final GetCommand request =
        new GetCommand(
            this.topic, this.metaConfig.getSlaveGroup(), partition, offset, maxSize, opaque);
    // this.conn.response(new BooleanCommand(request.getOpaque(),
    // HttpStatus.Forbidden, "partition["
    // + this.metaConfig.getBrokerId() + "-" + request.getPartition() +
    // "] have been closed"));
    set.write(request, this.sessionContext);
    EasyMock.expectLastCall();

    this.mocksControl.replay();

    this.getProcessor.handleRequest(request, this.conn);
    this.mocksControl.verify();
    assertEquals(0, this.statsManager.getCmdGetMiss());
    assertEquals(1, this.statsManager.getCmdGets());
    assertEquals(0, this.statsManager.getCmdOffsets());
  }
Beispiel #4
0
  @Test
  public void testHandleRequestPartitionClosed() throws Exception {
    final int partition = 1;
    final int opaque = 0;
    final int maxSize = 1024;
    final long offset = 10;

    this.metaConfig.setTopics(Arrays.asList(this.topic));
    this.metaConfig.closePartitions(this.topic, partition, partition);
    final GetCommand request =
        new GetCommand(this.topic, this.group, partition, offset, maxSize, opaque);
    this.conn.response(
        new BooleanCommand(
            request.getOpaque(),
            HttpStatus.Forbidden,
            "Partition["
                + this.metaConfig.getBrokerId()
                + "-"
                + request.getPartition()
                + "] has been closed"));
    EasyMock.expectLastCall();

    this.mocksControl.replay();

    this.getProcessor.handleRequest(request, this.conn);
    this.mocksControl.verify();
  }
 public SmsBuilder aboutPurchase(String amount) {
   EasyMock.expect(anySmsMessage.getDisplayMessageBody())
       .andReturn(
           String.format(
               "You have done a debit purchase of INR %s at ARJAY RETAIL SONY BANGALORE.Available balance as on Jan 6 2010 8:45 PM IST is INR 10,000.00",
               amount));
   EasyMock.expectLastCall().anyTimes();
   return this;
 }
 private void mockLoadNullInitOffset(
     final String topic, final String group, final Partition partition) {
   EasyMock.expect(
           this.offsetStorage.load(
               EasyMock.eq(topic), EasyMock.contains(group), EasyMock.eq(partition)))
       .andReturn(null);
   this.offsetStorage.initOffset(
       EasyMock.eq(topic), EasyMock.contains(group), EasyMock.eq(partition), EasyMock.eq(0L));
   EasyMock.expectLastCall();
 }
  @Test
  public void testPerformReturnsUnstableAndDoesNotInvokeOtherPublishers() throws Exception {
    final BapPublisher mockPub1 = createAndAddMockPublisher(hostConfiguration.getName());
    mockPub1.perform(hostConfiguration, buildInfo);
    EasyMock.expectLastCall().andThrow(new RuntimeException("Bad stuff here!"));
    createAndAddMockPublisher(null);

    final BPInstanceConfig instanceConfig = createInstanceConfig(publishers, false, false, false);
    instanceConfig.setHostConfigurationAccess(mockHostConfigurationAccess);

    assertResult(Result.UNSTABLE, instanceConfig);
  }
  @Test
  public void testPerformReturnsFailureIfFailOnError() throws Exception {
    final BapPublisher mockPub1 = createAndAddMockPublisher(hostConfiguration.getName());
    mockPub1.perform(hostConfiguration, buildInfo);
    EasyMock.expectLastCall().andThrow(new RuntimeException("Bad stuff here!"));
    createAndAddMockPublisher(null);

    final BPInstanceConfig instanceConfig = createInstanceConfig(publishers, false, true, false);
    instanceConfig.setHostConfigurationAccess(mockHostConfigurationAccess);

    assertResult(Result.FAILURE, instanceConfig);
  }
 @Test
 public void testHandleBeginTransaction() throws Exception {
   final String sessionId = "test";
   final LocalTransactionId transactionId = new LocalTransactionId(sessionId, 1);
   final TransactionInfo info =
       new TransactionInfo(transactionId, sessionId, TransactionType.BEGIN);
   final TransactionCommand tc = new TransactionCommand(info, 1);
   this.commandProcessor.beginTransaction(
       new SessionContextImpl(sessionId, this.conn), transactionId, 0);
   EasyMock.expectLastCall();
   this.mockSessionContext(sessionId, sessionId);
   this.mockResponseOK();
   this.replay();
   this.transactionProcessor.handleRequest(tc, this.conn);
 }
 @Test
 public void testCommitOnePhase() throws Exception {
   final String sessionId = "test";
   final LocalTransactionId transactionId = new LocalTransactionId(sessionId, 1);
   final TransactionInfo info =
       new TransactionInfo(transactionId, sessionId, TransactionType.COMMIT_ONE_PHASE);
   final TransactionCommand tc = new TransactionCommand(info, 1);
   this.commandProcessor.commitTransaction(
       new SessionContextImpl(sessionId, this.conn), transactionId, true);
   EasyMock.expectLastCall();
   this.mockResponseOK();
   this.mockSessionContext(sessionId, sessionId);
   this.replay();
   this.transactionProcessor.handleRequest(tc, this.conn);
 }
  @Test
  public void testHandleException() throws Exception {
    final String sessionId = "test";
    final TransactionInfo info = new TransactionInfo(null, sessionId, TransactionType.RECOVER);
    final TransactionCommand tc = new TransactionCommand(info, 1);
    this.mockSessionContext(SessionContextHolder.GLOBAL_SESSION_KEY, sessionId);

    EasyMock.expect(
            this.commandProcessor.getPreparedTransactions(
                new SessionContextImpl("test", this.conn)))
        .andThrow(new RuntimeException("just for test"));

    this.conn.response(new BooleanCommand(1, HttpStatus.InternalServerError, "just for test"));
    EasyMock.expectLastCall();
    this.replay();
    this.transactionProcessor.handleRequest(tc, this.conn);
  }
  @Test
  public void testRecoverTransaction() throws Exception {
    final String sessionId = "test";
    final TransactionInfo info = new TransactionInfo(null, sessionId, TransactionType.RECOVER);
    final TransactionCommand tc = new TransactionCommand(info, 1);
    final TransactionId[] ids = this.generateIds();
    final String resultString = this.generateIdsString(ids);
    this.mockSessionContext(SessionContextHolder.GLOBAL_SESSION_KEY, sessionId);
    EasyMock.expect(
            this.commandProcessor.getPreparedTransactions(
                new SessionContextImpl("test", this.conn)))
        .andReturn(ids);

    this.conn.response(new BooleanCommand(1, HttpStatus.Success, resultString));
    EasyMock.expectLastCall();
    this.replay();
    this.transactionProcessor.handleRequest(tc, this.conn);
  }
Beispiel #13
0
  @Test
  public void testHandleRequestNoStore() throws Exception {
    final int partition = 1;
    final int opaque = 0;
    EasyMock.expect(this.storeManager.getMessageStore(this.topic, partition)).andReturn(null);
    this.conn.response(
        new BooleanCommand(
            opaque,
            HttpStatus.NotFound,
            "The topic `" + this.topic + "` in partition `" + partition + "` is not exists"));
    EasyMock.expectLastCall();
    this.mocksControl.replay();

    final GetCommand request =
        new GetCommand(this.topic, this.group, partition, opaque, 1024 * 1024, opaque);
    this.getProcessor.handleRequest(request, this.conn);
    this.mocksControl.verify();
    assertEquals(1, this.statsManager.getCmdGetMiss());
    assertEquals(1, this.statsManager.getCmdGets());
    assertEquals(0, this.statsManager.getCmdOffsets());
  }
Beispiel #14
0
  @Test
  public void testHandleRequestNormal() throws Exception {
    final int partition = 1;
    final int opaque = 0;
    final int maxSize = 1024;
    final long offset = 10;
    final MessageStore store = this.mocksControl.createMock(MessageStore.class);
    EasyMock.expect(this.storeManager.getMessageStore(this.topic, partition)).andReturn(store);
    final MessageSet set = this.mocksControl.createMock(MessageSet.class);
    EasyMock.expect(store.slice(offset, maxSize)).andReturn(set);
    final GetCommand request =
        new GetCommand(this.topic, this.group, partition, offset, maxSize, opaque);
    set.write(request, this.sessionContext);
    EasyMock.expectLastCall();
    this.mocksControl.replay();

    this.getProcessor.handleRequest(request, this.conn);
    this.mocksControl.verify();
    assertEquals(0, this.statsManager.getCmdGetMiss());
    assertEquals(1, this.statsManager.getCmdGets());
    assertEquals(0, this.statsManager.getCmdOffsets());
  }
Beispiel #15
0
  @Test
  public void testHandleRequestInvalidMaxSize() throws Exception {
    final int partition = 1;
    final int opaque = 0;
    final int maxSize = -1;
    this.metaConfig.setMaxTransferSize(1024);
    EasyMock.expect(this.storeManager.getMessageStore(this.topic, partition))
        .andReturn(new MessageStore(this.topic, partition, this.metaConfig, null));
    this.conn.response(
        new BooleanCommand(
            opaque, HttpStatus.BadRequest, "Bad request,invalid max size:" + maxSize));
    EasyMock.expectLastCall();
    this.mocksControl.replay();

    final GetCommand request =
        new GetCommand(this.topic, this.group, partition, opaque, maxSize, opaque);
    this.getProcessor.handleRequest(request, this.conn);
    this.mocksControl.verify();
    assertEquals(0, this.statsManager.getCmdGetMiss());
    assertEquals(1, this.statsManager.getCmdGets());
    assertEquals(0, this.statsManager.getCmdOffsets());
  }
Beispiel #16
0
  @Test
  public void testHandleRequestArrayIndexOutOfBounds() throws Exception {
    final int partition = 1;
    final int opaque = 0;
    final int maxSize = 1024;
    final long offset = 10;
    final long newOffset = 512;
    final MessageStore store = this.mocksControl.createMock(MessageStore.class);
    EasyMock.expect(this.storeManager.getMessageStore(this.topic, partition)).andReturn(store);
    EasyMock.expect(store.slice(offset, maxSize)).andThrow(new ArrayIndexOutOfBoundsException());
    EasyMock.expect(store.getNearestOffset(offset)).andReturn(newOffset);
    this.conn.response(new BooleanCommand(opaque, HttpStatus.Moved, String.valueOf(newOffset)));
    EasyMock.expectLastCall();
    this.mocksControl.replay();

    final GetCommand request =
        new GetCommand(this.topic, this.group, partition, offset, maxSize, opaque);
    this.getProcessor.handleRequest(request, this.conn);
    this.mocksControl.verify();
    assertEquals(1, this.statsManager.getCmdGetMiss());
    assertEquals(1, this.statsManager.getCmdGets());
    assertEquals(1, this.statsManager.getCmdOffsets());
  }
Beispiel #17
0
  @Test
  public void testHandleRequestGreatThanMaxOffsetSliceNull() throws Exception {
    final int partition = 1;
    final int opaque = 0;
    final int maxSize = 1024;
    final long offset = 10;
    final MessageStore store = this.mocksControl.createMock(MessageStore.class);
    EasyMock.expect(this.storeManager.getMessageStore(this.topic, partition)).andReturn(store);
    EasyMock.expect(store.slice(offset, maxSize)).andReturn(null);
    this.conn.response(
        new BooleanCommand(
            opaque, HttpStatus.NotFound, "Could not find message at position " + offset));
    EasyMock.expect(store.getMaxOffset()).andReturn(offset - 1);
    EasyMock.expectLastCall();
    this.mocksControl.replay();

    final GetCommand request =
        new GetCommand(this.topic, this.group, partition, offset, maxSize, opaque);
    this.getProcessor.handleRequest(request, this.conn);
    this.mocksControl.verify();
    assertEquals(1, this.statsManager.getCmdGetMiss());
    assertEquals(1, this.statsManager.getCmdGets());
    assertEquals(0, this.statsManager.getCmdOffsets());
  }
Beispiel #18
0
  @Test
  public void testHandleRequestMaxOffset() throws Exception {
    // 从实际最大的offset开始订阅
    final int partition = 1;
    final int opaque = 0;
    final int maxSize = 1024;
    final long offset = Long.MAX_VALUE;
    final long realMaxOffset = 100;
    final MessageStore store = this.mocksControl.createMock(MessageStore.class);
    EasyMock.expect(this.storeManager.getMessageStore(this.topic, partition)).andReturn(store);
    EasyMock.expect(store.slice(offset, maxSize)).andReturn(null);
    this.conn.response(new BooleanCommand(opaque, HttpStatus.Moved, String.valueOf(realMaxOffset)));
    EasyMock.expect(store.getMaxOffset()).andReturn(realMaxOffset);
    EasyMock.expectLastCall();
    this.mocksControl.replay();

    final GetCommand request =
        new GetCommand(this.topic, this.group, partition, offset, maxSize, opaque);
    this.getProcessor.handleRequest(request, this.conn);
    this.mocksControl.verify();
    assertEquals(1, this.statsManager.getCmdGetMiss());
    assertEquals(1, this.statsManager.getCmdGets());
    assertEquals(1, this.statsManager.getCmdOffsets());
  }
  @Test
  public void testFailureJob2() throws Exception {

    final AtomicLong numJobsComplete = new AtomicLong(0);

    /** ** Setup mockFlow1 *** */
    final Capture<FlowCallback> flow1Callback = new Capture<FlowCallback>();
    mockFlow1.execute(EasyMock.eq(props), EasyMock.capture(flow1Callback));
    EasyMock.expectLastCall()
        .andAnswer(
            new IAnswer<Void>() {
              @Override
              public Void answer() throws Throwable {
                Assert.assertEquals(Status.RUNNING, flow.getStatus());
                Assert.assertEquals(1, numJobsComplete.incrementAndGet());

                flow1Callback.getValue().completed(Status.SUCCEEDED);

                return null;
              }
            })
        .once();

    EasyMock.expect(mockFlow1.getStatus()).andReturn(Status.SUCCEEDED).times(2);
    EasyMock.expect(mockFlow1.getExceptions()).andReturn(emptyExceptions).times(1);

    /** ** Setup mockFlow2 *** */
    final Capture<FlowCallback> flow2Callback = new Capture<FlowCallback>();
    mockFlow2.execute(EasyMock.eq(props), EasyMock.capture(flow2Callback));
    EasyMock.expectLastCall()
        .andAnswer(
            new IAnswer<Void>() {
              @Override
              public Void answer() throws Throwable {
                Assert.assertEquals(Status.RUNNING, flow.getStatus());
                Assert.assertEquals(2, numJobsComplete.incrementAndGet());

                flow2Callback.getValue().completed(Status.FAILED);

                return null;
              }
            })
        .once();

    EasyMock.expect(mockFlow2.getStatus())
        .andAnswer(
            new IAnswer<Status>() {
              private volatile AtomicInteger count = new AtomicInteger(0);

              @Override
              public Status answer() throws Throwable {
                switch (count.getAndIncrement()) {
                  case 0:
                    return Status.READY;
                  case 1:
                    return Status.FAILED;
                  default:
                    Assert.fail("mockFlow2.getStatus() should only be called 2 times.");
                }
                return null;
              }
            })
        .times(2);

    final RuntimeException e1 = new RuntimeException();
    final RuntimeException e2 = new RuntimeException();

    final Map<String, Throwable> e1s = new HashMap<String, Throwable>();
    e1s.put("e1", e1);
    e1s.put("e2", e2);

    EasyMock.expect(mockFlow2.getExceptions()).andReturn(e1s).times(1);
    EasyMock.expect(props.equalsProps(props)).andReturn(true).once();

    EasyMock.replay(mockFlow1, mockFlow2, props);

    /** ** Start the test *** */
    AtomicBoolean callbackRan = new AtomicBoolean(false);
    flow.execute(
        props,
        new OneCallFlowCallback(callbackRan) {
          @Override
          public void theCallback(Status status) {
            Assert.assertEquals(Status.FAILED, status);
          }
        });

    Assert.assertTrue("Callback wasn't run.", callbackRan.get());
    Assert.assertEquals(Status.FAILED, flow.getStatus());
    Assert.assertEquals(e1s, flow.getExceptions());

    callbackRan = new AtomicBoolean(false);
    flow.execute(
        props,
        new OneCallFlowCallback(callbackRan) {
          @Override
          protected void theCallback(Status status) {
            Assert.assertEquals(Status.FAILED, status);
            Assert.assertEquals(2, numJobsComplete.get());
          }
        });

    Assert.assertTrue("Callback wasn't run.", callbackRan.get());
    Assert.assertEquals(Status.FAILED, flow.getStatus());
    Assert.assertEquals(e1s, flow.getExceptions());

    Assert.assertTrue("Expected to be able to reset the flow", flow.reset());
    Assert.assertEquals(Status.READY, flow.getStatus());
    Assert.assertEquals(emptyExceptions, flow.getExceptions());
  }
 private void mockCommitOffsets(
     final String group, final Collection<TopicPartitionRegInfo> arrayList) {
   this.offsetStorage.commitOffset(group, arrayList);
   EasyMock.expectLastCall();
 }
Beispiel #21
0
 public SmsBuilder fromStandardChartered() {
   EasyMock.expect(anySmsMessage.getDisplayOriginatingAddress()).andReturn("DM-StanChrt");
   EasyMock.expectLastCall().anyTimes();
   return this;
 }
 private void mockConnect(final String url) throws NotifyRemotingException, InterruptedException {
   this.remotingClient.connect(url);
   EasyMock.expectLastCall();
   this.remotingClient.awaitReadyInterrupt(url);
   EasyMock.expectLastCall();
 }
Beispiel #23
0
 public SmsBuilder fromSourceOtherThanTheBank() {
   EasyMock.expect(anySmsMessage.getDisplayOriginatingAddress()).andReturn("TA-Adiclub");
   EasyMock.expectLastCall().anyTimes();
   return this;
 }
  @Test
  public void testFailureJob1() throws Exception {

    final AtomicLong numJobsComplete = new AtomicLong(0);

    /** ** Setup mockFlow1 *** */
    final Capture<FlowCallback> flow1Callback = new Capture<FlowCallback>();
    mockFlow1.execute(EasyMock.eq(props), EasyMock.capture(flow1Callback));
    EasyMock.expectLastCall()
        .andAnswer(
            new IAnswer<Void>() {
              @Override
              public Void answer() throws Throwable {
                Assert.assertEquals(Status.RUNNING, flow.getStatus());
                Assert.assertEquals(1, numJobsComplete.incrementAndGet());

                flow1Callback.getValue().completed(Status.FAILED);

                return null;
              }
            })
        .once();

    EasyMock.expect(mockFlow1.getStatus()).andReturn(Status.FAILED).times(1);
    EasyMock.expect(mockFlow1.getExceptions()).andReturn(theExceptions).times(1);

    EasyMock.expect(props.equalsProps(props)).andReturn(true).once();

    /** ** Setup mockFlow2 *** */
    EasyMock.expect(mockFlow2.getExceptions()).andReturn(emptyExceptions).times(1);
    EasyMock.replay(mockFlow1, mockFlow2, props);

    /** ** Start the test *** */
    AtomicBoolean callbackRan = new AtomicBoolean(false);
    flow.execute(
        props,
        new OneCallFlowCallback(callbackRan) {
          @Override
          public void theCallback(Status status) {
            Assert.assertEquals(Status.FAILED, status);
          }
        });

    Assert.assertTrue("Callback wasn't run.", callbackRan.get());
    Assert.assertEquals(Status.FAILED, flow.getStatus());
    Assert.assertEquals(theExceptions, flow.getExceptions());

    callbackRan = new AtomicBoolean(false);
    flow.execute(
        props,
        new OneCallFlowCallback(callbackRan) {
          @Override
          protected void theCallback(Status status) {
            Assert.assertEquals(Status.FAILED, status);
          }
        });

    Assert.assertTrue("Callback wasn't run.", callbackRan.get());
    Assert.assertEquals(Status.FAILED, flow.getStatus());
    Assert.assertEquals(theExceptions, flow.getExceptions());

    Assert.assertTrue("Expected to be able to reset the flow", flow.reset());
    Assert.assertEquals(Status.READY, flow.getStatus());
    Assert.assertEquals(emptyExceptions, flow.getExceptions());
  }
 private void mockAddFetchRequest(final FetchRequest fetchRequest) {
   this.fetchManager.addFetchRequest(fetchRequest);
   EasyMock.expectLastCall();
 }
  @Test
  public void testSanity() throws Exception {
    final AtomicLong numJobsComplete = new AtomicLong(0);

    /** ** Setup mockFlow1 *** */
    final Capture<FlowCallback> flow1Callback = new Capture<FlowCallback>();
    mockFlow1.execute(EasyMock.eq(props), EasyMock.capture(flow1Callback));
    EasyMock.expectLastCall()
        .andAnswer(
            new IAnswer<Void>() {
              @Override
              public Void answer() throws Throwable {
                Assert.assertEquals(Status.RUNNING, flow.getStatus());
                Assert.assertEquals(1, numJobsComplete.incrementAndGet());

                flow1Callback.getValue().completed(Status.SUCCEEDED);

                Assert.assertEquals(Status.RUNNING, flow.getStatus());

                return null;
              }
            })
        .once();

    Props mockFlow1Props = new Props();
    mockFlow1Props.put("1", "1");
    mockFlow1Props.put("2", "1");

    EasyMock.expect(mockFlow1.getStatus()).andReturn(Status.SUCCEEDED).times(2);
    EasyMock.expect(mockFlow1.getReturnProps()).andReturn(mockFlow1Props).once();

    /** ** Setup mockFlow2 *** */
    final Capture<FlowCallback> flow2Callback = new Capture<FlowCallback>();
    mockFlow2.execute(EasyMock.eq(props), EasyMock.capture(flow2Callback));
    EasyMock.expectLastCall()
        .andAnswer(
            new IAnswer<Void>() {
              @Override
              public Void answer() throws Throwable {
                Assert.assertEquals(Status.RUNNING, flow.getStatus());
                Assert.assertEquals(2, numJobsComplete.incrementAndGet());

                flow2Callback.getValue().completed(Status.SUCCEEDED);

                Assert.assertEquals(Status.SUCCEEDED, flow.getStatus());

                return null;
              }
            })
        .once();

    EasyMock.expect(mockFlow2.getStatus())
        .andAnswer(
            new IAnswer<Status>() {
              private volatile AtomicInteger count = new AtomicInteger(0);

              @Override
              public Status answer() throws Throwable {
                switch (count.getAndIncrement()) {
                  case 0:
                    return Status.READY;
                  case 1:
                    return Status.SUCCEEDED;
                  default:
                    Assert.fail("mockFlow2.getStatus() should only be called 2 times.");
                }
                return null;
              }
            })
        .times(2);

    Props mockFlow2Props = new Props();
    mockFlow2Props.put("2", "2");
    mockFlow2Props.put("3", "2");
    EasyMock.expect(mockFlow2.getReturnProps()).andReturn(mockFlow2Props).once();

    EasyMock.expect(props.equalsProps(props)).andReturn(true).once();

    EasyMock.replay(mockFlow1, mockFlow2, props);

    /** ** Start the test *** */
    AtomicBoolean callbackRan = new AtomicBoolean(false);
    flow.execute(
        props,
        new OneCallFlowCallback(callbackRan) {
          @Override
          public void theCallback(Status status) {
            Assert.assertEquals(Status.SUCCEEDED, status);
            Assert.assertEquals(2, numJobsComplete.get());
          }
        });

    Assert.assertTrue("Callback wasn't run.", callbackRan.get());
    Assert.assertEquals(Status.SUCCEEDED, flow.getStatus());
    Assert.assertEquals(emptyExceptions, flow.getExceptions());
    Assert.assertEquals(props, flow.getParentProps());

    callbackRan = new AtomicBoolean(false);
    flow.execute(
        props,
        new OneCallFlowCallback(callbackRan) {
          @Override
          protected void theCallback(Status status) {
            Assert.assertEquals(Status.SUCCEEDED, status);
            Assert.assertEquals(2, numJobsComplete.get());
          }
        });

    Assert.assertTrue("Callback wasn't run.", callbackRan.get());
    Assert.assertEquals(Status.SUCCEEDED, flow.getStatus());
    Assert.assertEquals(emptyExceptions, flow.getExceptions());

    Props retProps = flow.getReturnProps();
    Assert.assertEquals(3, retProps.size());
    Assert.assertEquals("1", retProps.get("1"));
    Assert.assertEquals("2", retProps.get("2"));
    Assert.assertEquals("2", retProps.get("3"));

    EasyMock.verify(props);
    EasyMock.reset(props);

    EasyMock.expect(props.equalsProps(props)).andReturn(false).once();

    EasyMock.replay(props);

    boolean exceptionThrown = false;
    try {
      flow.execute(
          props,
          new FlowCallback() {
            @Override
            public void progressMade() {}

            @Override
            public void completed(Status status) {}
          });
    } catch (IllegalArgumentException e) {
      exceptionThrown = true;
    }

    Assert.assertTrue(
        "Expected an IllegalArgumentException to be thrown because props weren't the same.",
        exceptionThrown);
  }
 private void mockConnectCloseAnyTimes(final String url)
     throws NotifyRemotingException, InterruptedException {
   this.remotingClient.close(url, false);
   EasyMock.expectLastCall().anyTimes();
 }
  @Test
  public void testAllCallbacksCalled() throws Exception {
    final AtomicLong numJobsComplete = new AtomicLong(0);
    final AtomicBoolean executeCallWhileStateWasRunningHadItsCallbackCalled =
        new AtomicBoolean(false);

    /** ** Setup mockFlow1 *** */
    final Capture<FlowCallback> flow1Callback = new Capture<FlowCallback>();
    mockFlow1.execute(EasyMock.eq(props), EasyMock.capture(flow1Callback));
    EasyMock.expectLastCall()
        .andAnswer(
            new IAnswer<Void>() {
              @Override
              public Void answer() throws Throwable {
                Assert.assertEquals(Status.RUNNING, flow.getStatus());
                Assert.assertEquals(1, numJobsComplete.incrementAndGet());

                flow.execute(
                    props,
                    new OneCallFlowCallback(executeCallWhileStateWasRunningHadItsCallbackCalled) {
                      @Override
                      protected void theCallback(Status status) {}
                    });

                flow1Callback.getValue().completed(Status.SUCCEEDED);

                return null;
              }
            })
        .once();

    EasyMock.expect(mockFlow1.getStatus()).andReturn(Status.SUCCEEDED).times(2);

    /** ** Setup mockFlow2 *** */
    final Capture<FlowCallback> flow2Callback = new Capture<FlowCallback>();
    mockFlow2.execute(EasyMock.eq(props), EasyMock.capture(flow2Callback));
    EasyMock.expectLastCall()
        .andAnswer(
            new IAnswer<Void>() {
              @Override
              public Void answer() throws Throwable {
                Assert.assertEquals(Status.RUNNING, flow.getStatus());
                Assert.assertEquals(2, numJobsComplete.incrementAndGet());

                flow2Callback.getValue().completed(Status.SUCCEEDED);

                return null;
              }
            })
        .once();

    EasyMock.expect(mockFlow2.getStatus())
        .andAnswer(
            new IAnswer<Status>() {
              private volatile AtomicInteger count = new AtomicInteger(0);

              @Override
              public Status answer() throws Throwable {
                switch (count.getAndIncrement()) {
                  case 0:
                    return Status.READY;
                  case 1:
                    return Status.SUCCEEDED;
                  default:
                    Assert.fail("mockFlow2.getStatus() should only be called 2 times.");
                }
                return null;
              }
            })
        .times(2);

    EasyMock.expect(mockFlow1.getReturnProps()).andReturn(new Props()).once();
    EasyMock.expect(mockFlow2.getReturnProps()).andReturn(new Props()).once();

    EasyMock.expect(props.equalsProps(props)).andReturn(true).times(2);

    EasyMock.replay(mockFlow1, mockFlow2, props);

    /** ** Start the test *** */
    AtomicBoolean callbackRan = new AtomicBoolean(false);
    flow.execute(
        props,
        new OneCallFlowCallback(callbackRan) {
          @Override
          public void theCallback(Status status) {
            Assert.assertEquals(Status.SUCCEEDED, status);
            Assert.assertEquals(2, numJobsComplete.get());
          }
        });

    Assert.assertTrue("Callback wasn't run.", callbackRan.get());
    Assert.assertEquals(Status.SUCCEEDED, flow.getStatus());
    Assert.assertTrue(
        "mockFlow1, upon completion, sends another execute() call to the flow.  "
            + "The callback from that execute call was apparently not called.",
        executeCallWhileStateWasRunningHadItsCallbackCalled.get());
    Assert.assertEquals(emptyExceptions, flow.getExceptions());

    callbackRan = new AtomicBoolean(false);
    flow.execute(
        props,
        new OneCallFlowCallback(callbackRan) {
          @Override
          protected void theCallback(Status status) {
            Assert.assertEquals(Status.SUCCEEDED, status);
            Assert.assertEquals(2, numJobsComplete.get());
          }
        });

    Assert.assertTrue("Callback wasn't run.", callbackRan.get());
    Assert.assertEquals(Status.SUCCEEDED, flow.getStatus());
    Assert.assertEquals(emptyExceptions, flow.getExceptions());
  }