src/test/java/net/pterodactylus/fcp/quelaton/FcpReplySequenceTest.java

   1 package net.pterodactylus.fcp.quelaton;
   2
   3 import static org.hamcrest.MatcherAssert.assertThat;
   4 import static org.hamcrest.Matchers.empty;
   5 import static org.hamcrest.Matchers.is;
   6 import static org.hamcrest.Matchers.sameInstance;
   7 import static org.mockito.Mockito.mock;
   8 import static org.mockito.Mockito.verify;
   9
  10 import java.io.IOException;
  11 import java.util.concurrent.ExecutionException;
  12 import java.util.concurrent.ExecutorService;
  13 import java.util.concurrent.Executors;
  14 import java.util.concurrent.Future;
  15 import java.util.concurrent.atomic.AtomicBoolean;
  16 import java.util.concurrent.atomic.AtomicReference;
  17
  18 import net.pterodactylus.fcp.AllData;
  19 import net.pterodactylus.fcp.BaseMessage;
  20 import net.pterodactylus.fcp.CloseConnectionDuplicateClientName;
  21 import net.pterodactylus.fcp.ConfigData;
  22 import net.pterodactylus.fcp.DataFound;
  23 import net.pterodactylus.fcp.EndListPeerNotes;
  24 import net.pterodactylus.fcp.EndListPeers;
  25 import net.pterodactylus.fcp.EndListPersistentRequests;
  26 import net.pterodactylus.fcp.FCPPluginReply;
  27 import net.pterodactylus.fcp.FcpConnection;
  28 import net.pterodactylus.fcp.FcpMessage;
  29 import net.pterodactylus.fcp.FinishedCompression;
  30 import net.pterodactylus.fcp.GetFailed;
  31 import net.pterodactylus.fcp.IdentifierCollision;
  32 import net.pterodactylus.fcp.NodeData;
  33 import net.pterodactylus.fcp.NodeHello;
  34 import net.pterodactylus.fcp.Peer;
  35 import net.pterodactylus.fcp.PeerNote;
  36 import net.pterodactylus.fcp.PeerRemoved;
  37 import net.pterodactylus.fcp.PersistentGet;
  38 import net.pterodactylus.fcp.PersistentPut;
  39 import net.pterodactylus.fcp.PersistentPutDir;
  40 import net.pterodactylus.fcp.PersistentRequestModified;
  41 import net.pterodactylus.fcp.PersistentRequestRemoved;
  42 import net.pterodactylus.fcp.PluginInfo;
  43 import net.pterodactylus.fcp.ProtocolError;
  44 import net.pterodactylus.fcp.PutFailed;
  45 import net.pterodactylus.fcp.PutFetchable;
  46 import net.pterodactylus.fcp.PutSuccessful;
  47 import net.pterodactylus.fcp.ReceivedBookmarkFeed;
  48 import net.pterodactylus.fcp.SSKKeypair;
  49 import net.pterodactylus.fcp.SentFeed;
  50 import net.pterodactylus.fcp.SimpleProgress;
  51 import net.pterodactylus.fcp.StartedCompression;
  52 import net.pterodactylus.fcp.SubscribedUSKUpdate;
  53 import net.pterodactylus.fcp.TestDDAComplete;
  54 import net.pterodactylus.fcp.TestDDAReply;
  55 import net.pterodactylus.fcp.URIGenerated;
  56 import net.pterodactylus.fcp.UnknownNodeIdentifier;
  57 import net.pterodactylus.fcp.UnknownPeerNoteType;
  58
  59 import org.junit.Test;
  60
  61 /**
  62  * Unit test for {@link FcpReplySequence}.
  63  *
  64  * @author <a href="bombe@freenetproject.org">David ‘Bombe’ Roden</a>
  65  */
  66 public class FcpReplySequenceTest {
  67
  68         private final FcpConnection fcpConnection = mock(FcpConnection.class);
  69         private final ExecutorService executorService = Executors.newSingleThreadExecutor();
  70         private final TestFcpReplySequence replySequence = new TestFcpReplySequence(executorService, fcpConnection);
  71         private final FcpMessage fcpMessage = new FcpMessage("Test");
  72
  73         @Test
  74         public void canSendMessage() throws IOException, ExecutionException, InterruptedException {
  75                 FcpReplySequence replySequence = createBasicReplySequence();
  76                 replySequence.send(fcpMessage).get();
  77                 verify(fcpConnection).sendMessage(fcpMessage);
  78         }
  79
  80         private FcpReplySequence createBasicReplySequence() {
  81                 return new FcpReplySequence(executorService, fcpConnection) {
  82                                 @Override
  83                                 protected boolean isFinished() {
  84                                         return true;
  85                                 }
  86                         };
  87         }
  88
  89         @Test
  90         public void sendingAMessageRegistersTheWaiterAsFcpListener() throws IOException {
  91                 FcpReplySequence replySequence = createBasicReplySequence();
  92                 replySequence.send(fcpMessage);
  93                 verify(fcpConnection).addFcpListener(replySequence);
  94         }
  95
  96         @Test
  97         public void closingTheReplyWaiterRemovesTheFcpListener() throws IOException {
  98                 FcpReplySequence replySequence = createBasicReplySequence();
  99                 replySequence.send(fcpMessage);
 100                 replySequence.close();
 101                 verify(fcpConnection).removeFcpListener(replySequence);
 102         }
 103
 104         private <M extends BaseMessage> void waitForASpecificMessage(MessageReceiver<M> messageReceiver, Class<M> messageClass, MessageCreator<M> messageCreator) throws IOException, InterruptedException, ExecutionException {
 105                 waitForASpecificMessage(messageReceiver, messageCreator.create(new FcpMessage(messageClass.getSimpleName())));
 106         }
 107
 108         private <M extends BaseMessage> void waitForASpecificMessage(MessageReceiver<M> messageReceiver, M message) throws IOException, InterruptedException, ExecutionException {
 109                 replySequence.setExpectedMessage(message.getName());
 110                 Future<Boolean> result = replySequence.send(fcpMessage);
 111                 messageReceiver.receiveMessage(fcpConnection, message);
 112                 assertThat(result.get(), is(true));
 113         }
 114
 115         private <M extends BaseMessage> M createMessage(Class<M> messageClass, MessageCreator<M> messageCreator) {
 116                 return messageCreator.create(new FcpMessage(messageClass.getSimpleName()));
 117         }
 118
 119         private interface MessageCreator<M extends BaseMessage> {
 120
 121                 M create(FcpMessage fcpMessage);
 122
 123         }
 124
 125         @Test
 126         public void waitingForNodeHelloWorks() throws IOException, ExecutionException, InterruptedException {
 127                 waitForASpecificMessage(replySequence::receivedNodeHello, NodeHello.class, NodeHello::new);
 128         }
 129
 130         @Test(expected = ExecutionException.class)
 131         public void waitingForConnectionClosedDuplicateClientNameWorks() throws IOException, ExecutionException, InterruptedException {
 132                 replySequence.setExpectedMessage("");
 133                 Future<Boolean> result = replySequence.send(fcpMessage);
 134                 replySequence.receivedCloseConnectionDuplicateClientName(fcpConnection,
 135                         new CloseConnectionDuplicateClientName(new FcpMessage("CloseConnectionDuplicateClientName")));
 136                 result.get();
 137         }
 138
 139         @Test
 140         public void waitingForSSKKeypairWorks() throws InterruptedException, ExecutionException, IOException {
 141                 waitForASpecificMessage(replySequence::receivedSSKKeypair, SSKKeypair.class, SSKKeypair::new);
 142         }
 143
 144         @Test
 145         public void waitForPeerWorks() throws InterruptedException, ExecutionException, IOException {
 146                 waitForASpecificMessage(replySequence::receivedPeer, Peer.class, Peer::new);
 147         }
 148
 149         @Test
 150         public void waitForEndListPeersWorks() throws InterruptedException, ExecutionException, IOException {
 151                 waitForASpecificMessage(replySequence::receivedEndListPeers, EndListPeers.class, EndListPeers::new);
 152         }
 153
 154         @Test
 155         public void waitForPeerNoteWorks() throws InterruptedException, ExecutionException, IOException {
 156                 waitForASpecificMessage(replySequence::receivedPeerNote, PeerNote.class, PeerNote::new);
 157         }
 158
 159         @Test
 160         public void waitForEndListPeerNotesWorks() throws InterruptedException, ExecutionException, IOException {
 161                 waitForASpecificMessage(replySequence::receivedEndListPeerNotes, EndListPeerNotes.class, EndListPeerNotes::new);
 162         }
 163
 164         @Test
 165         public void waitForPeerRemovedWorks() throws InterruptedException, ExecutionException, IOException {
 166                 waitForASpecificMessage(replySequence::receivedPeerRemoved, PeerRemoved.class, PeerRemoved::new);
 167         }
 168
 169         @Test
 170         public void waitForNodeDataWorks() throws InterruptedException, ExecutionException, IOException {
 171                 waitForASpecificMessage(replySequence::receivedNodeData, new NodeData(
 172                         new FcpMessage("NodeData").put("ark.pubURI", "")
 173                                         .put("ark.number", "0")
 174                                         .put("auth.negTypes", "")
 175                                         .put("version", "0,0,0,0")
 176                                         .put("lastGoodVersion", "0,0,0,0")));
 177         }
 178
 179         @Test
 180         public void waitForTestDDAReplyWorks() throws InterruptedException, ExecutionException, IOException {
 181                 waitForASpecificMessage(replySequence::receivedTestDDAReply, TestDDAReply.class, TestDDAReply::new);
 182         }
 183
 184         @Test
 185         public void waitForTestDDACompleteWorks() throws InterruptedException, ExecutionException, IOException {
 186                 waitForASpecificMessage(replySequence::receivedTestDDAComplete, TestDDAComplete.class, TestDDAComplete::new);
 187         }
 188
 189         @Test
 190         public void waitForPersistentGetWorks() throws InterruptedException, ExecutionException, IOException {
 191                 waitForASpecificMessage(replySequence::receivedPersistentGet, PersistentGet.class, PersistentGet::new);
 192         }
 193
 194         @Test
 195         public void waitForPersistentPutWorks() throws InterruptedException, ExecutionException, IOException {
 196                 waitForASpecificMessage(replySequence::receivedPersistentPut, PersistentPut.class, PersistentPut::new);
 197         }
 198
 199         @Test
 200         public void waitForEndListPersistentRequestsWorks() throws InterruptedException, ExecutionException, IOException {
 201                 waitForASpecificMessage(replySequence::receivedEndListPersistentRequests, EndListPersistentRequests.class, EndListPersistentRequests::new);
 202         }
 203
 204         @Test
 205         public void waitForURIGeneratedWorks() throws InterruptedException, ExecutionException, IOException {
 206                 waitForASpecificMessage(replySequence::receivedURIGenerated, URIGenerated.class, URIGenerated::new);
 207         }
 208
 209         @Test
 210         public void waitForDataFoundWorks() throws InterruptedException, ExecutionException, IOException {
 211                 waitForASpecificMessage(replySequence::receivedDataFound, DataFound.class, DataFound::new);
 212         }
 213
 214         @Test
 215         public void waitForAllDataWorks() throws InterruptedException, ExecutionException, IOException {
 216                 waitForASpecificMessage(replySequence::receivedAllData, new AllData(new FcpMessage("AllData"), null));
 217         }
 218
 219         @Test
 220         public void waitForSimpleProgressWorks() throws InterruptedException, ExecutionException, IOException {
 221                 waitForASpecificMessage(replySequence::receivedSimpleProgress, SimpleProgress.class, SimpleProgress::new);
 222         }
 223
 224         @Test
 225         public void waitForStartedCompressionWorks() throws InterruptedException, ExecutionException, IOException {
 226                 waitForASpecificMessage(replySequence::receivedStartedCompression, StartedCompression.class, StartedCompression::new);
 227         }
 228
 229         @Test
 230         public void waitForFinishedCompressionWorks() throws InterruptedException, ExecutionException, IOException {
 231                 waitForASpecificMessage(replySequence::receivedFinishedCompression, FinishedCompression.class, FinishedCompression::new);
 232         }
 233
 234         @Test
 235         public void waitForUnknownPeerNoteTypeWorks() throws InterruptedException, ExecutionException, IOException {
 236                 waitForASpecificMessage(replySequence::receivedUnknownPeerNoteType, UnknownPeerNoteType.class, UnknownPeerNoteType::new);
 237         }
 238
 239         @Test
 240         public void waitForUnknownNodeIdentifierWorks() throws InterruptedException, ExecutionException, IOException {
 241                 waitForASpecificMessage(replySequence::receivedUnknownNodeIdentifier, UnknownNodeIdentifier.class, UnknownNodeIdentifier::new);
 242         }
 243
 244         @Test
 245         public void waitForConfigDataWorks() throws InterruptedException, ExecutionException, IOException {
 246                 waitForASpecificMessage(replySequence::receivedConfigData, ConfigData.class, ConfigData::new);
 247         }
 248
 249         @Test
 250         public void waitForGetFailedWorks() throws InterruptedException, ExecutionException, IOException {
 251                 waitForASpecificMessage(replySequence::receivedGetFailed, GetFailed.class, GetFailed::new);
 252         }
 253
 254         @Test
 255         public void waitForPutFailedWorks() throws InterruptedException, ExecutionException, IOException {
 256                 waitForASpecificMessage(replySequence::receivedPutFailed, PutFailed.class, PutFailed::new);
 257         }
 258
 259         @Test
 260         public void waitForIdentifierCollisionWorks() throws InterruptedException, ExecutionException, IOException {
 261                 waitForASpecificMessage(replySequence::receivedIdentifierCollision, IdentifierCollision.class, IdentifierCollision::new);
 262         }
 263
 264         @Test
 265         public void waitForPersistentPutDirWorks() throws InterruptedException, ExecutionException, IOException {
 266                 waitForASpecificMessage(replySequence::receivedPersistentPutDir, PersistentPutDir.class, PersistentPutDir::new);
 267         }
 268
 269         @Test
 270         public void waitForPersistentRequestRemovedWorks() throws InterruptedException, ExecutionException, IOException {
 271                 waitForASpecificMessage(replySequence::receivedPersistentRequestRemoved, PersistentRequestRemoved.class, PersistentRequestRemoved::new);
 272         }
 273
 274         @Test
 275         public void waitForSubscribedUSKUpdateWorks() throws InterruptedException, ExecutionException, IOException {
 276                 waitForASpecificMessage(replySequence::receivedSubscribedUSKUpdate, SubscribedUSKUpdate.class, SubscribedUSKUpdate::new);
 277         }
 278
 279         @Test
 280         public void waitForPluginInfoWorks() throws InterruptedException, ExecutionException, IOException {
 281                 waitForASpecificMessage(replySequence::receivedPluginInfo, PluginInfo.class, PluginInfo::new);
 282         }
 283
 284         @Test
 285         public void waitForFCPPluginReply() throws InterruptedException, ExecutionException, IOException {
 286                 waitForASpecificMessage(replySequence::receivedFCPPluginReply, new FCPPluginReply(new FcpMessage("FCPPluginReply"), null));
 287         }
 288
 289         @Test
 290         public void waitForPersistentRequestModifiedWorks() throws InterruptedException, ExecutionException, IOException {
 291                 waitForASpecificMessage(replySequence::receivedPersistentRequestModified, PersistentRequestModified.class, PersistentRequestModified::new);
 292         }
 293
 294         @Test
 295         public void waitForPutSuccessfulWorks() throws InterruptedException, ExecutionException, IOException {
 296                 waitForASpecificMessage(replySequence::receivedPutSuccessful, PutSuccessful.class, PutSuccessful::new);
 297         }
 298
 299         @Test
 300         public void waitForPutFetchableWorks() throws InterruptedException, ExecutionException, IOException {
 301                 waitForASpecificMessage(replySequence::receivedPutFetchable, PutFetchable.class, PutFetchable::new);
 302         }
 303
 304         @Test
 305         public void waitForSentFeedWorks() throws InterruptedException, ExecutionException, IOException {
 306                 waitForASpecificMessage(replySequence::receivedSentFeed, SentFeed.class, SentFeed::new);
 307         }
 308
 309         @Test
 310         public void waitForReceivedBookmarkFeedWorks() throws InterruptedException, ExecutionException, IOException {
 311                 waitForASpecificMessage(replySequence::receivedBookmarkFeed, ReceivedBookmarkFeed.class, ReceivedBookmarkFeed::new);
 312         }
 313
 314         @Test
 315         public void waitForProtocolErrorWorks() throws InterruptedException, ExecutionException, IOException {
 316                 waitForASpecificMessage(replySequence::receivedProtocolError, ProtocolError.class, ProtocolError::new);
 317         }
 318
 319         @Test
 320         public void waitForUnknownMessageWorks() throws IOException, ExecutionException, InterruptedException {
 321                 replySequence.setExpectedMessage("SomeFcpMessage");
 322                 Future<Boolean> result = replySequence.send(fcpMessage);
 323                 replySequence.receivedMessage(fcpConnection, new FcpMessage("SomeFcpMessage"));
 324                 assertThat(result.get(), is(true));
 325         }
 326
 327         @Test
 328         public void waitingForMultipleMessagesWorks() throws IOException, ExecutionException, InterruptedException {
 329                 TestFcpReplySequence replySequence = new TestFcpReplySequence(executorService, fcpConnection) {
 330                         private final AtomicBoolean gotPutFailed = new AtomicBoolean();
 331                         private final AtomicBoolean gotGetFailed = new AtomicBoolean();
 332
 333                         @Override
 334                         protected boolean isFinished() {
 335                                 return gotPutFailed.get() && gotGetFailed.get();
 336                         }
 337
 338                         @Override
 339                         protected Boolean getResult() {
 340                                 return isFinished();
 341                         }
 342
 343                         @Override
 344                         protected void consumePutFailed(PutFailed putFailed) {
 345                                 gotPutFailed.set(true);
 346                         }
 347
 348                         @Override
 349                         protected void consumeGetFailed(GetFailed getFailed) {
 350                                 gotGetFailed.set(true);
 351                         }
 352                 };
 353                 Future<?> result = replySequence.send(fcpMessage);
 354                 assertThat(result.isDone(), is(false));
 355                 replySequence.receivedGetFailed(fcpConnection, new GetFailed(new FcpMessage("GetFailed")));
 356                 assertThat(result.isDone(), is(false));
 357                 replySequence.receivedPutFailed(fcpConnection, new PutFailed(new FcpMessage("PutFailed")));
 358                 assertThat(result.get(), is(true));
 359         }
 360
 361         @Test
 362         public void waitingForConnectionClosureWorks() throws IOException, ExecutionException, InterruptedException {
 363                 replySequence.setExpectedMessage("none");
 364                 Future<Boolean> result = replySequence.send(fcpMessage);
 365                 Throwable throwable = new Throwable();
 366                 replySequence.connectionClosed(fcpConnection, throwable);
 367                 try {
 368                         result.get();
 369                 } catch (ExecutionException e) {
 370                         Throwable t = e;
 371                         while (t.getCause() != null) {
 372                                 t = t.getCause();
 373                         }
 374                         assertThat(t, sameInstance(throwable));
 375                 }
 376         }
 377
 378         @FunctionalInterface
 379         private interface MessageReceiver<M> {
 380
 381                 void receiveMessage(FcpConnection fcpConnection, M message);
 382
 383         }
 384
 385         private static class TestFcpReplySequence extends FcpReplySequence<Boolean> {
 386
 387                 private final AtomicReference<String> gotMessage = new AtomicReference<>();
 388                 private final AtomicReference<String> expectedMessage = new AtomicReference<>();
 389
 390                 public TestFcpReplySequence(ExecutorService executorService, FcpConnection fcpConnection) {
 391                         super(executorService, fcpConnection);
 392                 }
 393
 394                 public void setExpectedMessage(String expectedMessage) {
 395                         this.expectedMessage.set(expectedMessage);
 396                 }
 397
 398                 @Override
 399                 protected boolean isFinished() {
 400                         return getResult();
 401                 }
 402
 403                 @Override
 404                 protected Boolean getResult() {
 405                         return expectedMessage.get().equals(gotMessage.get());
 406                 }
 407
 408                 @Override
 409                 protected void consumeNodeHello(NodeHello nodeHello) {
 410                         gotMessage.set(nodeHello.getName());
 411                 }
 412
 413                 @Override
 414                 protected void consumeSSKKeypair(SSKKeypair sskKeypair) {
 415                         gotMessage.set(sskKeypair.getName());
 416                 }
 417
 418                 @Override
 419                 protected void consumePeer(Peer peer) {
 420                         gotMessage.set(peer.getName());
 421                 }
 422
 423                 @Override
 424                 protected void consumeEndListPeers(EndListPeers endListPeers) {
 425                         gotMessage.set(endListPeers.getName());
 426                 }
 427
 428                 @Override
 429                 protected void consumePeerNote(PeerNote peerNote) {
 430                         gotMessage.set(peerNote.getName());
 431                 }
 432
 433                 @Override
 434                 protected void consumeEndListPeerNotes(EndListPeerNotes endListPeerNotes) {
 435                         gotMessage.set(endListPeerNotes.getName());
 436                 }
 437
 438                 @Override
 439                 protected void consumePeerRemoved(PeerRemoved peerRemoved) {
 440                         gotMessage.set(peerRemoved.getName());
 441                 }
 442
 443                 @Override
 444                 protected void consumeNodeData(NodeData nodeData) {
 445                         gotMessage.set(nodeData.getName());
 446                 }
 447
 448                 @Override
 449                 protected void consumeTestDDAReply(TestDDAReply testDDAReply) {
 450                         gotMessage.set(testDDAReply.getName());
 451                 }
 452
 453                 @Override
 454                 protected void consumeTestDDAComplete(TestDDAComplete testDDAComplete) {
 455                         gotMessage.set(testDDAComplete.getName());
 456                 }
 457
 458                 @Override
 459                 protected void consumePersistentGet(PersistentGet persistentGet) {
 460                         gotMessage.set(persistentGet.getName());
 461                 }
 462
 463                 @Override
 464                 protected void consumePersistentPut(PersistentPut persistentPut) {
 465                         gotMessage.set(persistentPut.getName());
 466                 }
 467
 468                 @Override
 469                 protected void consumeEndListPersistentRequests(EndListPersistentRequests endListPersistentRequests) {
 470                         gotMessage.set(endListPersistentRequests.getName());
 471                 }
 472
 473                 @Override
 474                 protected void consumeURIGenerated(URIGenerated uriGenerated) {
 475                         gotMessage.set(uriGenerated.getName());
 476                 }
 477
 478                 @Override
 479                 protected void consumeDataFound(DataFound dataFound) {
 480                         gotMessage.set(dataFound.getName());
 481                 }
 482
 483                 @Override
 484                 protected void consumeAllData(AllData allData) {
 485                         gotMessage.set(allData.getName());
 486                 }
 487
 488                 @Override
 489                 protected void consumeSimpleProgress(SimpleProgress simpleProgress) {
 490                         gotMessage.set(simpleProgress.getName());
 491                 }
 492
 493                 @Override
 494                 protected void consumeStartedCompression(StartedCompression startedCompression) {
 495                         gotMessage.set(startedCompression.getName());
 496                 }
 497
 498                 @Override
 499                 protected void consumeFinishedCompression(FinishedCompression finishedCompression) {
 500                         gotMessage.set(finishedCompression.getName());
 501                 }
 502
 503                 @Override
 504                 protected void consumeUnknownPeerNoteType(UnknownPeerNoteType unknownPeerNoteType) {
 505                         gotMessage.set(unknownPeerNoteType.getName());
 506                 }
 507
 508                 @Override
 509                 protected void consumeUnknownNodeIdentifier(UnknownNodeIdentifier unknownNodeIdentifier) {
 510                         gotMessage.set(unknownNodeIdentifier.getName());
 511                 }
 512
 513                 @Override
 514                 protected void consumeConfigData(ConfigData configData) {
 515                         gotMessage.set(configData.getName());
 516                 }
 517
 518                 @Override
 519                 protected void consumeGetFailed(GetFailed getFailed) {
 520                         gotMessage.set(getFailed.getName());
 521                 }
 522
 523                 @Override
 524                 protected void consumePutFailed(PutFailed putFailed) {
 525                         gotMessage.set(putFailed.getName());
 526                 }
 527
 528                 @Override
 529                 protected void consumeIdentifierCollision(IdentifierCollision identifierCollision) {
 530                         gotMessage.set(identifierCollision.getName());
 531                 }
 532
 533                 @Override
 534                 protected void consumePersistentPutDir(PersistentPutDir persistentPutDir) {
 535                         gotMessage.set(persistentPutDir.getName());
 536                 }
 537
 538                 @Override
 539                 protected void consumePersistentRequestRemoved(PersistentRequestRemoved persistentRequestRemoved) {
 540                         gotMessage.set(persistentRequestRemoved.getName());
 541                 }
 542
 543                 @Override
 544                 protected void consumeSubscribedUSKUpdate(SubscribedUSKUpdate subscribedUSKUpdate) {
 545                         gotMessage.set(subscribedUSKUpdate.getName());
 546                 }
 547
 548                 @Override
 549                 protected void consumePluginInfo(PluginInfo pluginInfo) {
 550                         gotMessage.set(pluginInfo.getName());
 551                 }
 552
 553                 @Override
 554                 protected void consumeFCPPluginReply(FCPPluginReply fcpPluginReply) {
 555                         gotMessage.set(fcpPluginReply.getName());
 556                 }
 557
 558                 @Override
 559                 protected void consumePersistentRequestModified(PersistentRequestModified persistentRequestModified) {
 560                         gotMessage.set(persistentRequestModified.getName());
 561                 }
 562
 563                 @Override
 564                 protected void consumePutSuccessful(PutSuccessful putSuccessful) {
 565                         gotMessage.set(putSuccessful.getName());
 566                 }
 567
 568                 @Override
 569                 protected void consumePutFetchable(PutFetchable putFetchable) {
 570                         gotMessage.set(putFetchable.getName());
 571                 }
 572
 573                 @Override
 574                 protected void consumeSentFeed(SentFeed sentFeed) {
 575                         gotMessage.set(sentFeed.getName());
 576                 }
 577
 578                 @Override
 579                 protected void consumeReceivedBookmarkFeed(ReceivedBookmarkFeed receivedBookmarkFeed) {
 580                         gotMessage.set(receivedBookmarkFeed.getName());
 581                 }
 582
 583                 @Override
 584                 protected void consumeProtocolError(ProtocolError protocolError) {
 585                         gotMessage.set(protocolError.getName());
 586                 }
 587
 588                 @Override
 589                 protected void consumeUnknownMessage(FcpMessage fcpMessage) {
 590                         gotMessage.set(fcpMessage.getName());
 591                 }
 592
 593         }
 594
 595 }