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