import org.bitcoinj.testing.InboundMessageQueuer; //导入依赖的package包/类
@Test
public void pings() throws Exception {
    peerGroup.startAsync();
    peerGroup.awaitRunning();
    peerGroup.setPingIntervalMsec(100);
    VersionMessage versionMessage = new VersionMessage(params, 2);
    versionMessage.clientVersion = FilteredBlock.MIN_PROTOCOL_VERSION;
    versionMessage.localServices = VersionMessage.NODE_NETWORK;
    InboundMessageQueuer p1 = connectPeer(1, versionMessage);
    Ping ping = (Ping) outbound(p1);
    inbound(p1, new Pong(ping.getNonce()));
    pingAndWait(p1);
    assertTrue(peerGroup.getConnectedPeers().get(0).getLastPingTime() < Long.MAX_VALUE);
    // The call to outbound should block until a ping arrives.
    ping = (Ping) waitForOutbound(p1);
    inbound(p1, new Pong(ping.getNonce()));
    assertTrue(peerGroup.getConnectedPeers().get(0).getLastPingTime() < Long.MAX_VALUE);
}
 

import org.bitcoinj.testing.InboundMessageQueuer; //导入依赖的package包/类
@Test
public void invDownloadTxMultiPeer() throws Exception {
    // Check co-ordination of which peer to download via the memory pool.
    VersionMessage ver = new VersionMessage(PARAMS, 100);
    InetSocketAddress address = new InetSocketAddress("127.0.0.1", 4242);
    Peer peer2 = new Peer(PARAMS, ver, new PeerAddress(PARAMS, address), blockChain);
    peer2.addWallet(wallet);
    VersionMessage peerVersion = new VersionMessage(PARAMS, OTHER_PEER_CHAIN_HEIGHT);
    peerVersion.clientVersion = 70001;
    peerVersion.localServices = VersionMessage.NODE_NETWORK;

    connect();
    InboundMessageQueuer writeTarget2 = connect(peer2, peerVersion);

    // Make a tx and advertise it to one of the peers.
    Coin value = COIN;
    Transaction tx = createFakeTx(PARAMS, value, this.address);
    InventoryMessage inv = new InventoryMessage(PARAMS);
    InventoryItem item = new InventoryItem(InventoryItem.Type.Transaction, tx.getHash());
    inv.addItem(item);

    inbound(writeTarget, inv);

    // We got a getdata message.
    GetDataMessage message = (GetDataMessage)outbound(writeTarget);
    assertEquals(1, message.getItems().size());
    assertEquals(tx.getHash(), message.getItems().get(0).hash);
    assertNotEquals(0, tx.getConfidence().numBroadcastPeers());

    // Advertising to peer2 results in no getdata message.
    inbound(writeTarget2, inv);
    pingAndWait(writeTarget2);
    assertNull(outbound(writeTarget2));
}
 

import org.bitcoinj.testing.InboundMessageQueuer; //导入依赖的package包/类
@Test
public void fourPeers() throws Exception {
    InboundMessageQueuer[] channels = { connectPeer(1), connectPeer(2), connectPeer(3), connectPeer(4) };
    Transaction tx = new Transaction(params);
    TransactionBroadcast broadcast = new TransactionBroadcast(peerGroup, tx);
    ListenableFuture<Transaction> future = broadcast.broadcast();
    assertFalse(future.isDone());
    // We expect two peers to receive a tx message, and at least one of the others must announce for the future to
    // complete successfully.
    Message[] messages = {
            (Message) outbound(channels[0]),
            (Message) outbound(channels[1]),
            (Message) outbound(channels[2]),
            (Message) outbound(channels[3])
    };
    // 0 and 3 are randomly selected to receive the broadcast.
    assertEquals(tx, messages[0]);
    assertEquals(tx, messages[3]);
    assertNull(messages[1]);
    assertNull(messages[2]);
    Threading.waitForUserCode();
    assertFalse(future.isDone());
    inbound(channels[1], InventoryMessage.with(tx));
    pingAndWait(channels[1]);
    Threading.waitForUserCode();
    assertTrue(future.isDone());
}
 

