async runTestCase(adapter:Test.RemoteObjectAdapterPrx, proxy:Test.TestIntfPrx)
 {
     //
     // Put the adapter on hold. The server will not respond to
     // the graceful close. This allows to test whether or not
     // the close is graceful or forceful.
     //
     await adapter.hold();
     await Ice.Promise.delay(3000);
     test(this._heartbeat === 0);
     test(!this._closed); // Not closed yet because of graceful close.
     await adapter.activate();
     await Ice.Promise.delay(1000);
     await this.waitForClosed(); // Connection should be closed this time.
 }

 callbackOK():PromiseLike<void>
 {
     return this._p.then(() =>
                         {
                             this._callback = false;
                             this._p = new Ice.Promise();
                         });
 }

 async waitForClosed()
 {
     const now = Date.now();
     while(!this._closed)
     {
         await Ice.Promise.delay(100);
         if(Date.now() - now >= 2000)
         {
             test(false); // Waited for more than 2s for close, something's wrong.
         }
     }
 }

 async function connect(prx:Test.TimeoutPrx)
 {
     let nRetry = 10;
     while(--nRetry > 0)
     {
         try
         {
             await prx.ice_getConnection();
             break;
         }
         catch(ex)
         {
             // Can sporadically occur with slow machines
             test(ex instanceof Ice.ConnectTimeoutException ||
                     ex instanceof Ice.ConnectFailedException, ex);
         }
         await Ice.Promise.delay(100);
     }
     return prx.ice_getConnection();
 }

//.........这里部分代码省略.........
        }
        catch(ex)
        {
            test(ex instanceof Ice.MemoryLimitException, ex);
        }

        try
        {
            await thrower.throwMemoryLimitException(new Uint8Array(20 * 1024));
            test(false);
        }
        catch(ex)
        {
            test(ex.toString().indexOf("ConnectionLostException") > 0, ex);
        }
        out.writeLine("ok");

        let retries = 10;
        while(--retries > 0)
        {
            // The above test can cause a close connection between the echo server and
            // bidir server, we need to wait until the bidir server has reopen the
            // connection with the echo server.

            try
            {
                await thrower.ice_ping();
                break;
            }
            catch(ex)
            {
                if(ex instanceof Ice.ObjectNotExistException && retries > 0)
                {
                    await Ice.Promise.delay(20);
                }
                else
                {
                    throw ex;
                }
            }
        }

        out.write("catching object not exist exception... ");
        try
        {
            const thrower2 = Test.ThrowerPrx.uncheckedCast(
                thrower.ice_identity(Ice.stringToIdentity("does not exist")));
            await thrower2.ice_ping();
            test(false);
        }
        catch(ex)
        {
            test(ex instanceof Ice.ObjectNotExistException, ex);
            test(ex.id.equals(Ice.stringToIdentity("does not exist")));
        }
        out.writeLine("ok");

        out.write("catching facet not exist exception... ");
        try
        {
            const thrower2 = Test.ThrowerPrx.uncheckedCast(thrower, "no such facet");
            await thrower2.ice_ping();
            test(false);
        }
        catch(ex)
        {