1 files changed, 6 insertions, 1 deletions
diff --git a/Swiften/Client/UnitTest/ClientSessionTest.cpp b/Swiften/Client/UnitTest/ClientSessionTest.cpp
index 9fe2a3d..e035ba3 100644
--- a/Swiften/Client/UnitTest/ClientSessionTest.cpp
+++ b/Swiften/Client/UnitTest/ClientSessionTest.cpp
@@ -128,209 +128,214 @@ class ClientSessionTest : public CppUnit::TestFixture {
 			server->sendAuthFailure();
 
 			CPPUNIT_ASSERT_EQUAL(ClientSession::Finished, session->getState());
 			CPPUNIT_ASSERT(sessionFinishedReceived);
 			CPPUNIT_ASSERT(sessionFinishedError);
 		}
 
 		void testAuthenticate_NoValidAuthMechanisms() {
 			boost::shared_ptr<ClientSession> session(createSession());
 			session->start();
 			server->receiveStreamStart();
 			server->sendStreamStart();
 			server->sendStreamFeaturesWithUnknownAuthentication();
 
 			CPPUNIT_ASSERT_EQUAL(ClientSession::Finished, session->getState());
 			CPPUNIT_ASSERT(sessionFinishedReceived);
 			CPPUNIT_ASSERT(sessionFinishedError);
 		}
 
 	private:
 		boost::shared_ptr<ClientSession> createSession() {
 			boost::shared_ptr<ClientSession> session = ClientSession::create(JID("me@foo.com"), server);
 			session->onFinished.connect(boost::bind(&ClientSessionTest::handleSessionFinished, this, _1));
 			session->onNeedCredentials.connect(boost::bind(&ClientSessionTest::handleSessionNeedCredentials, this));
 			return session;
 		}
 
 		void handleSessionFinished(boost::shared_ptr<Error> error) {
 			sessionFinishedReceived = true;
 			sessionFinishedError = error;
 		}
 
 		void handleSessionNeedCredentials() {
 			needCredentials = true;
 		}
 
 		class MockSessionStream : public SessionStream {
 			public:
 				struct Event {
 					Event(boost::shared_ptr<Element> element) : element(element), footer(false) {}
 					Event(const ProtocolHeader& header) : header(header), footer(false) {}
 					Event() : footer(true) {}
 					
 					boost::shared_ptr<Element> element;
 					boost::optional<ProtocolHeader> header;
 					bool footer;
 				};
 
-				MockSessionStream() : available(true), canTLSEncrypt(true), tlsEncrypted(false), whitespacePingEnabled(false), resetCount(0) {
+				MockSessionStream() : available(true), canTLSEncrypt(true), tlsEncrypted(false), compressed(false), whitespacePingEnabled(false), resetCount(0) {
 				}
 
 				virtual bool isAvailable() {
 					return available;
 				}
 
 				virtual void writeHeader(const ProtocolHeader& header) {
 					receivedEvents.push_back(Event(header));
 				}
 
 				virtual void writeFooter() {
 					receivedEvents.push_back(Event());
 				}
 
 				virtual void writeElement(boost::shared_ptr<Element> element) {
 					receivedEvents.push_back(Event(element));
 				}
 
 				virtual bool supportsTLSEncryption() {
 					return canTLSEncrypt;
 				}
 
 				virtual void addTLSEncryption() {
 					tlsEncrypted = true;
 				}
 
+				virtual void addZLibCompression() {
+					compressed = true;
+				}
+
 				virtual void setWhitespacePingEnabled(bool enabled) {
 					whitespacePingEnabled = enabled;
 				}
 
 				virtual void resetXMPPParser() {
 					resetCount++;
 				}
 
 				void breakConnection() {
 					onError(boost::shared_ptr<SessionStream::Error>(new SessionStream::Error(SessionStream::Error::ConnectionReadError)));
 				}
 
 				void breakTLS() {
 					onError(boost::shared_ptr<SessionStream::Error>(new SessionStream::Error(SessionStream::Error::TLSError)));
 				}
 
 
 				void sendStreamStart() {
 					ProtocolHeader header;
 					header.setTo("foo.com");
 					return onStreamStartReceived(header);
 				}
 
 				void sendStreamFeaturesWithStartTLS() {
 					boost::shared_ptr<StreamFeatures> streamFeatures(new StreamFeatures());
 					streamFeatures->setHasStartTLS();
 					onElementReceived(streamFeatures);
 				}
 
 				void sendTLSProceed() {
 					onElementReceived(boost::shared_ptr<TLSProceed>(new TLSProceed()));
 				}
 
 				void sendTLSFailure() {
 					onElementReceived(boost::shared_ptr<StartTLSFailure>(new StartTLSFailure()));
 				}
 
 				void sendStreamFeaturesWithPLAINAuthentication() {
 					boost::shared_ptr<StreamFeatures> streamFeatures(new StreamFeatures());
 					streamFeatures->addAuthenticationMechanism("PLAIN");
 					onElementReceived(streamFeatures);
 				}
 
 				void sendStreamFeaturesWithUnknownAuthentication() {
 					boost::shared_ptr<StreamFeatures> streamFeatures(new StreamFeatures());
 					streamFeatures->addAuthenticationMechanism("UNKNOWN");
 					onElementReceived(streamFeatures);
 				}
 
 				void sendAuthSuccess() {
 					onElementReceived(boost::shared_ptr<AuthSuccess>(new AuthSuccess()));
 				}
 
 				void sendAuthFailure() {
 					onElementReceived(boost::shared_ptr<AuthFailure>(new AuthFailure()));
 				}
 
 				void receiveStreamStart() {
 					Event event = popEvent();
 					CPPUNIT_ASSERT(event.header);
 				}
 
 				void receiveStartTLS() {
 					Event event = popEvent();
 					CPPUNIT_ASSERT(event.element);
 					CPPUNIT_ASSERT(boost::dynamic_pointer_cast<StartTLSRequest>(event.element));
 				}
 
 				void receiveAuthRequest(const String& mech) {
 					Event event = popEvent();
 					CPPUNIT_ASSERT(event.element);
 					boost::shared_ptr<AuthRequest> request(boost::dynamic_pointer_cast<AuthRequest>(event.element));
 					CPPUNIT_ASSERT(request);
 					CPPUNIT_ASSERT_EQUAL(mech, request->getMechanism());
 				}
 
 				Event popEvent() {
 					CPPUNIT_ASSERT(receivedEvents.size() > 0);
 					Event event = receivedEvents.front();
 					receivedEvents.pop_front();
 					return event;
 				}
 
 				bool available;
 				bool canTLSEncrypt;
 				bool tlsEncrypted;
+				bool compressed;
 				bool whitespacePingEnabled;
 				int resetCount;
 				std::deque<Event> receivedEvents;
 		};
 
 		boost::shared_ptr<MockSessionStream> server;
 		bool sessionFinishedReceived;
 		bool needCredentials;
 		boost::shared_ptr<Error> sessionFinishedError;
 };
 
 CPPUNIT_TEST_SUITE_REGISTRATION(ClientSessionTest);
 
 #if 0
 		void testAuthenticate() {
 			boost::shared_ptr<MockSession> session(createSession("me@foo.com/Bar"));
 			session->onNeedCredentials.connect(boost::bind(&ClientSessionTest::setNeedCredentials, this));
 			getMockServer()->expectStreamStart();
 			getMockServer()->sendStreamStart();
 			getMockServer()->sendStreamFeaturesWithAuthentication();
 			session->startSession();
 			processEvents();
 			CPPUNIT_ASSERT_EQUAL(ClientSession::WaitingForCredentials, session->getState());
 			CPPUNIT_ASSERT(needCredentials_);
 
 			getMockServer()->expectAuth("me", "mypass");
 			getMockServer()->sendAuthSuccess();
 			getMockServer()->expectStreamStart();
 			getMockServer()->sendStreamStart();
 			session->sendCredentials("mypass");
 			CPPUNIT_ASSERT_EQUAL(ClientSession::Authenticating, session->getState());
 			processEvents();
 			CPPUNIT_ASSERT_EQUAL(ClientSession::Negotiating, session->getState());
 		}
 
 		void testAuthenticate_Unauthorized() {
 			boost::shared_ptr<MockSession> session(createSession("me@foo.com/Bar"));
 			getMockServer()->expectStreamStart();
 			getMockServer()->sendStreamStart();
 			getMockServer()->sendStreamFeaturesWithAuthentication();
 			session->startSession();
 			processEvents();
 
 			getMockServer()->expectAuth("me", "mypass");
 			getMockServer()->sendAuthFailure();
 			session->sendCredentials("mypass");
 			processEvents();