import org.bitcoinj.testing.InboundMessageQueuer; //导入依赖的package包/类
@Test
public void retryFailedBroadcast() throws Exception {
    // If we create a spend, it's sent to a peer that swallows it, and the peergroup is removed/re-added then
    // the tx should be broadcast again.
    InboundMessageQueuer p1 = connectPeer(1);
    connectPeer(2);

    // Send ourselves a bit of money.
    Block b1 = FakeTxBuilder.makeSolvedTestBlock(blockStore, address);
    inbound(p1, b1);
    assertNull(outbound(p1));
    assertEquals(FIFTY_COINS, wallet.getBalance());

    // Now create a spend, and expect the announcement on p1.
    Address dest = new ECKey().toAddress(params);
    Wallet.SendResult sendResult = wallet.sendCoins(peerGroup, dest, COIN);
    assertFalse(sendResult.broadcastComplete.isDone());
    Transaction t1;
    {
        Message m;
        while (!((m = outbound(p1)) instanceof Transaction));
        t1 = (Transaction) m;
    }
    assertFalse(sendResult.broadcastComplete.isDone());

    // p1 eats it :( A bit later the PeerGroup is taken down.
    peerGroup.removeWallet(wallet);
    peerGroup.addWallet(wallet);

    // We want to hear about it again. Now, because we've disabled the randomness for the unit tests it will
    // re-appear on p1 again. Of course in the real world it would end up with a different set of peers and
    // select randomly so we get a second chance.
    Transaction t2 = (Transaction) outbound(p1);
    assertEquals(t1, t2);
}
 

import org.bitcoinj.testing.InboundMessageQueuer; //导入依赖的package包/类
@Test
public void invDownloadTxMultiPeer() throws Exception {
    // Check co-ordination of which peer to download via the memory pool.
    VersionMessage ver = new VersionMessage(unitTestParams, 100);
    InetSocketAddress address = new InetSocketAddress("127.0.0.1", 4242);
    Peer peer2 = new Peer(unitTestParams, ver, new PeerAddress(address), blockChain, memoryPool);
    peer2.addWallet(wallet);
    VersionMessage peerVersion = new VersionMessage(unitTestParams, OTHER_PEER_CHAIN_HEIGHT);
    peerVersion.clientVersion = 70001;
    peerVersion.localServices = VersionMessage.NODE_NETWORK;

    connect();
    InboundMessageQueuer writeTarget2 = connect(peer2, peerVersion);

    // Make a tx and advertise it to one of the peers.
    Coin value = COIN;
    Transaction tx = createFakeTx(unitTestParams, value, this.address);
    InventoryMessage inv = new InventoryMessage(unitTestParams);
    InventoryItem item = new InventoryItem(InventoryItem.Type.Transaction, tx.getHash());
    inv.addItem(item);

    inbound(writeTarget, inv);

    // We got a getdata message.
    GetDataMessage message = (GetDataMessage)outbound(writeTarget);
    assertEquals(1, message.getItems().size());
    assertEquals(tx.getHash(), message.getItems().get(0).hash);
    assertTrue(memoryPool.maybeWasSeen(tx.getHash()));

    // Advertising to peer2 results in no getdata message.
    inbound(writeTarget2, inv);
    pingAndWait(writeTarget2);
    assertNull(outbound(writeTarget2));
}
 

import org.bitcoinj.testing.InboundMessageQueuer; //导入依赖的package包/类
@Test
public void listener() throws Exception {
    peerGroup.startAsync();
    peerGroup.awaitRunning();
    peerGroup.addEventListener(listener);

    // Create a couple of peers.
    InboundMessageQueuer p1 = connectPeer(1);
    InboundMessageQueuer p2 = connectPeer(2);
    connectedPeers.take();
    connectedPeers.take();

    pingAndWait(p1);
    pingAndWait(p2);
    Threading.waitForUserCode();
    assertEquals(0, disconnectedPeers.size());

    p1.close();
    disconnectedPeers.take();
    assertEquals(0, disconnectedPeers.size());
    p2.close();
    disconnectedPeers.take();
    assertEquals(0, disconnectedPeers.size());

    assertTrue(peerGroup.removeEventListener(listener));
    assertFalse(peerGroup.removeEventListener(listener));
}
 

