1 files changed, 4 insertions, 4 deletions
diff --git a/Swiften/Component/UnitTest/ComponentSessionTest.cpp b/Swiften/Component/UnitTest/ComponentSessionTest.cpp
index 0533645..79d9ab3 100644
--- a/Swiften/Component/UnitTest/ComponentSessionTest.cpp
+++ b/Swiften/Component/UnitTest/ComponentSessionTest.cpp
@@ -1,37 +1,37 @@
 /*
- * Copyright (c) 2010-2013 Remko Tronçon
+ * Copyright (c) 2010-2014 Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #include <cppunit/extensions/HelperMacros.h>
 #include <cppunit/extensions/TestFactoryRegistry.h>
 #include <deque>
 #include <boost/bind.hpp>
 #include <boost/optional.hpp>
 
 #include <Swiften/Session/SessionStream.h>
 #include <Swiften/Component/ComponentSession.h>
 #include <Swiften/Elements/ComponentHandshake.h>
 #include <Swiften/Elements/AuthFailure.h>
 #include <Swiften/Crypto/CryptoProvider.h>
 #include <Swiften/Crypto/PlatformCryptoProvider.h>
 
 using namespace Swift;
 
 class ComponentSessionTest : public CppUnit::TestFixture {
 		CPPUNIT_TEST_SUITE(ComponentSessionTest);
 		CPPUNIT_TEST(testStart);
 		CPPUNIT_TEST(testStart_Error);
 		CPPUNIT_TEST(testStart_Unauthorized);
 		CPPUNIT_TEST_SUITE_END();
 
 	public:
 		void setUp() {
 			server = boost::make_shared<MockSessionStream>();
 			sessionFinishedReceived = false;
 			crypto = boost::shared_ptr<CryptoProvider>(PlatformCryptoProvider::create());
 		}
 
 		void testStart() {
 			boost::shared_ptr<ComponentSession> session(createSession());
@@ -54,99 +54,99 @@ class ComponentSessionTest : public CppUnit::TestFixture {
 			server->breakConnection();
 
 			CPPUNIT_ASSERT_EQUAL(ComponentSession::Finished, session->getState());
 			CPPUNIT_ASSERT(sessionFinishedReceived);
 			CPPUNIT_ASSERT(sessionFinishedError);
 		}
 
 		void testStart_Unauthorized() {
 			boost::shared_ptr<ComponentSession> session(createSession());
 			session->start();
 			server->receiveStreamStart();
 			server->sendStreamStart();
 			server->receiveHandshake();
 			server->sendHandshakeError();
 
 			CPPUNIT_ASSERT_EQUAL(ComponentSession::Finished, session->getState());
 			CPPUNIT_ASSERT(sessionFinishedReceived);
 			CPPUNIT_ASSERT(sessionFinishedError);
 		}
 
 	private:
 		boost::shared_ptr<ComponentSession> createSession() {
 			boost::shared_ptr<ComponentSession> session = ComponentSession::create(JID("service.foo.com"), "servicesecret", server, crypto.get());
 			session->onFinished.connect(boost::bind(&ComponentSessionTest::handleSessionFinished, this, _1));
 			return session;
 		}
 
 		void handleSessionFinished(boost::shared_ptr<Error> error) {
 			sessionFinishedReceived = true;
 			sessionFinishedError = error;
 		}
 
 		class MockSessionStream : public SessionStream {
 			public:
 				struct Event {
-					Event(boost::shared_ptr<Element> element) : element(element), footer(false) {}
+					Event(boost::shared_ptr<ToplevelElement> element) : element(element), footer(false) {}
 					Event(const ProtocolHeader& header) : header(header), footer(false) {}
 					Event() : footer(true) {}
 					
-					boost::shared_ptr<Element> element;
+					boost::shared_ptr<ToplevelElement> element;
 					boost::optional<ProtocolHeader> header;
 					bool footer;
 				};
 
 				MockSessionStream() : available(true), whitespacePingEnabled(false), resetCount(0) {
 				}
 
 				virtual void close() {
 					onClosed(boost::shared_ptr<Error>());
 				}
 
 				virtual bool isOpen() {
 					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) {
+				virtual void writeElement(boost::shared_ptr<ToplevelElement> element) {
 					receivedEvents.push_back(Event(element));
 				}
 
 				virtual void writeData(const std::string&) {
 				}
 
 				virtual bool supportsTLSEncryption() {
 					return false;
 				}
 
 				virtual void addTLSEncryption() {
 					assert(false);
 				}
 
 				virtual bool isTLSEncrypted() {
 					return false;
 				}
 
 				virtual ByteArray getTLSFinishMessage() const {
 					return ByteArray();
 				}
 
 				virtual Certificate::ref getPeerCertificate() const {
 					return Certificate::ref();
 				}
 
 				virtual std::vector<Certificate::ref> getPeerCertificateChain() const {
 					 return std::vector<Certificate::ref>();
 				}
 
 				virtual boost::shared_ptr<CertificateVerificationError> getPeerCertificateVerificationError() const {
 					return boost::shared_ptr<CertificateVerificationError>();
 				}
 
 				virtual bool supportsZLibCompression() {