/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swift/QtUI/QtWebKitChatView.h>

#include <QApplication>

#include <QDesktopServices>

#include <QEventLoop>

#include <QFile>

#include <QFileDialog>

#include <QInputDialog>

#include <QKeyEvent>

#include <QMessageBox>

#include <QStackedWidget>

#include <QTimer>

#include <QVBoxLayout>

#include <QWebFrame>

#include <QtDebug>

#include <Swiften/Base/FileSize.h>

#include <Swiften/Base/Log.h>

#include <Swiften/StringCodecs/Base64.h>

#include <Swift/Controllers/UIEvents/JoinMUCUIEvent.h>

#include <Swift/Controllers/UIEvents/UIEventStream.h>

#include <Swift/QtUI/MessageSnippet.h>

#include <Swift/QtUI/QtChatWindow.h>

#include <Swift/QtUI/QtChatWindowJSBridge.h>

#include <Swift/QtUI/QtScaledAvatarCache.h>

#include <Swift/QtUI/QtSwiftUtil.h>

#include <Swift/QtUI/QtUtilities.h>

#include <Swift/QtUI/QtWebView.h>

#include <Swift/QtUI/SystemMessageSnippet.h>

namespace Swift {

const QString QtWebKitChatView::ButtonWhiteboardSessionCancel = QString("whiteboard-cancel");

const QString QtWebKitChatView::ButtonWhiteboardSessionAcceptRequest = QString("whiteboard-acceptrequest");

const QString QtWebKitChatView::ButtonWhiteboardShowWindow = QString("whiteboard-showwindow");

}

std::string QtWebKitChatView::addWhiteboardRequest(const QString& contact, bool senderIsSelf) {

QString wb_id = QString("wb%1").arg(P2QSTRING(boost::lexical_cast<std::string>(idCounter_++)));

QString htmlString;

QString actionText;

if (senderIsSelf) {

actionText = tr("Starting whiteboard chat");

htmlString = "<div id='" + wb_id + "'>" + actionText + "<br />"+

buildChatWindowButton(tr("Cancel"), ButtonWhiteboardSessionCancel, wb_id) +

"</div>";

} else {

actionText = tr("%1 would like to start a whiteboard chat");

htmlString = "<div id='" + wb_id + "'>" + actionText.arg(QtUtilities::htmlEscape(contact)) + ": <br/>" +

buildChatWindowButton(tr("Cancel"), ButtonWhiteboardSessionCancel, wb_id) +

buildChatWindowButton(tr("Accept"), ButtonWhiteboardSessionAcceptRequest, wb_id) +

"</div>";

}

QString qAvatarPath = "qrc:/icons/avatar.png";

std::string id = "wbmessage" + boost::lexical_cast<std::string>(idCounter_++);

addMessageBottom(boost::make_shared<MessageSnippet>(htmlString, QtUtilities::htmlEscape(contact), B2QDATE(boost::posix_time::second_clock::universal_time()), qAvatarPath, false, false, theme_, P2QSTRING(id), ChatSnippet::getDirection(actionText)));

previousMessageWasSelf_ = false;

previousSenderName_ = contact;

return Q2PSTRING(wb_id);

}

void QtWebKitChatView::setWhiteboardSessionStatus(const std::string& id, const ChatWindow::WhiteboardSessionState state) {

setWhiteboardSessionStatus(P2QSTRING(id), state);

}

void QtWebKitChatView::handleHTMLButtonClicked(QString id, QString encodedArgument1, QString encodedArgument2, QString encodedArgument3, QString encodedArgument4, QString encodedArgument5) {

QString arg1 = decodeButtonArgument(encodedArgument1);

QString arg2 = decodeButtonArgument(encodedArgument2);

QString arg3 = decodeButtonArgument(encodedArgument3);

QString arg4 = decodeButtonArgument(encodedArgument4);

QString arg5 = decodeButtonArgument(encodedArgument5);

if (id.startsWith(ButtonFileTransferCancel)) {

QString ft_id = arg1;

window_->onFileTransferCancel(Q2PSTRING(ft_id));

}

else if (id.startsWith(ButtonFileTransferSetDescription)) {

QString ft_id = arg1;

bool ok = false;

QString text = QInputDialog::getText(this, tr("File transfer description"),

tr("Description:"), QLineEdit::Normal, "", &ok);

if (ok) {

descriptions_[ft_id] = text;

}

}

else if (id.startsWith(ButtonFileTransferSendRequest)) {

QString ft_id = arg1;

QString text = descriptions_.find(ft_id) == descriptions_.end() ? QString() : descriptions_[ft_id];

window_->onFileTransferStart(Q2PSTRING(ft_id), Q2PSTRING(text));

}

else if (id.startsWith(ButtonFileTransferAcceptRequest)) {

QString ft_id = arg1;

QString filename = arg2;

QString path = QFileDialog::getSaveFileName(this, tr("Save File"), filename);

filePaths_[ft_id] = path;

window_->onFileTransferAccept(Q2PSTRING(ft_id), Q2PSTRING(path));

}

}

