public override Dictionary<string, int[]> opNDAIS(Dictionary<string, int[]> i,
                                                   out Dictionary<string, int[]> o,
                                                   Ice.Current current)
 {
     o = i;
     return i;
 }

    public override void pingBiDir(Ice.Identity id, Ice.Current current)
    {
        try
        {
            //
            // Ensure sending too much data doesn't cause the UDP connection
            // to be closed.
            //
            try
            {
                byte[] seq = new byte[32 * 1024];
                Test.TestIntfPrxHelper.uncheckedCast(current.con.createProxy(id)).sendByteSeq(seq, null);
            }
            catch(Ice.DatagramLimitException)
            {
                // Expected.
            }

            Test.PingReplyPrxHelper.uncheckedCast(current.con.createProxy(id)).reply();
        }
        catch(Ice.LocalException)
        {
            Debug.Assert(false);
        }
    }

    private static int run(string[] args, Ice.Communicator communicator)
    {
        System.Collections.Generic.List<int> ports = new System.Collections.Generic.List<int>();
        for(int i = 0; i < args.Length; i++)
        {
            int port = 0;
            try
            {
                port = System.Int32.Parse(args[i]);
            }
            catch(System.FormatException ex)
            {
                System.Console.Error.WriteLine(ex);
                return 1;
            }
            ports.Add(port);
        }

        if(ports.Count == 0)
        {
            System.Console.Error.WriteLine("Client: no ports specified");
            usage();
            return 1;
        }

        AllTests.allTests(communicator, ports);
        return 0;
    }

    public Ice.Object locate(Ice.Current current, out System.Object cookie)
    {
        lock(this)
        {
            test(!_deactivated);
        }

        test(current.id.category.Equals(_category) || _category.Length == 0);

        if(current.id.name.Equals("unknown"))
        {
            cookie = null;
            return null;
        }

        test(current.id.name.Equals("locate") || current.id.name.Equals("finished"));
        if(current.id.name.Equals("locate"))
        {
            exception(current);
        }

        //
        // Ensure locate() is only called once per request.
        //
        test(_requestId == -1);
        _requestId = current.requestId;

        cookie = new CookieI();

        return new TestI();
    }

 public override float getStatistics(Ferda.Modules.AbstractQuantifierSetting quantifierSetting, Ice.Current current__)
 {
     //Differences between EConfidence (a+d)/(a+b+c+d)
     return
         ((float)(
         quantifierSetting.firstContingencyTableRows[0][0] +
         quantifierSetting.firstContingencyTableRows[1][1]
         )
         /
         (float)(
         quantifierSetting.firstContingencyTableRows[0][0] +
         quantifierSetting.firstContingencyTableRows[0][1] +
         quantifierSetting.firstContingencyTableRows[1][0] +
         quantifierSetting.firstContingencyTableRows[1][1]
         ))
         -
         ((float)(
         quantifierSetting.secondContingencyTableRows[0][0] +
         quantifierSetting.secondContingencyTableRows[1][1]
         )
         /
         (float)(
         quantifierSetting.secondContingencyTableRows[0][0] +
         quantifierSetting.secondContingencyTableRows[0][1] +
         quantifierSetting.secondContingencyTableRows[1][0] +
         quantifierSetting.secondContingencyTableRows[1][1]
         ))
         ;
 }

 public override Dictionary<string, Dictionary<int, int>> opNDV(Dictionary<string, Dictionary<int, int>> i,
                                                                out Dictionary<string, Dictionary<int, int>> o,
                                                                Ice.Current current)
 {
     o = i;
     return i;
 }

 putOnHold(int milliSeconds, Ice.Current current)
 {
     if(milliSeconds < 0)
     {
         _adapter.hold();
     }
     else if(milliSeconds == 0)
     {
         _adapter.hold();
         _adapter.activate();
     }
     else
     {
         _timer.schedule(() =>
         {
             try
             {
                 putOnHold(0, null);
             }
             catch(Ice.ObjectAdapterDeactivatedException)
             {
             }
         }, milliSeconds);
     }
 }

 getConnectionObserver(Ice.ConnectionInfo ci, 
                       Ice.Endpoint ei, 
                       Ice.Instrumentation.ConnectionState s,
                       Ice.Instrumentation.ConnectionObserver o)
 {
     return null;
 }

 public ConnectionRequestHandler(Reference @ref, Ice.ConnectionI connection, bool compress)
 {
     _reference = @ref;
     _response = _reference.getMode() == Reference.Mode.ModeTwoway;
     _connection = connection;
     _compress = compress;
 }

 public override void ice_exception(Ice.Exception ex)
 {
     if (callback != null)
     {
         callback(new Result<bool>(ex));
     }
 }

 public ServiceManagerI(Ice.Communicator communicator, string[] args)
 {
     _communicator = communicator;
     _logger = _communicator.getLogger();
     _argv = args;
     _traceServiceObserver = _communicator.getProperties().getPropertyAsInt("IceBox.Trace.ServiceObserver");
 }

    public override Ice.DispatchStatus dispatch(Ice.Request request)
    {
        Ice.Current current = request.getCurrent();
        lastOperation_ = current.operation;

        if(lastOperation_.Equals("addWithRetry"))
        {
            for(int i = 0; i < 10; ++i)
            {
                try
                {
                    servant_.ice_dispatch(request);
                    test(false);
                }
                catch(Test.RetryException)
                {
                    //
                    // Expected, retry
                    //
                }
            }

            current.ctx["retry"] = "no";
        }

        lastStatus_ = servant_.ice_dispatch(request);
        return lastStatus_;
    }

 public override Dictionary<string, List<string>> opNDGSS(Dictionary<string, List<string>> i,
                                                          out Dictionary<string, List<string>> o,
                                                          Ice.Current current)
 {
     o = i;
     return i;
 }

 public override Dictionary<string, CSS> opNDCSS(Dictionary<string, CSS> i,
                                                 out Dictionary<string, CSS> o,
                                                 Ice.Current current)
 {
     o = i;
     return i;
 }

 public override void findAdapterById_async(Ice.AMD_Locator_findAdapterById response, string adapter,
                                            Ice.Current current)
 {
     _controller.checkCallPause(current);
     Ice.Communicator communicator = current.adapter.getCommunicator();
     response.ice_response(current.adapter.createDirectProxy(communicator.stringToIdentity("dummy")));
 }

 /// <summary>
 /// Creates a Glacier2 session.
 /// </summary>
 /// <param name="callback">The callback for notifications about session
 /// establishment.</param>
 /// <param name="initData">The Ice.InitializationData for initializing
 /// the communicator.</param>
 /// <param name="finderStr">The stringified Ice.RouterFinder proxy.</param>
 /// <param name="useCallbacks">True if the session should create an object adapter for receiving callbacks.</param>
 public SessionHelper(SessionCallback callback, Ice.InitializationData initData, string finderStr, bool useCallbacks)
 {
     _callback = callback;
     _initData = initData;
     _finderStr = finderStr;
     _useCallbacks = useCallbacks;
 }

    public static int run(string[] args, Ice.Communicator communicator, TextWriter @out)
    {
        //
        // When running as a MIDlet the properties for the server may be
        // overridden by configuration. If it isn't then we assume
        // defaults.
        //
        if(communicator.getProperties().getProperty("TestAdapter.Endpoints").Length == 0)
        {
            communicator.getProperties().setProperty("TestAdapter.Endpoints", "default -p 12010");
        }
        if(communicator.getProperties().getProperty("ControllerAdapter.Endpoints").Length == 0)
        {
            communicator.getProperties().setProperty("ControllerAdapter.Endpoints", "tcp -p 12011");
            communicator.getProperties().setProperty("ControllerAdapter.ThreadPool.Size", "1");
        }

        Ice.ObjectAdapter adapter = communicator.createObjectAdapter("TestAdapter");
        Ice.ObjectAdapter adapter2 = communicator.createObjectAdapter("ControllerAdapter");

        BackgroundControllerI backgroundController = new BackgroundControllerI(adapter);

        adapter.add(new BackgroundI(backgroundController), communicator.stringToIdentity("background"));
        adapter.add(new LocatorI(backgroundController), communicator.stringToIdentity("locator"));
        adapter.add(new RouterI(backgroundController), communicator.stringToIdentity("router"));
        adapter.activate();

        adapter2.add(backgroundController, communicator.stringToIdentity("backgroundController"));
        adapter2.activate();

        communicator.waitForShutdown();
        return 0;
    }

 opBatchCount(Ice.Current current)
 {
     lock(this)
     {
         return _batchCount;
     }
 }

 public override void holdAdapter(int to, Ice.Current current)
 {
     current.adapter.hold();
     ActivateAdapterThread act = new ActivateAdapterThread(current.adapter, to);
     Thread thread = new Thread(new ThreadStart(act.run));
     thread.Start();
 }

 //
 // Only for use by Instance.
 //
 internal ObjectAdapterFactory(Instance instance, Ice.Communicator communicator)
 {
     instance_ = instance;
     _communicator = communicator;
     _adapterNamesInUse = new HashSet<string>();
     _adapters = new List<Ice.ObjectAdapterI>();
 }