void closeStreamRun(bool fork, bool doSleep=false) {
        using std::tr1::placeholders::_1;
        using std::tr1::placeholders::_2;

        for(int i=0;i<NUM_TEST_STREAMS;++i) {
            mReceivers[i]=mSenders[i]=NULL;
            mSendReceiveMap[i]=-1;
            mReceiversData[i]=0;
        }

        for(int i=0;i<NUM_TEST_STREAMS;++i) {
            if (i==0||!fork) {
                mSenders[i]=StreamFactory::getSingleton().getDefaultConstructor()(mSendStrand,StreamFactory::getSingleton().getDefaultOptionParser()(String("--parallel-sockets=1")));
                mSenders[i]->connect(Address("127.0.0.1",mPort),
                                     &Stream::ignoreSubstreamCallback,
                                     std::tr1::bind(&SstCloseTest::connectionCallback,this,i,_1,_2),
                                     &Stream::ignoreReceivedCallback,
                                     &Stream::ignoreReadySendCallback);
            }else {
                mSenders[i]=mSenders[0]->clone(  std::tr1::bind(&SstCloseTest::connectionCallback,this,i,_1,_2),
                                     &Stream::ignoreReceivedCallback,
                                     &Stream::ignoreReadySendCallback);

            }

        }
        mSendService->reset();
        mSendService->run();
#ifdef _WIN32
        //Sleep(1000);
#else
        sleep(1);
#endif

        int sentSoFar=0;
        for (int c=0;c<mChunks;++c) {
            int willHaveSent=(c+1)*mBytes/mChunks;

            Chunk cur(willHaveSent-sentSoFar);
            for (size_t j=0;j<cur.size();++j) {
                cur[j]=j+sentSoFar;
            }
            for (int i=0;i<NUM_TEST_STREAMS;++i) {
                if (cur.size()) {
                    cur[0]=i%256;
                    if (cur.size()>1) {
                        cur[1]=i/256%256;
                    }
                    if (cur.size()>2) {
                        cur[2]=i/256/256%256;
                    }
                    if (cur.size()>3) {
                        cur[3]=i/256/256/256%256;
                    }
                }
                bool retval=mSenders[i]->send(MemoryReference(cur),ReliableUnordered);
                TS_ASSERT(retval);

            }
            if (doSleep) {
#ifdef _WIN32
                Sleep(1000);
#else
//                sleep(1);
#endif
            }
            sentSoFar=willHaveSent;
        }
        if (!doSleep) {
#ifdef _WIN32
            Sleep(1000);
#else
//            sleep(1);
#endif
        }
        //SILOG(tcpsst,error,"CLOSING");
        for (int i=mOffset;i<NUM_TEST_STREAMS;++i) {
            mSenders[i]->close();
        }
        //SILOG(tcpsst,error,"CLOSED");
        bool done=true;
        int counter=0;
        do {
            done=true;
            for (int i=mOffset;i<NUM_TEST_STREAMS;++i) {
                if (mReceiversData[i].read()!=mBytes*2+1) {
                    done=false;
                    if (counter>4998) {
                        SILOG(ssttest,error,"Data "<<i<<" only "<<mReceiversData[i].read()<<" != "<<mBytes*2+1);
                    }
                }
            }
            if (counter>4997&&!done) {
#ifdef _WIN32
                Sleep(1000);
#else
                sleep (1);
#endif
            }
            ++counter;
        }while (counter<5000&&!done);
        TS_ASSERT(done);
        for (int i=0;i<NUM_TEST_STREAMS;++i) {
            delete mSenders[i];
            mSenders[i]=NULL;
        }
        for (int i=0;i<NUM_TEST_STREAMS;++i) {
            delete mReceivers[i];
            mReceivers[i]=NULL;
        }
    }