static void onEventConnected(RemoteObject* ro, qi::Future<SignalLink> fut, qi::Promise<SignalLink> prom, SignalLink id) {
   if (fut.hasError()) {
     prom.setError(fut.error());
     return;
   }
   prom.setValue(id);
 }

 void ServiceDirectoryClient::onSDEventConnected(qi::Future<SignalLink> future,
   qi::Promise<void> promise, bool isAdd)
 {
   if (promise.future().isFinished()) {
     return;
   }
   if (future.hasError())
   {
     qi::Future<void> fdc = onSocketDisconnected(future.error());
     fdc.connect(&qi::Promise<void>::setError, promise, future.error());
     return;
   }
   bool ready = false;
   {
     boost::mutex::scoped_lock lock(_mutex);
     if (isAdd)
       _addSignalLink = future.value();
     else
       _removeSignalLink = future.value();
     ready = _addSignalLink && _removeSignalLink;
   }
   if (ready)
   {
     promise.setValue(0);
     connected();
   }
 }

 void serviceReady(qi::Future<void> fut, qi::Promise<unsigned int> result, unsigned int idx) {
   if (fut.hasError()) {
     result.setError(fut.error());
     return;
   }
   result.setValue(idx);
 }

static void call_from_java_cont(qi::Future<qi::AnyReference> ret,
    qi::Promise<qi::AnyValue> promise)
{
  if (ret.hasError())
    promise.setError(ret.error());
  else
    promise.setValue(qi::AnyValue(ret.value(), false, true));
}

 void RemoteObject::onMetaObject(qi::Future<qi::MetaObject> fut, qi::Promise<void> prom) {
   if (fut.hasError()) {
     qiLogVerbose() << "MetaObject error: " << fut.error();
     prom.setError(fut.error());
     return;
   }
   qiLogVerbose() << "Fetched metaobject";
   setMetaObject(fut.value());
   prom.setValue(0);
 }