import org.bitcoinj.testing.InboundMessageQueuer; //导入依赖的package包/类
@Test
public void receiveTxBroadcast() throws Exception {
    // Check that when we receive transactions on all our peers, we do the right thing.
    peerGroup.startAsync();
    peerGroup.awaitRunning();

    // Create a couple of peers.
    InboundMessageQueuer p1 = connectPeer(1);
    InboundMessageQueuer p2 = connectPeer(2);
    
    // Check the peer accessors.
    assertEquals(2, peerGroup.numConnectedPeers());
    Set<Peer> tmp = new HashSet<Peer>(peerGroup.getConnectedPeers());
    Set<Peer> expectedPeers = new HashSet<Peer>();
    expectedPeers.add(peerOf(p1));
    expectedPeers.add(peerOf(p2));
    assertEquals(tmp, expectedPeers);

    Coin value = COIN;
    Transaction t1 = FakeTxBuilder.createFakeTx(unitTestParams, value, address);
    InventoryMessage inv = new InventoryMessage(unitTestParams);
    inv.addTransaction(t1);

    // Note: we start with p2 here to verify that transactions are downloaded from whichever peer announces first
    // which does not have to be the same as the download peer (which is really the "block download peer").
    inbound(p2, inv);
    assertTrue(outbound(p2) instanceof GetDataMessage);
    inbound(p1, inv);
    assertNull(outbound(p1));  // Only one peer is used to download.
    inbound(p2, t1);
    assertNull(outbound(p1));
    // Asks for dependency.
    GetDataMessage getdata = (GetDataMessage) outbound(p2);
    assertNotNull(getdata);
    inbound(p2, new NotFoundMessage(unitTestParams, getdata.getItems()));
    pingAndWait(p2);
    assertEquals(value, wallet.getBalance(Wallet.BalanceType.ESTIMATED));
    peerGroup.stopAsync();
    peerGroup.awaitTerminated();
}
 

import org.bitcoinj.testing.InboundMessageQueuer; //导入依赖的package包/类
@Test
public void receiveTxBroadcastOnAddedWallet() throws Exception {
    // Check that when we receive transactions on all our peers, we do the right thing.
    peerGroup.startAsync();
    peerGroup.awaitRunning();

    // Create a peer.
    InboundMessageQueuer p1 = connectPeer(1);
    
    Wallet wallet2 = new Wallet(unitTestParams);
    ECKey key2 = wallet2.freshReceiveKey();
    Address address2 = key2.toAddress(unitTestParams);
    
    peerGroup.addWallet(wallet2);
    blockChain.addWallet(wallet2);

    assertTrue(outbound(p1) instanceof BloomFilter);
    assertTrue(outbound(p1) instanceof MemoryPoolMessage);

    Coin value = COIN;
    Transaction t1 = FakeTxBuilder.createFakeTx(unitTestParams, value, address2);
    InventoryMessage inv = new InventoryMessage(unitTestParams);
    inv.addTransaction(t1);

    inbound(p1, inv);
    assertTrue(outbound(p1) instanceof GetDataMessage);
    inbound(p1, t1);
    // Asks for dependency.
    GetDataMessage getdata = (GetDataMessage) outbound(p1);
    assertNotNull(getdata);
    inbound(p1, new NotFoundMessage(unitTestParams, getdata.getItems()));
    pingAndWait(p1);
    assertEquals(value, wallet2.getBalance(Wallet.BalanceType.ESTIMATED));
    peerGroup.stopAsync();
    peerGroup.awaitTerminated();
}
 

import org.bitcoinj.testing.InboundMessageQueuer; //导入依赖的package包/类
@Test
public void singleDownloadPeer2() throws Exception {
    // Check that we don't attempt multiple simultaneous block chain downloads, when adding a new peer in the
    // middle of an existing chain download.
    // Create a couple of peers.
    peerGroup.startAsync();
    peerGroup.awaitRunning();

    // Create a couple of peers.
    InboundMessageQueuer p1 = connectPeer(1);

    // Set up a little block chain.
    Block b1 = FakeTxBuilder.createFakeBlock(blockStore).block;
    Block b2 = FakeTxBuilder.makeSolvedTestBlock(b1);
    Block b3 = FakeTxBuilder.makeSolvedTestBlock(b2);

    // Expect a zero hash getblocks on p1. This is how the process starts.
    peerGroup.startBlockChainDownload(new AbstractPeerEventListener() {
    });
    GetBlocksMessage getblocks = (GetBlocksMessage) outbound(p1);
    assertEquals(Sha256Hash.ZERO_HASH, getblocks.getStopHash());
    // We give back an inv with some blocks in it.
    InventoryMessage inv = new InventoryMessage(params);
    inv.addBlock(b1);
    inv.addBlock(b2);
    inv.addBlock(b3);
    
    inbound(p1, inv);
    assertTrue(outbound(p1) instanceof GetDataMessage);
    // We hand back the first block.
    inbound(p1, b1);
    // Now we successfully connect to another peer. There should be no messages sent.
    InboundMessageQueuer p2 = connectPeer(2);
    Message message = (Message)outbound(p2);
    assertNull(message == null ? "" : message.toString(), message);
    peerGroup.stopAsync();
}
 