else if (id.startsWith(ButtonFileTransferOpenFile)) {

QString ft_id = arg1;

QString filename = arg2;

askDesktopToOpenFile(filename);

}

else if (id.startsWith(ButtonWhiteboardSessionAcceptRequest)) {

QString id = arg1;

setWhiteboardSessionStatus(id, ChatWindow::WhiteboardAccepted);

window_->onWhiteboardSessionAccept();

}

else if (id.startsWith(ButtonWhiteboardSessionCancel)) {

QString id = arg1;

setWhiteboardSessionStatus(id, ChatWindow::WhiteboardTerminated);

window_->onWhiteboardSessionCancel();

}

else if (id.startsWith(ButtonWhiteboardShowWindow)) {

QString id = arg1;

window_->onWhiteboardWindowShow();

}

else if (id.startsWith(ButtonMUCInvite)) {

QString roomJID = arg1;

QString password = arg2;

QString elementID = arg3;

QString isImpromptu = arg4;

QString isContinuation = arg5;

eventStream_->send(boost::make_shared<JoinMUCUIEvent>(Q2PSTRING(roomJID), Q2PSTRING(password), boost::optional<std::string>(), false, false, isImpromptu.contains("true"), isContinuation.contains("true")));

setMUCInvitationJoined(elementID);

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <QList>

#include <QString>

#include <QWebElement>

#include <QWidget>

#include <Swiften/Base/Override.h>

#include <Swift/Controllers/UIInterfaces/ChatWindow.h>

#include <Swift/QtUI/ChatSnippet.h>

#include <Swift/QtUI/QtChatView.h>

class QWebPage;

class QUrl;

class QDate;

namespace Swift {

class QtWebView;

class QtChatTheme;

class QtChatWindowJSBridge;

class UIEventStream;

class QtChatWindow;

virtual std::string addFileTransfer(const std::string& senderName, bool senderIsSelf, const std::string& filename, const boost::uintmax_t sizeInBytes, const std::string& description) SWIFTEN_OVERRIDE;

virtual void setFileTransferProgress(std::string, const int percentageDone) SWIFTEN_OVERRIDE;

virtual void setFileTransferStatus(std::string, const ChatWindow::FileTransferState state, const std::string& msg = "") SWIFTEN_OVERRIDE;

virtual void addMUCInvitation(const std::string& senderName, const JID& jid, const std::string& reason, const std::string& password, bool direct, bool isImpromptu, bool isContinuation) SWIFTEN_OVERRIDE;

virtual std::string addWhiteboardRequest(const QString& contact, bool senderIsSelf) SWIFTEN_OVERRIDE;

virtual void setWhiteboardSessionStatus(const std::string& id, const ChatWindow::WhiteboardSessionState state) SWIFTEN_OVERRIDE;

virtual void setMessageReceiptState(const std::string& id, ChatWindow::ReceiptState state) SWIFTEN_OVERRIDE;

virtual void showEmoticons(bool show) SWIFTEN_OVERRIDE;

void addMessageTop(boost::shared_ptr<ChatSnippet> snippet);

void addMessageBottom(boost::shared_ptr<ChatSnippet> snippet);

int getSnippetPositionByDate(const QDate& date); // FIXME : This probably shouldn't have been public

virtual void addLastSeenLine() SWIFTEN_OVERRIDE;

private: // previously public, now private

void replaceLastMessage(const QString& newMessage, const ChatWindow::TimestampBehaviour timestampBehaviour);

void replaceLastMessage(const QString& newMessage, const QString& note);

void replaceMessage(const QString& newMessage, const QString& id, const QDateTime& time);

void replaceSystemMessage(const QString& newMessage, const QString&id, const ChatWindow::TimestampBehaviour timestampBehaviour);

void rememberScrolledToBottom();

void setAckXML(const QString& id, const QString& xml);

void setReceiptXML(const QString& id, const QString& xml);

void displayReceiptInfo(const QString& id, bool showIt);

QString getLastSentMessage();

void addToJSEnvironment(const QString&, QObject*);

void setFileTransferProgress(QString id, const int percentageDone);

void setFileTransferStatus(QString id, const ChatWindow::FileTransferState state, const QString& msg);

void setWhiteboardSessionStatus(QString id, const ChatWindow::WhiteboardSessionState state);

void setMUCInvitationJoined(QString id);

void askDesktopToOpenFile(const QString& filename);

signals:

void gotFocus();

void fontResized(int);

void logCleared();

void scrollRequested(int pos);

void scrollReachedTop();

void scrollReachedBottom();

public slots:

void copySelectionToClipboard();

void handleLinkClicked(const QUrl&);

void resetView();

void resetTopInsertPoint();

void increaseFontSize(int numSteps = 1);

void decreaseFontSize();

virtual void resizeFont(int fontSizeSteps) SWIFTEN_OVERRIDE;

virtual void scrollToBottom() SWIFTEN_OVERRIDE;

virtual void handleKeyPressEvent(QKeyEvent* event) SWIFTEN_OVERRIDE;

private slots:

void handleViewLoadFinished(bool);

void handleFrameSizeChanged();

void handleClearRequested();

void handleScrollRequested(int dx, int dy, const QRect& rectToScroll);

void handleHTMLButtonClicked(QString id, QString arg1, QString arg2, QString arg3, QString arg4, QString arg5);

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/FileTransfer/WriteBytestream.h>

namespace Swift {

class SWIFTEN_API ByteArrayWriteBytestream : public WriteBytestream {

public:

ByteArrayWriteBytestream() {

}

data.insert(data.end(), bytes.begin(), bytes.end());

onWrite(bytes);

}

const std::vector<unsigned char>& getData() const {

return data;

}

private:

std::vector<unsigned char> data;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

namespace Swift {

class SWIFTEN_API FileTransferError {

public:

enum Type {

UnknownError,

PeerError,

ReadError,

ClosedError

};

FileTransferError(Type type = UnknownError) : type(type) {}

Type getType() const {

return type;

}

private:

Type type;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/FileTransfer/FileWriteBytestream.h>

#include <cassert>

#include <boost/filesystem/fstream.hpp>

#include <boost/numeric/conversion/cast.hpp>

namespace Swift {

FileWriteBytestream::FileWriteBytestream(const boost::filesystem::path& file) : file(file), stream(NULL) {

}

FileWriteBytestream::~FileWriteBytestream() {

if (stream) {

stream->close();

delete stream;

stream = NULL;

}

}

if (data.empty()) {

}

if (!stream) {

stream = new boost::filesystem::ofstream(file, std::ios_base::out|std::ios_base::binary);

}

}

void FileWriteBytestream::close() {

if (stream) {

stream->close();

delete stream;

stream = NULL;

}

}

}

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <boost/filesystem/fstream.hpp>

#include <boost/filesystem/path.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/FileTransfer/WriteBytestream.h>

namespace Swift {

class SWIFTEN_API FileWriteBytestream : public WriteBytestream {

public:

FileWriteBytestream(const boost::filesystem::path& file);

virtual ~FileWriteBytestream();

void close();

private:

boost::filesystem::path file;

boost::filesystem::ofstream* stream;

};

}

/*

* Copyright (c) 2011 Tobias Markmann

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include "SOCKS5BytestreamClientSession.h"

#include <boost/bind.hpp>

#include <boost/numeric/conversion/cast.hpp>

#include <Swiften/Base/Algorithm.h>

#include <Swiften/Base/ByteArray.h>

#include <Swiften/Base/Concat.h>

#include <Swiften/Base/Log.h>

#include <Swiften/Base/SafeByteArray.h>

#include <Swiften/FileTransfer/BytestreamException.h>

#include <Swiften/Network/TimerFactory.h>

#include <Swiften/StringCodecs/Hexify.h>

namespace Swift {

SOCKS5BytestreamClientSession::SOCKS5BytestreamClientSession(

boost::shared_ptr<Connection> connection,

const HostAddressPort& addressPort,

const std::string& destination,

TimerFactory* timerFactory) :

connection(connection),

addressPort(addressPort),

destination(destination),

state(Initial),

chunkSize(131072) {

SWIFT_LOG(debug) << "Data: " << Hexify::hexify(unprocessedData) << std::endl;

unprocessedData.clear();

//assert(false);

}

}

void SOCKS5BytestreamClientSession::hello() {

// Version 5, 1 auth method, No authentication

const SafeByteArray hello = createSafeByteArray("\x05\x01\x00", 3);

connection->write(hello);

state = Hello;

}

void SOCKS5BytestreamClientSession::authenticate() {

SWIFT_LOG(debug) << std::endl;

SafeByteArray header = createSafeByteArray("\x05\x01\x00\x03", 4);

SafeByteArray message = header;

append(message, createSafeByteArray(boost::numeric_cast<char>(destination.size())));

authenticateAddress = createByteArray(destination);

append(message, authenticateAddress);

append(message, createSafeByteArray("\x00\x00", 2)); // 2 byte for port

connection->write(message);

state = Authenticating;

}

void SOCKS5BytestreamClientSession::startReceiving(boost::shared_ptr<WriteBytestream> writeStream) {

if (state == Ready) {

state = Reading;

writeBytestream = writeStream;

writeBytestream->write(unprocessedData);

unprocessedData.clear();

} else {

SWIFT_LOG(debug) << "Session isn't ready for transfer yet!" << std::endl;

}

}

void SOCKS5BytestreamClientSession::startSending(boost::shared_ptr<ReadBytestream> readStream) {

if (state == Ready) {

state = Writing;

readBytestream = readStream;

dataWrittenConnection = connection->onDataWritten.connect(

boost::bind(&SOCKS5BytestreamClientSession::sendData, this));

sendData();

} else {

SWIFT_LOG(debug) << "Session isn't ready for transfer yet!" << std::endl;

}

}

HostAddressPort SOCKS5BytestreamClientSession::getAddressPort() const {

return addressPort;

}

void SOCKS5BytestreamClientSession::sendData() {

if (!readBytestream->isFinished()) {

try {

boost::shared_ptr<ByteArray> dataToSend = readBytestream->read(boost::numeric_cast<size_t>(chunkSize));

connection->write(createSafeByteArray(*dataToSend));

onBytesSent(dataToSend->size());

}

catch (const BytestreamException&) {

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/FileTransfer/SOCKS5BytestreamServerSession.h>

#include <boost/bind.hpp>

#include <boost/numeric/conversion/cast.hpp>

#include <Swiften/Base/Algorithm.h>

#include <Swiften/Base/Concat.h>

#include <Swiften/Base/Log.h>

#include <Swiften/FileTransfer/BytestreamException.h>

namespace Swift {

SOCKS5BytestreamServerSession::SOCKS5BytestreamServerSession(

boost::shared_ptr<Connection> connection,

SOCKS5BytestreamRegistry* bytestreams) :

connection(connection),

bytestreams(bytestreams),

state(Initial),

chunkSize(131072),

waitingForData(false) {

disconnectedConnection = connection->onDisconnected.connect(boost::bind(&SOCKS5BytestreamServerSession::handleDisconnected, this, _1));

}

SOCKS5BytestreamServerSession::~SOCKS5BytestreamServerSession() {

if (state != Finished && state != Initial) {

}

}

void SOCKS5BytestreamServerSession::start() {

SWIFT_LOG(debug) << std::endl;

dataReadConnection = connection->onDataRead.connect(

boost::bind(&SOCKS5BytestreamServerSession::handleDataRead, this, _1));

state = WaitingForAuthentication;

}

void SOCKS5BytestreamServerSession::stop() {

}

void SOCKS5BytestreamServerSession::startSending(boost::shared_ptr<ReadBytestream> stream) {

if (state != ReadyForTransfer) { SWIFT_LOG(debug) << "Not ready for transfer!" << std::endl; return; }

readBytestream = stream;

state = WritingData;

dataAvailableConnection = readBytestream->onDataAvailable.connect(

boost::bind(&SOCKS5BytestreamServerSession::handleDataAvailable, this));

dataWrittenConnection = connection->onDataWritten.connect(

boost::bind(&SOCKS5BytestreamServerSession::sendData, this));

sendData();

}

void SOCKS5BytestreamServerSession::startReceiving(boost::shared_ptr<WriteBytestream> stream) {

if (state != ReadyForTransfer) { SWIFT_LOG(debug) << "Not ready for transfer!" << std::endl; return; }

writeBytestream = stream;

state = ReadingData;

writeBytestream->write(unprocessedData);

// onBytesReceived(unprocessedData.size());

unprocessedData.clear();

}

HostAddressPort SOCKS5BytestreamServerSession::getAddressPort() const {

return connection->getLocalAddress();

}

void SOCKS5BytestreamServerSession::handleDataRead(boost::shared_ptr<SafeByteArray> data) {

if (state != ReadingData) {

append(unprocessedData, *data);

process();

} else {

}

}

void SOCKS5BytestreamServerSession::handleDataAvailable() {

if (waitingForData) {

sendData();

}

}

void SOCKS5BytestreamServerSession::handleDisconnected(const boost::optional<Connection::Error>& error) {

SWIFT_LOG(debug) << (error ? (error == Connection::ReadError ? "Read Error" : "Write Error") : "No Error") << std::endl;

}

void SOCKS5BytestreamServerSession::process() {

if (state == WaitingForAuthentication) {

if (unprocessedData.size() >= 2) {

size_t authCount = unprocessedData[1];

size_t i = 2;

while (i < 2 + authCount && i < unprocessedData.size()) {

// Skip authentication mechanism

++i;

}

if (i == 2 + authCount) {

// Authentication message is complete

if (i != unprocessedData.size()) {

SWIFT_LOG(debug) << "Junk after authentication mechanism" << std::endl;

}

unprocessedData.clear();

connection->write(createSafeByteArray("\x05\x00", 2));

state = WaitingForRequest;

}

}

}

else if (state == WaitingForRequest) {

if (unprocessedData.size() >= 5) {

ByteArray requestID;

size_t i = 5;

size_t hostnameSize = unprocessedData[4];

while (i < 5 + hostnameSize && i < unprocessedData.size()) {

requestID.push_back(unprocessedData[i]);

++i;

}

// Skip the port: 2 byte large, one already skipped. Add one for comparison with size

i += 2;

if (i <= unprocessedData.size()) {

if (i != unprocessedData.size()) {

SWIFT_LOG(debug) << "Junk after authentication mechanism" << std::endl;

}

unprocessedData.clear();

streamID = byteArrayToString(requestID);

bool hasBytestream = bytestreams->hasBytestream(streamID);

SafeByteArray result = createSafeByteArray("\x05", 1);

result.push_back(hasBytestream ? 0x0 : 0x4);

append(result, createByteArray("\x00\x03", 2));

result.push_back(boost::numeric_cast<unsigned char>(requestID.size()));

append(result, concat(requestID, createByteArray("\x00\x00", 2)));

if (!hasBytestream) {

SWIFT_LOG(debug) << "Readstream or Wrtiestream with ID " << streamID << " not found!" << std::endl;

connection->write(result);

}

else {

SWIFT_LOG(debug) << "Found stream. Sent OK." << std::endl;

connection->write(result);

state = ReadyForTransfer;

}

}

}

}

}

void SOCKS5BytestreamServerSession::sendData() {

if (!readBytestream->isFinished()) {

try {

SafeByteArray dataToSend = createSafeByteArray(*readBytestream->read(boost::numeric_cast<size_t>(chunkSize)));

if (!dataToSend.empty()) {

connection->write(dataToSend);

onBytesSent(dataToSend.size());

waitingForData = false;

}

else {

waitingForData = true;

}

}

catch (const BytestreamException&) {

}

}

else {

}

}

if (state == Finished) {

return;

}

disconnectedConnection.disconnect();

dataReadConnection.disconnect();

dataWrittenConnection.disconnect();

dataAvailableConnection.disconnect();

readBytestream.reset();

state = Finished;

}

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/FileTransfer/ReadBytestream.h>

#include <Swiften/FileTransfer/WriteBytestream.h>

namespace Swift {

class SOCKS5BytestreamRegistry;

class SWIFTEN_API SOCKS5BytestreamServerSession {

public:

typedef boost::shared_ptr<SOCKS5BytestreamServerSession> ref;

public:

enum State {

Initial,

WaitingForAuthentication,

WaitingForRequest,

ReadyForTransfer,

ReadingData,

WritingData,

Finished

};

SOCKS5BytestreamServerSession(boost::shared_ptr<Connection> connection, SOCKS5BytestreamRegistry* registry);

~SOCKS5BytestreamServerSession();

void setChunkSize(int chunkSize) {

this->chunkSize = chunkSize;

}

void start();

void stop();

void startSending(boost::shared_ptr<ReadBytestream>);

void startReceiving(boost::shared_ptr<WriteBytestream>);

HostAddressPort getAddressPort() const;

boost::signal<void (boost::optional<FileTransferError>)> onFinished;

boost::signal<void (unsigned long long)> onBytesSent;

const std::string& getStreamID() const {

return streamID;

}

private:

void process();

void handleDataRead(boost::shared_ptr<SafeByteArray>);

void handleDisconnected(const boost::optional<Connection::Error>&);

void handleDataAvailable();

void sendData();

private:

boost::shared_ptr<Connection> connection;

SOCKS5BytestreamRegistry* bytestreams;

ByteArray unprocessedData;

State state;

int chunkSize;

std::string streamID;

boost::shared_ptr<ReadBytestream> readBytestream;

boost::shared_ptr<WriteBytestream> writeBytestream;

bool waitingForData;

boost::bsignals::connection disconnectedConnection;

boost::bsignals::connection dataReadConnection;

boost::bsignals::connection dataWrittenConnection;

boost::bsignals::connection dataAvailableConnection;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <vector>

#include <Swiften/Base/API.h>

#include <Swiften/Base/boost_bsignals.h>

namespace Swift {

class SWIFTEN_API WriteBytestream {

public:

typedef boost::shared_ptr<WriteBytestream> ref;

virtual ~WriteBytestream();

boost::signal<void (const std::vector<unsigned char>&)> onWrite;

};

}

Import("swiften_env")

SConscript(dirs = [

"NetworkTest",

# "ReconnectTest",

"ClientTest",

# "DNSSDTest",

"TLSTest",

"ScriptedTests",

"ProxyProviderTest",

"FileTransferTest",

])

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <Swiften/Base/ByteArray.h>

#include <Swiften/FileTransfer/FileReadBytestream.h>

using namespace Swift;

class FileReadBytestreamTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(FileReadBytestreamTest);

CPPUNIT_TEST(testRead);

CPPUNIT_TEST(testRead_Twice);

CPPUNIT_TEST(testIsFinished_NotFinished);

CPPUNIT_TEST(testIsFinished_IsFinished);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

pathProvider = new PlatformApplicationPathProvider("FileReadBytestreamTest");

}

void tearDown() {

delete pathProvider;

}

void testRead() {

boost::shared_ptr<FileReadBytestream> testling(createTestling());

}

void testRead_Twice() {

boost::shared_ptr<FileReadBytestream> testling(createTestling());

testling->read(10);

}

void testIsFinished_NotFinished() {

boost::shared_ptr<FileReadBytestream> testling(createTestling());

testling->read(10);

CPPUNIT_ASSERT(!testling->isFinished());

}

void testIsFinished_IsFinished() {

boost::shared_ptr<FileReadBytestream> testling(createTestling());

testling->read(4096);

CPPUNIT_ASSERT(testling->isFinished());

}

private:

FileReadBytestream* createTestling() {

return new FileReadBytestream(pathProvider->getExecutableDir() / "FileReadBytestreamTest.cpp");

}

PlatformApplicationPathProvider* pathProvider;

};

CPPUNIT_TEST_SUITE_REGISTRATION(FileReadBytestreamTest);

import os

Import("env")

if env["TEST"] :

myenv = env.Clone()

myenv.MergeFlags(myenv["CHECKER_FLAGS"])

myenv.MergeFlags(myenv["SWIFTOOLS_FLAGS"])

myenv.MergeFlags(myenv["SWIFTEN_FLAGS"])

myenv.MergeFlags(myenv["CPPUNIT_FLAGS"])

myenv.MergeFlags(myenv["BOOST_FLAGS"])

myenv.MergeFlags(myenv["LIBIDN_FLAGS"])

myenv.MergeFlags(myenv.get("EXPAT_FLAGS", {}))

myenv.MergeFlags(myenv.get("LIBXML_FLAGS", {}))

myenv.MergeFlags(myenv["PLATFORM_FLAGS"])

tester = myenv.Program("StorageTest", [

"FileReadBytestreamTest.cpp",

])

myenv.Test(tester, "system", is_checker = True)