void slowDisconnect(qi::Promise<void> ready, qi::Promise<void> done, qi::Future<void> wait, qi::AnyObject obj, boost::shared_ptr<qi::SignalLink> link)
{
  ready.setValue(0);
  wait.wait();
  try {
    obj.disconnect(*link);
  }
  catch (...) {}
  done.setValue(0);
}

  void ObjectRegistrar::onFutureFinished(qi::Future<unsigned int> fut, long id, qi::Promise<unsigned int> result)
  {
    if (fut.hasError()) {
      result.setError(fut.error());
      return;
    }
    qi::ServiceInfo              si;
    RegisterServiceMap::iterator it;

    {
      boost::mutex::scoped_lock sl(_registerServiceRequestMutex);
      it = _registerServiceRequest.find(id);
      if (it != _registerServiceRequest.end())
        si = it->second.second;
      if (fut.hasError()) {
        _registerServiceRequest.erase(id);
        result.setError(fut.error());
        return;
      }
    }
    unsigned int idx = fut.value();
    si.setServiceId(idx);
    {
      boost::mutex::scoped_lock sl(_servicesMutex);
      BoundService bs;
      bs.id          = idx;
      bs.object      = it->second.first;
      bs.serviceInfo = si;
      bs.name        = si.name();
      BoundServiceMap::iterator it;
      it = _services.find(idx);
      if (it != _services.end()) {
        qiLogError() << "A service is already registered with that id:" << idx;
        result.setError("Service already registered.");
        return;
      }
      _services[idx] = bs;
      //todo register the object on the server (find a better way)
      Server::addObject(idx, bs.object);
    }

    {
      boost::mutex::scoped_lock sl(_serviceNameToIndexMutex);
      _serviceNameToIndex[si.name()] = idx;
    }
    {
      boost::mutex::scoped_lock sl(_registerServiceRequestMutex);
      _registerServiceRequest.erase(it);
    }

    // ack the Service directory to tell that we are ready
    qi::Future<void> fut2 = _sdClient->serviceReady(idx);
    fut2.connect(boost::bind(&serviceReady, _1, result, idx));
  }

  void SessionPrivate::listenStandaloneCont(qi::Promise<void> p, qi::Future<void> f)
  {
    if (f.hasError())
      p.setError(f.error());
    else
    {
      _sdClient.setServiceDirectory(boost::static_pointer_cast<ServiceBoundObject>(_sd._serviceBoundObject)->object());
      // _sdClient will trigger its connected, which will trigger our connected

      p.setValue(0);
    }
  }

  void SessionPrivate::onServiceTrackingCancelled(qi::Promise<void> promise,
      boost::shared_ptr<qi::Atomic<int> > link)
  {
    SignalLink link2 = link->swap(0);

    if (link2 == 0)
      return;

    _sdClient.serviceAdded.disconnect(link2);
    promise.setCanceled();
  }

 int f(int end, qi::Promise<void> finished)
 {
   int startval = prop.get();
   EXPECT_FALSE(calling);
   calling = true;
   qi::os::msleep(5);
   EXPECT_TRUE(calling);
   calling = false;
   EXPECT_EQ(startval, prop.get());
   if (++callcount == end + 1)
     finished.setValue(0);
   return 42;
 }

  void SessionPrivate::addSdSocketToCache(Future<void> f, const qi::Url& url,
                                          qi::Promise<void> p)
  {
    qiLogDebug() << "addSocketToCache processing";
    if (f.hasError())
    {
      qiLogDebug() << "addSdSocketToCache: connect reported failure";
      _serviceHandler.removeService("ServiceDirectory");
      p.setError(f.error());
      return;
    }

    // Allow the SD process to use the existing socket to talk to our services
    _serverObject.registerSocket(_sdClient.socket());

    /* Allow reusing the SD socket for communicating with services.
     * To do this, we must add it to our socket cache, and for this we need
     * to know the sd machineId
     */
     std::string mid;
     try
     {
       mid = _sdClient.machineId();
     }
     catch (const std::exception& e)
     { // Provide a nice message for backward compatibility
       qiLogVerbose() << e.what();
       qiLogWarning() << "Failed to obtain machineId, connection to service directory will not be reused for other services.";
       p.setValue(0);
       return;
     }
     TransportSocketPtr s = _sdClient.socket();
     qiLogVerbose() << "Inserting sd to cache for " << mid <<" " << url.str() << std::endl;
     _socketsCache.insert(mid, s->remoteEndpoint(), s);
     p.setValue(0);
  }

  void SessionPrivate::onTrackedServiceAdded(const std::string& actual,
      const std::string& expected,
      qi::Promise<void> promise,
      boost::shared_ptr<qi::Atomic<int> > link)
  {
    if (actual != expected)
      return;

    // only do it once in case of multiple calls
    SignalLink link2 = link->swap(0);

    if (link2 == 0)
      return;

    _sdClient.serviceAdded.disconnect(link2);

    promise.setValue(0);
  }

TEST(Test, Recurse)
{
  payload = qi::Promise<bool>();
  TestSessionPair       p1;
  TestSessionPair       p2(p1);
  qi::DynamicObjectBuilder     ob1, ob2;
  ob1.advertiseMethod("onFire1", &onFire1);
  ob2.advertiseMethod("onFire2", &onFire2);
  qi::AnyObject    oserver1(ob1.object()), oserver2(ob2.object());
  unsigned int           nbServices = TestMode::getTestMode() == TestMode::Mode_Nightmare ? 2 : 1;

  // Two objects with a fire event and a onFire method.
  ASSERT_NO_THROW(p1.server()->registerService("coin1", oserver1).hasValue(2000));
  ASSERT_NO_THROW(p2.server()->registerService("coin2", oserver2).hasValue(2000));
  EXPECT_EQ(nbServices, p1.server()->services(qi::Session::ServiceLocality_Local).value().size());
  EXPECT_EQ(nbServices, p2.server()->services(qi::Session::ServiceLocality_Local).value().size());
  oclient1 = p2.client()->service("coin1");
  oclient2 = p1.client()->service("coin2");
#ifdef WIN32
  int niter = 1000;
#else
  int niter = 1000;
#endif
  if (TestMode::getTestMode() == TestMode::Mode_SSL)
  {
    niter /= 100;
  }
  if (getenv("VALGRIND"))
  {
    std::cerr << "Valgrind detected, reducing iteration count" << std::endl;
    niter = 50;
  }
  oclient1.call<void>("onFire1", niter);
  ASSERT_NO_THROW(payload.future().hasValue(2000));
  oclient1.reset();
  oclient2.reset();
}