import org.bitcoinj.testing.InboundMessageQueuer; //导入依赖的package包/类
@Test
public void testBloomOnP2Pubkey() throws Exception {
    // Cover bug 513. When a relevant transaction with a p2pubkey output is found, the Bloom filter should be
    // recalculated to include that transaction hash but not re-broadcast as the remote nodes should have followed
    // the same procedure. However a new node that's connected should get the fresh filter.
    peerGroup.startAsync();
    peerGroup.awaitRunning();
    final ECKey key = wallet.currentReceiveKey();
    // Create a couple of peers.
    InboundMessageQueuer p1 = connectPeer(1);
    InboundMessageQueuer p2 = connectPeer(2);
    // Create a pay to pubkey tx.
    Transaction tx = FakeTxBuilder.createFakeTx(params, COIN, key);
    Transaction tx2 = new Transaction(params);
    tx2.addInput(tx.getOutput(0));
    TransactionOutPoint outpoint = tx2.getInput(0).getOutpoint();
    assertTrue(p1.lastReceivedFilter.contains(key.getPubKey()));
    assertFalse(p1.lastReceivedFilter.contains(tx.getHash().getBytes()));
    inbound(p1, tx);
    // p1 requests dep resolution, p2 is quiet.
    assertTrue(outbound(p1) instanceof GetDataMessage);
    final Sha256Hash dephash = tx.getInput(0).getOutpoint().getHash();
    final InventoryItem inv = new InventoryItem(InventoryItem.Type.Transaction, dephash);
    inbound(p1, new NotFoundMessage(params, ImmutableList.of(inv)));
    assertNull(outbound(p1));
    assertNull(outbound(p2));
    peerGroup.waitForJobQueue();
    // Now we connect p3 and there is a new bloom filter sent, that DOES match the relevant outpoint.
    InboundMessageQueuer p3 = connectPeer(3);
    assertTrue(p3.lastReceivedFilter.contains(key.getPubKey()));
    assertTrue(p3.lastReceivedFilter.contains(outpoint.bitcoinSerialize()));
}
 

import org.bitcoinj.testing.InboundMessageQueuer; //导入依赖的package包/类
@Test
public void testBloomResendOnNewKey() throws Exception {
    // Check that when we add a new key to the wallet, the Bloom filter is re-calculated and re-sent but only once
    // we exceed the lookahead threshold.
    wallet.setKeychainLookaheadSize(5);
    wallet.setKeychainLookaheadThreshold(4);
    peerGroup.startAsync();
    peerGroup.awaitRunning();
    // Create a couple of peers.
    InboundMessageQueuer p1 = connectPeer(1);
    InboundMessageQueuer p2 = connectPeer(2);
    peerGroup.waitForJobQueue();
    BloomFilter f1 = p1.lastReceivedFilter;
    ECKey key = null;
    // We have to run ahead of the lookahead zone for this test. There should only be one bloom filter recalc.
    for (int i = 0; i < wallet.getKeychainLookaheadSize() + wallet.getKeychainLookaheadThreshold() + 1; i++) {
        key = wallet.freshReceiveKey();
    }
    peerGroup.waitForJobQueue();
    BloomFilter bf, f2 = null;
    while ((bf = (BloomFilter) outbound(p1)) != null) {
        assertEquals(MemoryPoolMessage.class, outbound(p1).getClass());
        f2 = bf;
    }
    assertNotNull(key);
    assertNotNull(f2);
    assertNull(outbound(p1));
    // Check the last filter received.
    assertNotEquals(f1, f2);
    assertTrue(f2.contains(key.getPubKey()));
    assertTrue(f2.contains(key.getPubKeyHash()));
    assertFalse(f1.contains(key.getPubKey()));
    assertFalse(f1.contains(key.getPubKeyHash()));
}
 

