1 files changed, 11 insertions, 2 deletions
diff --git a/Swiften/QA/FileTransferTest/FileTransferTest.cpp b/Swiften/QA/FileTransferTest/FileTransferTest.cpp
index 13b6eff..8597033 100644
--- a/Swiften/QA/FileTransferTest/FileTransferTest.cpp
+++ b/Swiften/QA/FileTransferTest/FileTransferTest.cpp
@@ -69,62 +69,61 @@ class FileTransferTest {
 			options.useAcks = false;
 
 			sender_->connect(options);
 			receiver_->connect(options);
 
 			timeOut_ = networkFactories->getTimerFactory()->createTimer(60000);
 			timeOut_->onTick.connect(boost::bind(&FileTransferTest::handleTimeOut, this));
 
 			// Create randomly sized data to exchange.
 			sendFilePath_ = boost::filesystem::unique_path("ft_send_%%%%%%%%%%%%%%%%.bin");
 			receiveFilePath_ = boost::filesystem::unique_path("ft_receive_%%%%%%%%%%%%%%%%.bin");
 
 			size_t size = 1024 + boost::numeric_cast<size_t>(randGen.generateRandomInteger(1024 * 10));
 			sendData_.resize(size);
 			for (size_t n = 0; n < sendData_.size(); n++) {
 				sendData_[n] = boost::numeric_cast<unsigned char>(randGen.generateRandomInteger(255));
 			}
 
 			std::ofstream outfile(sendFilePath_.native().c_str(), std::ios::out | std::ios::binary);
 			outfile.write(reinterpret_cast<char *>(&sendData_[0]), boost::numeric_cast<ptrdiff_t>(sendData_.size()));
 			outfile.close();
 		}
 
 		~FileTransferTest() {
 			timeOut_->stop();
 
 			delete senderTracer_;
 			delete receiverTracer_;
 
 			// Free file-transfer objects so file handles are closed and files can be removed afterwards.
-			incomingFileTransfers_.clear();
-			outgoingFileTransfer_.reset();
+			assert(!outgoingFileTransfer_ && incomingFileTransfers_.empty());
 
 			if(boost::filesystem::exists(sendFilePath_)) {
 				boost::filesystem::remove(sendFilePath_);
 			}
 
 			if(boost::filesystem::exists(receiveFilePath_)) {
 				boost::filesystem::remove(receiveFilePath_);
 			}
 		}
 
 		void handleSenderConnected() {
 			sender_->sendPresence(Presence::create());
 		}
 
 		void handleReceiverConnected() {
 			receiver_->getFileTransferManager()->onIncomingFileTransfer.connect(boost::bind(&FileTransferTest::handleReceiverIncomingFileTransfer, this, _1));
 
 			DiscoInfo discoInfo;
 			discoInfo.addIdentity(DiscoInfo::Identity(CLIENT_NAME, "client", "pc"));
 			discoInfo.addFeature(DiscoInfo::JingleFeature);
 			discoInfo.addFeature(DiscoInfo::JingleFTFeature);
 			discoInfo.addFeature(DiscoInfo::Bytestream);
 			discoInfo.addFeature(DiscoInfo::JingleTransportsIBBFeature);
 			discoInfo.addFeature(DiscoInfo::JingleTransportsS5BFeature);
 			receiver_->getDiscoManager()->setCapsNode(CLIENT_NODE);
 			receiver_->getDiscoManager()->setDiscoInfo(discoInfo);
 			receiver_->getPresenceSender()->sendPresence(Presence::create());
 		}
 
 		void handleReceiverIncomingFileTransfer(IncomingFileTransfer::ref transfer) {
@@ -162,70 +161,80 @@ class FileTransferTest {
 				std::cout << "S5B Proxied (" << options.isProxiedAllowed() << ")" << std::endl;
 
 				outgoingFileTransfer_ = sender_->getFileTransferManager()->createOutgoingFileTransfer(jid.toBare(), sendFilePath_, "Some File!", fileStream, options);
 
 				if (outgoingFileTransfer_) {
 					outgoingFileTransfer_->onFinished.connect(boost::bind(&FileTransferTest::handleSenderFileTransferFinished, this, _1));
 					outgoingFileTransfer_->start();
 				} else {
 					std::cout << "ERROR: No outgoing file transfer returned." << std::endl;
 					endTest();
 				}
 			}
 		}
 
 		void handleReceiverFileTransferFinished(const boost::optional<FileTransferError>& error, boost::shared_ptr<FileWriteBytestream> out) {
 			out->close();
 			receiverError_ = error;
 			receiverIsDone_ = true;
 			if (senderIsDone_) {
 				timeOut_->stop();
 				timeOut_ = networkFactories->getTimerFactory()->createTimer(1000);
 				timeOut_->onTick.connect(boost::bind(&FileTransferTest::endTest, this));
 				timeOut_->start();
 			}
 		}
 
 		void handleSenderDisconnected(const boost::optional<ClientError>& error) {
 			if (error) {
 				std::cout << this << " " << "handleSenderDisconnected: error: " << error.get() << std::endl;
 			}
+
+			// All file-transfers related to a Client instance need to be freed
+			// *before* freeing the Client instance.
+			outgoingFileTransfer_.reset();
+
 			sender_.reset();
 			if (!sender_ && !receiver_) {
 				eventLoop->stop();
 			}
 		}
 
 		void handleReceiverDisconnected(const boost::optional<ClientError>& error) {
 			if (error) {
 				std::cout << this << " " << "handleReceiverDisconnected: error: " << error.get() << std::endl;
 			}
+
+			// All file-transfers related to a Client instance need to be freed
+			// *before* freeing the Client instance.
+			incomingFileTransfers_.clear();
+
 			receiver_.reset();
 			if (!sender_ && !receiver_) {
 				eventLoop->stop();
 			}
 		}
 
 		void handleSenderFileTransferFinished(const boost::optional<FileTransferError>& error) {
 			senderError_ = error;
 			senderIsDone_ = true;
 			if (receiverIsDone_) {
 				timeOut_->stop();
 				timeOut_ = networkFactories->getTimerFactory()->createTimer(1000);
 				timeOut_->onTick.connect(boost::bind(&FileTransferTest::endTest, this));
 				timeOut_->start();
 			}
 		}
 
 		void run() {
 			timeOut_->start();
 			eventLoop->run();
 		}
 
 		void endTest() {
 			if (sender_) {
 				sender_->disconnect();
 			}
 			if (receiver_) {
 				receiver_->disconnect();
 			}
 		}