_ Git - ldk-java/blob - src/test/java/org/ldk/HumanObjectPeerTest.java

   1 package org.ldk;
   2
   3 import org.bitcoinj.core.*;
   4 import org.bitcoinj.core.Transaction;
   5 import org.bitcoinj.script.Script;
   6 import org.junit.jupiter.api.Test;
   7 import org.ldk.enums.LDKNetwork;
   8 import org.ldk.impl.bindings;
   9 import org.ldk.structs.*;
  10 import org.ldk.util.TwoTuple;
  11
  12 import java.lang.ref.WeakReference;
  13 import java.util.Arrays;
  14 import java.util.HashMap;
  15 import java.util.LinkedList;
  16
  17 class HumanObjectPeerTestInstance {
  18     class Peer {
  19         KeysInterface manual_keysif(KeysInterface underlying_if) {
  20             return KeysInterface.new_impl(new KeysInterface.KeysInterfaceInterface() {
  21                 @Override public byte[] get_node_secret() { return underlying_if.get_node_secret(); }
  22                 @Override public byte[] get_destination_script() { return underlying_if.get_destination_script(); }
  23                 @Override public byte[] get_shutdown_pubkey() { return underlying_if.get_shutdown_pubkey(); }
  24
  25                 @Override
  26                 public ChannelKeys get_channel_keys(boolean inbound, long channel_value_satoshis) {
  27                     ChannelKeys underlying_ck = underlying_if.get_channel_keys(inbound, channel_value_satoshis);
  28                     ChannelKeys.ChannelKeysInterface cki = new ChannelKeys.ChannelKeysInterface() {
  29                         @Override
  30                         public byte[] get_per_commitment_point(long idx) {
  31                             return underlying_ck.get_per_commitment_point(idx);
  32                         }
  33
  34                         @Override
  35                         public byte[] release_commitment_secret(long idx) {
  36                             return underlying_ck.release_commitment_secret(idx);
  37                         }
  38
  39                         @Override
  40                         public TwoTuple<Long, Long> key_derivation_params() {
  41                             return new TwoTuple<Long, Long>((long)0, (long)1);
  42                         }
  43
  44                         @Override
  45                         public Result_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_counterparty_commitment(CommitmentTransaction commitment_tx) {
  46                             return underlying_ck.sign_counterparty_commitment(commitment_tx);
  47                         }
  48
  49                         @Override
  50                         public Result_SignatureNoneZ sign_holder_commitment(HolderCommitmentTransaction holder_commitment_tx) {
  51                             return underlying_ck.sign_holder_commitment(holder_commitment_tx);
  52                         }
  53
  54                         @Override
  55                         public Result_CVec_SignatureZNoneZ sign_holder_commitment_htlc_transactions(HolderCommitmentTransaction holder_commitment_tx) {
  56                             return underlying_ck.sign_holder_commitment_htlc_transactions(holder_commitment_tx);
  57                         }
  58
  59                         @Override
  60                         public Result_SignatureNoneZ sign_justice_transaction(byte[] justice_tx, long input, long amount, byte[] per_commitment_key, HTLCOutputInCommitment htlc) {
  61                             return underlying_ck.sign_justice_transaction(justice_tx, input, amount, per_commitment_key, htlc);
  62                         }
  63
  64                         @Override
  65                         public Result_SignatureNoneZ sign_counterparty_htlc_transaction(byte[] htlc_tx, long input, long amount, byte[] per_commitment_point, HTLCOutputInCommitment htlc) {
  66                             return underlying_ck.sign_counterparty_htlc_transaction(htlc_tx, input, amount, per_commitment_point, htlc);
  67                         }
  68
  69                         @Override
  70                         public Result_SignatureNoneZ sign_closing_transaction(byte[] closing_tx) {
  71                             return underlying_ck.sign_closing_transaction(closing_tx);
  72                         }
  73
  74                         @Override
  75                         public Result_SignatureNoneZ sign_channel_announcement(UnsignedChannelAnnouncement msg) {
  76                             return underlying_ck.sign_channel_announcement(msg);
  77                         }
  78
  79                         @Override
  80                         public void ready_channel(ChannelTransactionParameters params) {
  81                             underlying_ck.ready_channel(params);
  82                         }
  83
  84                         @Override
  85                         public byte[] write() {
  86                             return underlying_ck.write();
  87                         }
  88                     };
  89                     ChannelKeys resp = ChannelKeys.new_impl(cki, underlying_ck.get_pubkeys());
  90                     must_free_objs.add(new WeakReference<>(cki));
  91                     must_free_objs.add(new WeakReference<>(resp));
  92                     must_free_objs.add(new WeakReference<>(underlying_ck));
  93                     return resp;
  94                 }
  95
  96                 @Override
  97                 public byte[] get_secure_random_bytes() {
  98                     return underlying_if.get_secure_random_bytes();
  99                 }
 100
 101                 @Override
 102                 public Result_ChanKeySignerDecodeErrorZ read_chan_signer(byte[] reader) {
 103                     return underlying_if.read_chan_signer(reader);
 104                 }
 105             });
 106         }
 107
 108         Watch get_manual_watch() {
 109             return Watch.new_impl(new Watch.WatchInterface() {
 110                 public Result_NoneChannelMonitorUpdateErrZ watch_channel(OutPoint funding_txo, ChannelMonitor monitor) {
 111                     synchronized (monitors) {
 112                         assert monitors.put(Arrays.toString(funding_txo.get_txid()), monitor) == null;
 113                     }
 114                     return new Result_NoneChannelMonitorUpdateErrZ.Result_NoneChannelMonitorUpdateErrZ_OK();
 115                 }
 116
 117                 public Result_NoneChannelMonitorUpdateErrZ update_channel(OutPoint funding_txo, ChannelMonitorUpdate update) {
 118                     synchronized (monitors) {
 119                         String txid = Arrays.toString(funding_txo.get_txid());
 120                         assert monitors.containsKey(txid);
 121                         Result_NoneMonitorUpdateErrorZ update_res = monitors.get(txid).update_monitor(update, tx_broadcaster, fee_estimator, logger);
 122                         assert update_res instanceof Result_NoneMonitorUpdateErrorZ.Result_NoneMonitorUpdateErrorZ_OK;
 123                     }
 124                     return new Result_NoneChannelMonitorUpdateErrZ.Result_NoneChannelMonitorUpdateErrZ_OK();
 125                 }
 126
 127                 @Override
 128                 public MonitorEvent[] release_pending_monitor_events() {
 129                     synchronized (monitors) {
 130                         assert monitors.size() <= 1;
 131                         for (ChannelMonitor mon : monitors.values()) {
 132                             return mon.get_and_clear_pending_monitor_events();
 133                         }
 134                     }
 135                     return new MonitorEvent[0];
 136                 }
 137             });
 138         }
 139
 140         final Logger logger;
 141         final FeeEstimator fee_estimator;
 142         final BroadcasterInterface tx_broadcaster;
 143         final KeysInterface keys_interface;
 144         final ChainMonitor chain_monitor;
 145         final ChannelManager chan_manager;
 146         final EventsProvider chan_manager_events;
 147         final NetGraphMsgHandler router;
 148         final PeerManager peer_manager;
 149         final HashMap<String, ChannelMonitor> monitors; // Wow I forgot just how terrible Java is - we can't put a byte array here.
 150         byte[] node_id;
 151         final LinkedList<byte[]> broadcast_set = new LinkedList<>();
 152
 153         Peer(byte seed, boolean use_km_wrapper, boolean use_manual_watch) {
 154             logger = Logger.new_impl((String arg) -> System.out.println(seed + ": " + arg));
 155             fee_estimator = FeeEstimator.new_impl((confirmation_target -> 253));
 156             tx_broadcaster = BroadcasterInterface.new_impl(tx -> {
 157                 broadcast_set.add(tx);
 158             });
 159             this.monitors = new HashMap<>();
 160             Persist persister = Persist.new_impl(new Persist.PersistInterface() {
 161                 @Override
 162                 public Result_NoneChannelMonitorUpdateErrZ persist_new_channel(OutPoint id, ChannelMonitor data) {
 163                     return new Result_NoneChannelMonitorUpdateErrZ.Result_NoneChannelMonitorUpdateErrZ_OK();
 164                 }
 165
 166                 @Override
 167                 public Result_NoneChannelMonitorUpdateErrZ update_persisted_channel(OutPoint id, ChannelMonitorUpdate update, ChannelMonitor data) {
 168                     return new Result_NoneChannelMonitorUpdateErrZ.Result_NoneChannelMonitorUpdateErrZ_OK();
 169                 }
 170             });
 171             Watch chain_watch;
 172             if (use_manual_watch) {
 173                 chain_watch = get_manual_watch();
 174                 chain_monitor = null;
 175             } else {
 176                 chain_monitor = ChainMonitor.constructor_new(null, tx_broadcaster, logger, fee_estimator, persister);
 177                 chain_watch = chain_monitor.as_Watch();
 178             }
 179
 180             byte[] key_seed = new byte[32];
 181             for (byte i = 0; i < 32; i++) {
 182                 key_seed[i] = (byte) (i ^ seed);
 183             }
 184             if (use_km_wrapper) {
 185                 KeysManager underlying = KeysManager.constructor_new(key_seed, LDKNetwork.LDKNetwork_Bitcoin, System.currentTimeMillis() / 1000, (int) (System.currentTimeMillis() * 1000) & 0xffffffff);
 186                 this.keys_interface = manual_keysif(underlying.as_KeysInterface());
 187             } else {
 188                 KeysManager keys = KeysManager.constructor_new(key_seed, LDKNetwork.LDKNetwork_Bitcoin, System.currentTimeMillis() / 1000, (int) (System.currentTimeMillis() * 1000) & 0xffffffff);
 189                 this.keys_interface = keys.as_KeysInterface();
 190             }
 191             this.chan_manager = ChannelManager.constructor_new(LDKNetwork.LDKNetwork_Bitcoin, FeeEstimator.new_impl(confirmation_target -> 0), chain_watch, tx_broadcaster, logger, this.keys_interface, UserConfig.constructor_default(), 1);
 192             this.node_id = chan_manager.get_our_node_id();
 193             this.chan_manager_events = chan_manager.as_EventsProvider();
 194             this.router = NetGraphMsgHandler.constructor_new(new byte[32], null, logger);
 195
 196             byte[] random_data = new byte[32];
 197             for (byte i = 0; i < 32; i++) {
 198                 random_data[i] = (byte) ((i ^ seed) ^ 0xf0);
 199             }
 200             this.peer_manager = PeerManager.constructor_new(chan_manager.as_ChannelMessageHandler(), router.as_RoutingMessageHandler(), keys_interface.get_node_secret(), random_data, logger);
 201             System.gc();
 202         }
 203
 204         TwoTuple<byte[], TwoTuple<Integer, TxOut>[]>[] connect_block(Block b, int height, long expected_monitor_update_len) {
 205             byte[] header = Arrays.copyOfRange(b.bitcoinSerialize(), 0, 80);
 206             TwoTuple<Long, byte[]>[] txn;
 207             if (b.hasTransactions()) {
 208                 assert b.getTransactions().size() == 1;
 209                 TwoTuple<Long, byte[]> txp = new TwoTuple<>((long) 1, b.getTransactions().get(0).bitcoinSerialize());
 210                 txn = new TwoTuple[]{txp};
 211             } else
 212                 txn = new TwoTuple[0];
 213             chan_manager.block_connected(header, txn, height);
 214             if (chain_monitor != null) {
 215                 chain_monitor.block_connected(header, txn, height);
 216             } else {
 217                 synchronized (monitors) {
 218                     assert monitors.size() == 1;
 219                     for (ChannelMonitor mon : monitors.values()) {
 220                         TwoTuple<byte[], TwoTuple<Integer, TxOut>[]>[] ret = mon.block_connected(header, txn, height, tx_broadcaster, fee_estimator, logger);
 221                         assert ret.length == expected_monitor_update_len;
 222                         return ret;
 223                     }
 224                 }
 225             }
 226             return null;
 227         }
 228
 229         Route get_route(byte[] dest_node, ChannelDetails[] our_chans) {
 230             try (LockedNetworkGraph netgraph = this.router.read_locked_graph()) {
 231                 NetworkGraph graph = netgraph.graph();
 232                 long res = bindings.get_route(this.node_id, graph._test_only_get_ptr(), dest_node, new long[]{our_chans[0]._test_only_get_ptr()},
 233                         new long[0], 1000, 42, this.logger._test_only_get_ptr());
 234                 assert bindings.LDKCResult_RouteLightningErrorZ_result_ok(res);
 235                 byte[] serialized_route = bindings.Route_write(bindings.LDKCResult_RouteLightningErrorZ_get_ok(res));
 236                 must_free_objs.add(new WeakReference<>(serialized_route));
 237                 Result_RouteDecodeErrorZ copy = Route.constructor_read(serialized_route);
 238                 assert copy instanceof Result_RouteDecodeErrorZ.Result_RouteDecodeErrorZ_OK;
 239                 bindings.CResult_RouteLightningErrorZ_free(res);
 240                 return ((Result_RouteDecodeErrorZ.Result_RouteDecodeErrorZ_OK) copy).res;
 241             }
 242         }
 243     }
 244
 245     class DescriptorHolder { SocketDescriptor val; }
 246
 247     boolean running = false;
 248     final LinkedList<Runnable> runqueue = new LinkedList();
 249     Thread t = new Thread(() -> {
 250             while (true) {
 251                 try {
 252                     Runnable r;
 253                     synchronized (runqueue) {
 254                         while (runqueue.isEmpty()) {
 255                             runqueue.wait();
 256                         }
 257                         running = true;
 258                         r = runqueue.pollFirst();
 259                     }
 260                     r.run();
 261                     synchronized (runqueue) {
 262                         running = false;
 263                         runqueue.notifyAll();
 264                     }
 265                 } catch (InterruptedException e) {
 266                     return;
 267                 }
 268             }
 269     });
 270     void wait_events_processed() {
 271         while (true) {
 272             synchronized (runqueue) {
 273                 if (runqueue.isEmpty() && !running) break;
 274                 try { runqueue.wait(); } catch (InterruptedException e) { assert false; }
 275             }
 276         }
 277     }
 278     void do_read_event(PeerManager pm, SocketDescriptor descriptor, byte[] data) {
 279         if (!t.isAlive()) t.start();
 280         synchronized (runqueue) {
 281             runqueue.add(() -> {
 282                 Result_boolPeerHandleErrorZ res = pm.read_event(descriptor, data);
 283                 assert res instanceof Result_boolPeerHandleErrorZ.Result_boolPeerHandleErrorZ_OK;
 284             });
 285             runqueue.notifyAll();
 286         }
 287         must_free_objs.add(new WeakReference<>(data));
 288     }
 289
 290     void do_test_message_handler(boolean nice_close, boolean use_km_wrapper, boolean use_manual_watch) throws InterruptedException {
 291         GcCheck obj = new GcCheck();
 292         Peer peer1 = new Peer((byte) 1, use_km_wrapper, use_manual_watch);
 293         Peer peer2 = new Peer((byte) 2, use_km_wrapper, use_manual_watch);
 294
 295         DescriptorHolder descriptor1 = new DescriptorHolder();
 296         DescriptorHolder descriptor1ref = descriptor1;
 297         SocketDescriptor descriptor2 = SocketDescriptor.new_impl(new SocketDescriptor.SocketDescriptorInterface() {
 298             @Override
 299             public long send_data(byte[] data, boolean resume_read) {
 300                 do_read_event(peer1.peer_manager, descriptor1ref.val, data);
 301                 return data.length;
 302             }
 303
 304             @Override public void disconnect_socket() { assert false; }
 305             @Override public boolean eq(SocketDescriptor other_arg) { return other_arg.hash() == 2; }
 306             @Override public long hash() { return 2; }
 307         });
 308
 309         descriptor1.val = SocketDescriptor.new_impl(new SocketDescriptor.SocketDescriptorInterface() {
 310             @Override
 311             public long send_data(byte[] data, boolean resume_read) {
 312                 do_read_event(peer2.peer_manager, descriptor2, data);
 313                 return data.length;
 314             }
 315
 316             @Override public void disconnect_socket() { assert false; }
 317             @Override public boolean eq(SocketDescriptor other_arg) { return other_arg.hash() == 1; }
 318             @Override public long hash() { return 1; }
 319         });
 320
 321         Result_CVec_u8ZPeerHandleErrorZ conn_res = peer1.peer_manager.new_outbound_connection(peer2.node_id, descriptor1.val);
 322         assert conn_res instanceof Result_CVec_u8ZPeerHandleErrorZ.Result_CVec_u8ZPeerHandleErrorZ_OK;
 323
 324         Result_NonePeerHandleErrorZ inbound_conn_res = peer2.peer_manager.new_inbound_connection(descriptor2);
 325         assert inbound_conn_res instanceof Result_NonePeerHandleErrorZ.Result_NonePeerHandleErrorZ_OK;
 326         do_read_event(peer2.peer_manager, descriptor2, ((Result_CVec_u8ZPeerHandleErrorZ.Result_CVec_u8ZPeerHandleErrorZ_OK) conn_res).res);
 327
 328         wait_events_processed();
 329
 330         Result_NoneAPIErrorZ cc_res = peer1.chan_manager.create_channel(peer2.node_id, 10000, 1000, 42, null);
 331         assert cc_res instanceof Result_NoneAPIErrorZ.Result_NoneAPIErrorZ_OK;
 332
 333         peer1.peer_manager.process_events();
 334         wait_events_processed();
 335         peer2.peer_manager.process_events();
 336         wait_events_processed();
 337
 338         Event[] events = peer1.chan_manager_events.get_and_clear_pending_events();
 339         assert events.length == 1;
 340         assert events[0] instanceof Event.FundingGenerationReady;
 341         assert ((Event.FundingGenerationReady) events[0]).channel_value_satoshis == 10000;
 342         assert ((Event.FundingGenerationReady) events[0]).user_channel_id == 42;
 343         byte[] funding_spk = ((Event.FundingGenerationReady) events[0]).output_script;
 344         assert funding_spk.length == 34 && funding_spk[0] == 0 && funding_spk[1] == 32; // P2WSH
 345         byte[] chan_id = ((Event.FundingGenerationReady) events[0]).temporary_channel_id;
 346
 347         NetworkParameters bitcoinj_net = NetworkParameters.fromID(NetworkParameters.ID_MAINNET);
 348
 349         Transaction funding = new Transaction(bitcoinj_net);
 350         funding.addInput(new TransactionInput(bitcoinj_net, funding, new byte[0]));
 351         funding.getInputs().get(0).setWitness(new TransactionWitness(2)); // Make sure we don't complain about lack of witness
 352         funding.getInput(0).getWitness().setPush(0, new byte[]{0x1});
 353         funding.addOutput(Coin.SATOSHI.multiply(10000), new Script(funding_spk));
 354         peer1.chan_manager.funding_transaction_generated(chan_id, OutPoint.constructor_new(funding.getTxId().getReversedBytes(), (short) 0));
 355
 356         peer1.peer_manager.process_events();
 357         wait_events_processed();
 358         peer2.peer_manager.process_events();
 359         wait_events_processed();
 360
 361         events = peer1.chan_manager_events.get_and_clear_pending_events();
 362         assert events.length == 1;
 363         assert events[0] instanceof Event.FundingBroadcastSafe;
 364         assert ((Event.FundingBroadcastSafe) events[0]).user_channel_id == 42;
 365
 366         Block b = new Block(bitcoinj_net, 2, Sha256Hash.ZERO_HASH, Sha256Hash.ZERO_HASH, 42, 0, 0, Arrays.asList(new Transaction[]{funding}));
 367         peer1.connect_block(b, 1, 0);
 368         peer2.connect_block(b, 1, 0);
 369
 370         for (int height = 2; height < 10; height++) {
 371             b = new Block(bitcoinj_net, 2, b.getHash(), Sha256Hash.ZERO_HASH, 42, 0, 0, Arrays.asList(new Transaction[0]));
 372             peer1.connect_block(b, height, 0);
 373             peer2.connect_block(b, height, 0);
 374         }
 375
 376         peer1.peer_manager.process_events();
 377         peer2.peer_manager.process_events();
 378         wait_events_processed();
 379
 380         peer1.chan_manager.list_channels();
 381         ChannelDetails[] peer1_chans = peer1.chan_manager.list_channels();
 382         ChannelDetails[] peer2_chans = peer2.chan_manager.list_channels();
 383         assert peer1_chans.length == 1;
 384         assert peer2_chans.length == 1;
 385         assert peer1_chans[0].get_channel_value_satoshis() == 10000;
 386         assert peer1_chans[0].get_is_live();
 387         assert Arrays.equals(peer1_chans[0].get_channel_id(), funding.getTxId().getReversedBytes());
 388         assert Arrays.equals(peer2_chans[0].get_channel_id(), funding.getTxId().getReversedBytes());
 389
 390         byte[] payment_preimage = new byte[32];
 391         for (int i = 0; i < 32; i++) payment_preimage[i] = (byte) (i ^ 0x0f);
 392         byte[] payment_hash = Sha256Hash.hash(payment_preimage);
 393         Route route = peer1.get_route(peer2.node_id, peer1_chans);
 394         Result_NonePaymentSendFailureZ payment_res = peer1.chan_manager.send_payment(route, payment_hash, new byte[32]);
 395         assert payment_res instanceof Result_NonePaymentSendFailureZ.Result_NonePaymentSendFailureZ_OK;
 396
 397         peer1.peer_manager.process_events();
 398         wait_events_processed();
 399         peer2.peer_manager.process_events();
 400         wait_events_processed();
 401         peer1.peer_manager.process_events();
 402         wait_events_processed();
 403
 404         {
 405             peer1.chan_manager.write();
 406             //ChannelManager.
 407         }
 408
 409         events = peer2.chan_manager_events.get_and_clear_pending_events();
 410         assert events.length == 1;
 411         assert events[0] instanceof Event.PendingHTLCsForwardable;
 412         peer2.chan_manager.process_pending_htlc_forwards();
 413
 414         events = peer2.chan_manager_events.get_and_clear_pending_events();
 415         assert events.length == 1;
 416         assert events[0] instanceof Event.PaymentReceived;
 417         peer2.chan_manager.claim_funds(payment_preimage, new byte[32], ((Event.PaymentReceived) events[0]).amt);
 418
 419         peer2.peer_manager.process_events();
 420         wait_events_processed();
 421         peer1.peer_manager.process_events();
 422         wait_events_processed();
 423         peer2.peer_manager.process_events();
 424         wait_events_processed();
 425
 426         events = peer1.chan_manager_events.get_and_clear_pending_events();
 427         assert events.length == 1;
 428         assert events[0] instanceof Event.PaymentSent;
 429         assert Arrays.equals(((Event.PaymentSent) events[0]).payment_preimage, payment_preimage);
 430
 431         if (nice_close) {
 432             Result_NoneAPIErrorZ close_res = peer1.chan_manager.close_channel(peer1_chans[0].get_channel_id());
 433             assert close_res instanceof Result_NoneAPIErrorZ.Result_NoneAPIErrorZ_OK;
 434
 435             peer1.peer_manager.process_events();
 436             wait_events_processed();
 437             peer2.peer_manager.process_events();
 438             wait_events_processed();
 439             peer1.peer_manager.process_events();
 440             wait_events_processed();
 441             peer2.peer_manager.process_events();
 442             wait_events_processed();
 443
 444             assert peer1.broadcast_set.size() == 1;
 445             assert peer2.broadcast_set.size() == 1;
 446         } else {
 447             peer1.chan_manager.force_close_all_channels();
 448
 449             peer1.peer_manager.process_events();
 450             wait_events_processed();
 451             peer2.peer_manager.process_events();
 452             wait_events_processed();
 453             peer1.peer_manager.process_events();
 454             wait_events_processed();
 455             peer2.peer_manager.process_events();
 456             wait_events_processed();
 457
 458             assert peer1.broadcast_set.size() == 1;
 459             assert peer2.broadcast_set.size() == 0;
 460
 461             Transaction tx = new Transaction(bitcoinj_net, peer1.broadcast_set.getFirst());
 462             b = new Block(bitcoinj_net, 2, b.getHash(), Sha256Hash.ZERO_HASH, 42, 0, 0,
 463                     Arrays.asList(new Transaction[]{tx}));
 464             TwoTuple<byte[], TwoTuple<Integer, TxOut>[]>[] watch_outputs =  peer2.connect_block(b, 1, 1);
 465             if (watch_outputs != null) { // We only process watch_outputs manually when we use a manually-build Watch impl
 466                 assert watch_outputs.length == 1;
 467                 assert Arrays.equals(watch_outputs[0].a, tx.getTxId().getReversedBytes());
 468                 assert watch_outputs[0].b.length == 1;
 469             }
 470
 471             // This used to be buggy and double-free, so go ahead and fetch them!
 472             for (ChannelMonitor mon : peer2.monitors.values()) {
 473                 byte[][] txn = mon.get_latest_holder_commitment_txn(peer2.logger);
 474             }
 475         }
 476     }
 477
 478     java.util.LinkedList<WeakReference<Object>> must_free_objs = new java.util.LinkedList();
 479     boolean gc_ran = false;
 480     class GcCheck {
 481         @Override
 482         protected void finalize() throws Throwable {
 483             gc_ran = true;
 484             super.finalize();
 485         }
 486     }
 487 }
 488 public class HumanObjectPeerTest {
 489     void do_test(boolean nice_close, boolean use_km_wrapper, boolean use_manual_watch) throws InterruptedException {
 490         HumanObjectPeerTestInstance instance = new HumanObjectPeerTestInstance();
 491         instance.do_test_message_handler(nice_close, use_km_wrapper, use_manual_watch);
 492         while (!instance.gc_ran) {
 493             System.gc();
 494             System.runFinalization();
 495         }
 496         for (WeakReference<Object> o : instance.must_free_objs)
 497             assert o.get() == null;
 498     }
 499     @Test
 500     public void test_message_handler_force_close() throws InterruptedException {
 501         do_test(false, false, false);
 502     }
 503     @Test
 504     public void test_message_handler_nice_close() throws InterruptedException {
 505         do_test(true, false, false);
 506     }
 507     @Test
 508     public void test_message_handler_nice_close_wrapper() throws InterruptedException {
 509         do_test(true, true, true);
 510     }
 511     @Test
 512     public void test_message_handler_force_close_wrapper() throws InterruptedException {
 513         do_test(false, true, true);
 514     }
 515 }