import org.bitcoinj.testing.InboundMessageQueuer; //导入依赖的package包/类
private void filterAndSend(InboundMessageQueuer p1, List<Block> blocks, BloomFilter filter) {
    for (Block block : blocks) {
        FilteredBlock fb = filter.applyAndUpdate(block);
        inbound(p1, fb);
        for (Transaction tx : fb.getAssociatedTransactions().values())
            inbound(p1, tx);
    }
}
 

import org.bitcoinj.testing.InboundMessageQueuer; //导入依赖的package包/类
@Test
public void invDownloadTxMultiPeer() throws Exception {
    // Check co-ordination of which peer to download via the memory pool.
    VersionMessage ver = new VersionMessage(PARAMS, 100);
    InetSocketAddress address = new InetSocketAddress("127.0.0.1", 4242);
    Peer peer2 = new Peer(PARAMS, ver, new PeerAddress(PARAMS, address), blockChain);
    peer2.addWallet(wallet);
    VersionMessage peerVersion = new VersionMessage(PARAMS, OTHER_PEER_CHAIN_HEIGHT);
    peerVersion.clientVersion = CoinDefinition.MIN_PROTOCOL_VERSION;
    peerVersion.localServices = VersionMessage.NODE_NETWORK;

    connect();
    InboundMessageQueuer writeTarget2 = connect(peer2, peerVersion);

    // Make a tx and advertise it to one of the peers.
    Coin value = COIN;
    Transaction tx = createFakeTx(PARAMS, value, this.address);
    InventoryMessage inv = new InventoryMessage(PARAMS);
    InventoryItem item = new InventoryItem(InventoryItem.Type.Transaction, tx.getHash());
    inv.addItem(item);

    inbound(writeTarget, inv);

    // We got a getdata message.
    GetDataMessage message = (GetDataMessage)outbound(writeTarget);
    assertEquals(1, message.getItems().size());
    assertEquals(tx.getHash(), message.getItems().get(0).hash);
    assertNotEquals(0, tx.getConfidence().numBroadcastPeers());

    // Advertising to peer2 results in no getdata message.
    inbound(writeTarget2, inv);
    pingAndWait(writeTarget2);
    assertNull(outbound(writeTarget2));
}
 

import org.bitcoinj.testing.InboundMessageQueuer; //导入依赖的package包/类
@Test
public void singleDownloadPeer1() throws Exception {
    // Check that we don't attempt to retrieve blocks on multiple peers.
    peerGroup.startAsync();
    peerGroup.awaitRunning();

    // Create a couple of peers.
    InboundMessageQueuer p1 = connectPeer(1);
    InboundMessageQueuer p2 = connectPeer(2);
    assertEquals(2, peerGroup.numConnectedPeers());

    // Set up a little block chain. We heard about b1 but not b2 (it is pending download). b3 is solved whilst we
    // are downloading the chain.
    Block b1 = FakeTxBuilder.createFakeBlock(blockStore).block;
    blockChain.add(b1);
    Block b2 = FakeTxBuilder.makeSolvedTestBlock(b1);
    Block b3 = FakeTxBuilder.makeSolvedTestBlock(b2);

    // Peer 1 and 2 receives an inv advertising a newly solved block.
    InventoryMessage inv = new InventoryMessage(params);
    inv.addBlock(b3);
    // Only peer 1 tries to download it.
    inbound(p1, inv);
    pingAndWait(p1);
    
    assertTrue(outbound(p1) instanceof GetDataMessage);
    assertNull(outbound(p2));
    // Peer 1 goes away, peer 2 becomes the download peer and thus queries the remote mempool.
    final SettableFuture<Void> p1CloseFuture = SettableFuture.create();
    peerOf(p1).addEventListener(new AbstractPeerEventListener() {
        @Override
        public void onPeerDisconnected(Peer peer, int peerCount) {
            p1CloseFuture.set(null);
        }
    });
    closePeer(peerOf(p1));
    p1CloseFuture.get();
    // Peer 2 fetches it next time it hears an inv (should it fetch immediately?).
    inbound(p2, inv);
    assertTrue(outbound(p2) instanceof GetDataMessage);
    peerGroup.stopAsync();
}
 

import org.bitcoinj.testing.InboundMessageQueuer; //导入依赖的package包/类
private <T extends Message> T assertNextMessageIs(InboundMessageQueuer q, Class<T> klass) throws Exception {
    Message outbound = waitForOutbound(q);
    assertEquals(klass, outbound.getClass());
    return (T) outbound;
}