2 files changed, 5 insertions, 5 deletions
diff --git a/Swiften/StreamStack/UnitTest/StreamStackTest.cpp b/Swiften/StreamStack/UnitTest/StreamStackTest.cpp
index 213948a..35146d6 100644
--- a/Swiften/StreamStack/UnitTest/StreamStackTest.cpp
+++ b/Swiften/StreamStack/UnitTest/StreamStackTest.cpp
@@ -1,37 +1,37 @@
 /*
- * Copyright (c) 2010 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 <Swiften/Base/ByteArray.h>
 #include <QA/Checker/IO.h>
 
 #include <vector>
 #include <boost/bind.hpp>
 #include <boost/smart_ptr.hpp>
 #include <cppunit/extensions/HelperMacros.h>
 #include <cppunit/extensions/TestFactoryRegistry.h>
 
 #include <Swiften/Base/ByteArray.h>
 #include <Swiften/Base/Concat.h>
 #include <Swiften/StreamStack/StreamStack.h>
 #include <Swiften/StreamStack/LowLayer.h>
 #include <Swiften/StreamStack/XMPPLayer.h>
 #include <Swiften/StreamStack/StreamLayer.h>
 #include <Swiften/Parser/PlatformXMLParserFactory.h>
 #include <Swiften/Parser/PayloadParsers/FullPayloadParserFactoryCollection.h>
 #include <Swiften/Serializer/PayloadSerializers/FullPayloadSerializerCollection.h>
 
 using namespace Swift;
 
 class StreamStackTest : public CppUnit::TestFixture {
 		CPPUNIT_TEST_SUITE(StreamStackTest);
 		CPPUNIT_TEST(testWriteData_NoIntermediateStreamStack);
 		CPPUNIT_TEST(testWriteData_OneIntermediateStream);
 		CPPUNIT_TEST(testWriteData_TwoIntermediateStreamStack);
 		CPPUNIT_TEST(testReadData_NoIntermediateStreamStack);
 		CPPUNIT_TEST(testReadData_OneIntermediateStream);
 		CPPUNIT_TEST(testReadData_TwoIntermediateStreamStack);
 		CPPUNIT_TEST(testAddLayer_ExistingOnWriteDataSlot);
 		CPPUNIT_TEST_SUITE_END();
@@ -94,71 +94,71 @@ class StreamStackTest : public CppUnit::TestFixture {
 		void testReadData_OneIntermediateStream() {
 			StreamStack testling(xmppStream_, physicalStream_);
 			xmppStream_->onElement.connect(boost::bind(&StreamStackTest::handleElement, this, _1));
 			boost::shared_ptr<MyStreamLayer> xStream(new MyStreamLayer("<"));
 			testling.addLayer(xStream.get());
 
 			physicalStream_->onDataRead(createSafeByteArray("stream:stream xmlns:stream='http://etherx.jabber.org/streams'><presence/>"));
 
 			CPPUNIT_ASSERT_EQUAL(1, elementsReceived_);
 		}
 
 		void testReadData_TwoIntermediateStreamStack() {
 			StreamStack testling(xmppStream_, physicalStream_);
 			xmppStream_->onElement.connect(boost::bind(&StreamStackTest::handleElement, this, _1));
 			boost::shared_ptr<MyStreamLayer> xStream(new MyStreamLayer("s"));
 			boost::shared_ptr<MyStreamLayer> yStream(new MyStreamLayer("<"));
 			testling.addLayer(xStream.get());
 			testling.addLayer(yStream.get());
 
 			physicalStream_->onDataRead(createSafeByteArray("tream:stream xmlns:stream='http://etherx.jabber.org/streams'><presence/>"));
 
 			CPPUNIT_ASSERT_EQUAL(1, elementsReceived_);
 		}
 
 		void testAddLayer_ExistingOnWriteDataSlot() {
 			StreamStack testling(xmppStream_, physicalStream_);
 			xmppStream_->onWriteData.connect(boost::bind(&StreamStackTest::handleWriteData, this, _1));
 			boost::shared_ptr<MyStreamLayer> xStream(new MyStreamLayer("X"));
 			testling.addLayer(xStream.get());
 
 			xmppStream_->writeData("foo");
 
 			CPPUNIT_ASSERT_EQUAL(1, dataWriteReceived_);
 		}
 
-		void handleElement(boost::shared_ptr<Element>) {
+		void handleElement(boost::shared_ptr<ToplevelElement>) {
 			++elementsReceived_;
 		}
 
 		void handleWriteData(const SafeByteArray&) {
 			++dataWriteReceived_;
 		}
 
 	private:
 		class MyStreamLayer : public StreamLayer {
 			public:
 				MyStreamLayer(const std::string& prepend) : prepend_(prepend) {
 				}
 
 				virtual void writeData(const SafeByteArray& data) {
 					writeDataToChildLayer(concat(createSafeByteArray(prepend_), data));
 				}
 
 				virtual void handleDataRead(const SafeByteArray& data) {
 					writeDataToParentLayer(concat(createSafeByteArray(prepend_), data));
 				}
 
 			private:
 				std::string prepend_;
 		};
 
 		class TestLowLayer : public LowLayer {
 			public:
 				TestLowLayer() {
 				}
 
 				virtual void writeData(const SafeByteArray& data) {
 					data_.push_back(data);
 				}
 
 				void onDataRead(const SafeByteArray& data) {
diff --git a/Swiften/StreamStack/UnitTest/XMPPLayerTest.cpp b/Swiften/StreamStack/UnitTest/XMPPLayerTest.cpp
index a6098f1..ced9ec3 100644
--- a/Swiften/StreamStack/UnitTest/XMPPLayerTest.cpp
+++ b/Swiften/StreamStack/UnitTest/XMPPLayerTest.cpp
@@ -1,37 +1,37 @@
 /*
- * Copyright (c) 2010 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 <vector>
 #include <boost/bind.hpp>
 #include <cppunit/extensions/HelperMacros.h>
 #include <cppunit/extensions/TestFactoryRegistry.h>
 
 #include <Swiften/Elements/ProtocolHeader.h>
 #include <Swiften/Elements/Presence.h>
 #include <Swiften/Base/ByteArray.h>
 #include <Swiften/StreamStack/XMPPLayer.h>
 #include <Swiften/StreamStack/LowLayer.h>
 #include <Swiften/Parser/PlatformXMLParserFactory.h>
 #include <Swiften/Parser/PayloadParsers/FullPayloadParserFactoryCollection.h>
 #include <Swiften/Serializer/PayloadSerializers/FullPayloadSerializerCollection.h>
 
 using namespace Swift;
 
 class XMPPLayerTest : public CppUnit::TestFixture {
 		CPPUNIT_TEST_SUITE(XMPPLayerTest);
 		CPPUNIT_TEST(testParseData_Error);
 		CPPUNIT_TEST(testResetParser);
 		CPPUNIT_TEST(testResetParser_FromSlot);
 		CPPUNIT_TEST(testWriteHeader);
 		CPPUNIT_TEST(testWriteElement);
 		CPPUNIT_TEST(testWriteFooter);
 		CPPUNIT_TEST_SUITE_END();
 
 	public:
 		void setUp() {
 			lowLayer_ = new DummyLowLayer();
 			testling_ = new XMPPLayerExposed(&parserFactories_, &serializers_, &xmlParserFactory_, ClientStreamType);
 			testling_->setChildLayer(lowLayer_);
@@ -62,75 +62,75 @@ class XMPPLayerTest : public CppUnit::TestFixture {
 			testling_->handleDataRead(createSafeByteArray("<presence/>"));
 
 			CPPUNIT_ASSERT_EQUAL(1, elementsReceived_);
 			CPPUNIT_ASSERT_EQUAL(0, errorReceived_);
 		}
 
 		void testResetParser_FromSlot() {
 			testling_->onElement.connect(boost::bind(&XMPPLayerTest::handleElementAndReset, this, _1));
 			testling_->handleDataRead(createSafeByteArray("<stream:stream to=\"example.com\" xmlns=\"jabber:client\" xmlns:stream=\"http://etherx.jabber.org/streams\" ><presence/>"));
 			testling_->handleDataRead(createSafeByteArray("<stream:stream to=\"example.com\" xmlns=\"jabber:client\" xmlns:stream=\"http://etherx.jabber.org/streams\" ><presence/>"));
 
 			CPPUNIT_ASSERT_EQUAL(2, elementsReceived_);
 			CPPUNIT_ASSERT_EQUAL(0, errorReceived_);
 		}
 
 		void testWriteHeader() {
 			ProtocolHeader header;
 			header.setTo("example.com");
 			testling_->writeHeader(header);
 
 			CPPUNIT_ASSERT_EQUAL(std::string("<?xml version=\"1.0\"?><stream:stream xmlns=\"jabber:client\" xmlns:stream=\"http://etherx.jabber.org/streams\" to=\"example.com\" version=\"1.0\">"), lowLayer_->writtenData);
 		}
 
 		void testWriteElement() {
 			testling_->writeElement(boost::make_shared<Presence>());
 
 			CPPUNIT_ASSERT_EQUAL(std::string("<presence/>"), lowLayer_->writtenData);
 		}
 
 		void testWriteFooter() {
 			testling_->writeFooter();
 
 			CPPUNIT_ASSERT_EQUAL(std::string("</stream:stream>"), lowLayer_->writtenData);
 		}
 
-		void handleElement(boost::shared_ptr<Element>) {
+		void handleElement(boost::shared_ptr<ToplevelElement>) {
 			++elementsReceived_;
 		}
 
-		void handleElementAndReset(boost::shared_ptr<Element>) {
+		void handleElementAndReset(boost::shared_ptr<ToplevelElement>) {
 			++elementsReceived_;
 			testling_->resetParser();
 		}
 
 		void handleError() {
 			++errorReceived_;
 		}
 
 	private:
 		class XMPPLayerExposed : public XMPPLayer {
 			public:
 				XMPPLayerExposed(
 								PayloadParserFactoryCollection* payloadParserFactories,
 								PayloadSerializerCollection* payloadSerializers,
 								XMLParserFactory* xmlParserFactory,
 								StreamType streamType) : XMPPLayer(payloadParserFactories, payloadSerializers, xmlParserFactory, streamType) {}
 
 				using XMPPLayer::handleDataRead;
 				using HighLayer::setChildLayer;
 		};
 
 		class DummyLowLayer : public LowLayer {
 			public:
 				virtual void writeData(const SafeByteArray& data) {
 					writtenData += byteArrayToString(ByteArray(data.begin(), data.end()));
 				}
 				
 				std::string writtenData;
 		};
 
 		FullPayloadParserFactoryCollection parserFactories_;
 		FullPayloadSerializerCollection serializers_;
 		DummyLowLayer* lowLayer_;
 		XMPPLayerExposed* testling_;
 		PlatformXMLParserFactory xmlParserFactory_;