void producer(qi::Promise<int> pro) {
  qi::os::msleep(100);
  pro.setValue(42);
}

void unlock(qi::Promise<int> prom, bool* tag)
{
  *tag = true;
  prom.setValue(1);
}

void testDelete(bool afirst, bool disconnectFirst, qi::Promise<void> end)
{
  qi::Promise<void> p0;
  qi::Promise<void> p1;
  qi::SignalLink fireId, onFireId, onFireId2;
  qi::AnyObject *a;
  qi::AnyObject *b;
  {
    qi::DynamicObjectBuilder oba, obb;
    fireId = oba.advertiseSignal<int>("fire");
    onFireId = obb.advertiseMethod("onFire", boost::function<void(int)>(boost::bind<void>(&onFire, _1, boost::ref(p0))));
    onFireId2 = obb.advertiseMethod("onFire2", boost::function<void(int)>(boost::bind<void>(&onFire2, _1, boost::ref(p1))));
    a = new qi::AnyObject(oba.object());
    b = new qi::AnyObject(obb.object());
  }
  qi::SignalLink linkId = (*a).connect(fireId, *b, onFireId);
  (*a).connect(fireId, *b, onFireId2);
  //std::vector<qi::SignalSubscriber> subs = (*a)->subscribers(fireId);
  //EXPECT_EQ(static_cast<unsigned int>(2), subs.size());
  // Subs ordering is unspecified
  //EXPECT_EQ(subs[0].method + subs[1].method, onFireId + onFireId2);
  lastPayload = 11;
  lastPayload2 = 11;
  (*a).post("fire", 12);
  EXPECT_TRUE(p0.future().hasValue(1000));
  EXPECT_TRUE(p1.future().hasValue(1000));
  EXPECT_EQ(12, *lastPayload);
  EXPECT_EQ(12, *lastPayload2);
  p0 = qi::Promise<void>();
  p1 = qi::Promise<void>();
  if (disconnectFirst)
  {
    (*a).disconnect(linkId);
    (*a).post("fire", 13);
    EXPECT_TRUE(p1.future().hasValue(1000));
    EXPECT_EQ(12, *lastPayload);
    EXPECT_EQ(13, *lastPayload2);
    p0 = qi::Promise<void>();
    p1 = qi::Promise<void>();
  }
  if (afirst)
  {
    delete a;
    delete b;
  }
  else
  {
    int e1 = *lastPayload, e2 = *lastPayload2;
    delete b;
    // wait for the object to be deleted (signal callbacks may still be
    // running)
    qi::os::msleep(10);
    (*a).post("fire", 12);
    EXPECT_EQ(e1, *lastPayload);
    EXPECT_EQ(e2, *lastPayload2);
    delete a;
  }
  ++completed;
  int next = *completed;
  if (next == 4)
  {
    end.setValue(0);
    return;
  }
  qi::getEventLoop()->post(
    boost::bind(&testDelete, !!((int)next/2), !!((int)next%2), end));
}

void onFire2(const int& pl, qi::Promise<void>& p)
{
  ++lastPayload2;
  p.setValue(0);
}

 void log(const qi::LogLevel,
          const qi::Clock::time_point,
          const qi::SystemClock::time_point,
          const char*,
          const char*,
          const char*,
          const char*,
          int) {
   start.future().wait();
   if (++count == MAX)
     finished.setValue(0);
 }

 void operator()(int newValue)
 {
   if (newValue == targetValue)
   {
     running.setValue(true);
   }
 }

void onFire2(const int& pl)
{
  if (pl)
    oclient1.async<void>("onFire1", pl-1);
  else
    payload.setValue(true);
}