ColorScheme* KDE3ColorSchemeReader::read()
{
Q_ASSERT(_device->openMode() == QIODevice::ReadOnly ||
_device->openMode() == QIODevice::ReadWrite);
ColorScheme* scheme = new ColorScheme();
QRegExp comment("#.*$");
while (!_device->atEnd()) {
QString line(_device->readLine());
line.remove(comment);
line = line.simplified();
if (line.isEmpty())
continue;
if (line.startsWith(QLatin1String("color"))) {
if (!readColorLine(line, scheme))
kWarning() << "Failed to read KDE 3 color scheme line" << line;
} else if (line.startsWith(QLatin1String("title"))) {
if (!readTitleLine(line, scheme))
kWarning() << "Failed to read KDE 3 color scheme title line" << line;
} else {
kWarning() << "KDE 3 color scheme contains an unsupported feature, '" <<
line << "'";
}
}
return scheme;
}
QByteArray QIODeviceProto::readLine(qint64 maxSize)
{
QIODevice *item = qscriptvalue_cast<QIODevice*>(thisObject());
if (item)
return item->readLine(maxSize);
return QByteArray();
}
/*!
\internal
Reads the configuration out from a io device.
*/
void dtkLoggingPrivate::readSettings(QIODevice &device)
{
QMutexLocker locker(&_mutexRegisteredCategory);
{
_logConfigItemList.clear();
if (device.open(QIODevice::ReadOnly)) {
QByteArray truearray("true");
QByteArray line;
while (!device.atEnd()) {
line = device.readLine().replace(" ", "");
line = line.simplified();
const QList<QByteArray> pair = line.split('=');
if (pair.count() == 2)
_logConfigItemList.append(dtkLogConfigFilterItem(QString::fromLatin1(pair.at(0))
, (pair.at(1).toLower() == truearray)));
}
}
foreach (dtkLoggingCategory *category, _registeredCategories) {
updateCategory(category);
}
_registerCategories = true;
}
//----------------------------------------------------------------------------------
void tst_QIODevice::constructing_QFile()
{
QFile file;
QIODevice *device = &file;
QVERIFY(!device->isOpen());
file.setFileName(SRCDIR "tst_qiodevice.cpp");
QVERIFY(file.open(QFile::ReadOnly));
QVERIFY(device->isOpen());
QCOMPARE((int) device->openMode(), (int) QFile::ReadOnly);
char buf[1024];
memset(buf, 0, sizeof(buf));
qlonglong lineLength = device->readLine(buf, sizeof(buf));
QVERIFY(lineLength > 0);
QCOMPARE(file.pos(), lineLength);
file.seek(0);
char buf2[1024];
memset(buf2, 0, sizeof(buf2));
QCOMPARE(file.readLine(buf2, sizeof(buf2)), lineLength);
char *c1 = buf;
char *c2 = buf2;
while (*c1 && *c2) {
QCOMPARE(*c1, *c2);
++c1;
++c2;
}
QCOMPARE(*c1, *c2);
}
qint64 QIODeviceProto::readLine(char *data, qint64 maxSize)
{
QIODevice *item = qscriptvalue_cast<QIODevice*>(thisObject());
if (item)
return item->readLine(data, maxSize);
return 0;
}
Replayer::Replayer(QObject *parent, const QString &filename)
: QThread(parent), m_commandSeriesCounter(1),
filename(filename), speed(1.0), playing(true)
{
QIODevice *device = NULL;
if (filename.endsWith(".png")) {
QByteArray *data = new QByteArray(PNG2TXT(filename));
device = new QBuffer(data);
} else if (filename.endsWith(".qsgs")) {
QFile *file = new QFile(filename);
if (file->open(QFile::ReadOnly)) {
char header;
file->getChar(&header);
if (header == '\0') {
QByteArray content = file->readAll();
delete file;
QByteArray *data = new QByteArray(qUncompress(content));
device = new QBuffer(data);
} else {
file->close();
device = file;
}
} else {
return;
}
}
if (device == NULL)
return;
if (!device->open(QIODevice::ReadOnly | QIODevice::Text))
return;
while (!device->atEnd()) {
QByteArray line = device->readLine();
int split = line.indexOf(' ');
Pair pair;
pair.elapsed = line.left(split).toInt();
pair.cmd = line.mid(split + 1);
pairs << pair;
}
delete device;
int time_offset = 0;
pair_offset = 0;
foreach (const Pair &pair, pairs) {
Packet packet;
if (packet.parse(pair.cmd)) {
if (packet.getCommandType() == S_COMMAND_START_IN_X_SECONDS) {
time_offset = pair.elapsed;
break;
}
}
pair_offset++;
}
Replayer::Replayer(QObject *parent, const QString &filename)
:QThread(parent), m_isOldVersion(false), m_commandSeriesCounter(1),
filename(filename), speed(1.0), playing(true)
{
QIODevice *device = NULL;
if(filename.endsWith(".png")){
QByteArray *data = new QByteArray(PNG2TXT(filename));
QBuffer *buffer = new QBuffer(data);
device = buffer;
}else if(filename.endsWith(".txt")){
QFile *file = new QFile(filename);
device = file;
}
if(device == NULL)
return;
if(!device->open(QIODevice::ReadOnly | QIODevice::Text))
return;
typedef char buffer_t[1024];
initCommandPair();
while(!device->atEnd()){
buffer_t line;
memset(line, 0, sizeof(buffer_t));
device->readLine(line, sizeof(buffer_t));
char *space = strchr(line, ' ');
if(space == NULL)
continue;
*space = '\0';
QString cmd = space + 1;
int elapsed = atoi(line);
//@todo: There is a serious problem that the old protocol didn't has
//any tag or type definition for the sent messages, and if the old protocol
// wants to be translated to the new protocol, there is no information for the package type
//and client will be confused of showing dialog or not.
commandTranslation(cmd);
Pair pair;
pair.elapsed = elapsed;
pair.cmd = cmd;
pairs << pair;
}
if(m_isOldVersion){
QMessageBox::warning(NULL, tr("Warning"), tr("The replay use old protocol"));
}
delete device;
}
// Helper for xmlBufferCompare
static bool textBufferCompare(
const QByteArray& source, const QByteArray& dest, // for the qDebug only
QIODevice& sourceFile, QIODevice& destFile)
{
int lineNumber = 1;
while (!sourceFile.atEnd()) {
if (destFile.atEnd())
return false;
QByteArray sourceLine = sourceFile.readLine();
QByteArray destLine = destFile.readLine();
if (sourceLine != destLine) {
sourceLine.chop(1); // remove '\n'
destLine.chop(1); // remove '\n'
qDebug() << source << "and" << dest << "differ at line" << lineNumber;
qDebug("got : %s", sourceLine.constData());
qDebug("expected: %s", destLine.constData());
return false;
}
++lineNumber;
}
return true;
}
void SocketApi::slotReadSocket()
{
QIODevice* socket = qobject_cast<QIODevice*>(sender());
Q_ASSERT(socket);
while(socket->canReadLine()) {
QString line = QString::fromUtf8(socket->readLine());
line.chop(1); // remove the '\n'
QString command = line.split(":").value(0);
QString function = QString(QLatin1String("command_")).append(command);
QString functionWithArguments = function + QLatin1String("(QString,QIODevice*)");
int indexOfMethod = this->metaObject()->indexOfMethod(functionWithArguments.toAscii());
QString argument = line.remove(0, command.length()+1);
if(indexOfMethod != -1) {
QMetaObject::invokeMethod(this, function.toAscii(), Q_ARG(QString, argument), Q_ARG(QIODevice*, socket));
} else {
Replayer::Replayer(QObject *parent, const QString &filename)
: QThread(parent), m_commandSeriesCounter(1),
filename(filename), speed(1.0), playing(true)
{
QIODevice *device = NULL;
if (filename.endsWith(".png")) {
QByteArray *data = new QByteArray(Recorder::PNG2TXT(filename));
QBuffer *buffer = new QBuffer(data);
device = buffer;
} else if (filename.endsWith(".txt")) {
QFile *file = new QFile(filename);
device = file;
}
if (device == NULL)
return;
if (!device->open(QIODevice::ReadOnly | QIODevice::Text))
return;
typedef char buffer_t[65535];
while (!device->atEnd()) {
buffer_t line;
memset(line, 0, sizeof(buffer_t));
device->readLine(line, sizeof(buffer_t));
char *space = strchr(line, ' ');
if (space == NULL)
continue;
*space = '\0';
QString cmd = space + 1;
int elapsed = atoi(line);
Pair pair;
pair.elapsed = elapsed;
pair.cmd = cmd;
pairs << pair;
}
delete device;
}
//----------------------------------------------------------------------------------
void tst_QIODevice::constructing_QTcpSocket()
{
#if defined(Q_OS_WINCE) && defined(WINCE_EMULATOR_TEST)
QSKIP("Networking tests in a WinCE emulator are unstable", SkipAll);
#endif
QTcpSocket socket;
QIODevice *device = &socket;
QVERIFY(!device->isOpen());
socket.connectToHost(QtNetworkSettings::serverName(), 143);
QVERIFY(socket.waitForConnected(5000));
QVERIFY(device->isOpen());
while (!device->canReadLine())
QVERIFY(device->waitForReadyRead(5000));
char buf[1024];
memset(buf, 0, sizeof(buf));
qlonglong lineLength = device->readLine(buf, sizeof(buf));
QVERIFY(lineLength > 0);
QCOMPARE(socket.pos(), qlonglong(0));
socket.close();
socket.connectToHost(QtNetworkSettings::serverName(), 143);
QVERIFY(socket.waitForConnected(5000));
QVERIFY(device->isOpen());
while (!device->canReadLine())
QVERIFY(device->waitForReadyRead(5000));
char buf2[1024];
memset(buf2, 0, sizeof(buf2));
QCOMPARE(socket.readLine(buf2, sizeof(buf2)), lineLength);
char *c1 = buf;
char *c2 = buf2;
while (*c1 && *c2) {
QCOMPARE(*c1, *c2);
++c1;
++c2;
}
QCOMPARE(*c1, *c2);
}
Replayer::Replayer(QObject *parent, const QString &filename)
: QThread(parent), m_commandSeriesCounter(1),
filename(filename), speed(1.0), playing(true)
{
QIODevice *device = NULL;
if (filename.endsWith(".png")) {
QByteArray *data = new QByteArray(PNG2TXT(filename));
QBuffer *buffer = new QBuffer(data);
device = buffer;
} else if (filename.endsWith(".qsgs")) {
QFile *file = new QFile(filename);
device = file;
}
if (device == NULL)
return;
if (!device->open(QIODevice::ReadOnly | QIODevice::Text))
return;
while (!device->atEnd()) {
QString line = QString::fromUtf8(device->readLine());
QStringList splited_line = line.split(" ");
QString elapsed_str = splited_line.takeFirst();
QString cmd = splited_line.join(" ");
int elapsed = elapsed_str.toInt();
Pair pair;
pair.elapsed = elapsed;
pair.cmd = cmd;
pairs << pair;
}
delete device;
}
bool Record::open()
{
QIODevice *device = new QFile(m_fileName);
if (!device->open(QFile::ReadOnly))
return false;
char header;
device->getChar(&header);
if (header == '\0') {
m_format = CompressedText;
QByteArray content = device->readAll();
delete device;
QByteArray *data = new QByteArray(qUncompress(content));
device = new QBuffer(data);
device->open(QFile::ReadOnly);
} else {
m_format = PlainText;
device->ungetChar(header);
device->seek(0);
}
m_commands.clear();
while (!device->atEnd()) {
QByteArray line = device->readLine();
int split = line.indexOf(' ');
Command command;
command.elapsed = line.left(split).toInt();
command.data = line.mid(split + 1);
m_commands << command;
}
return true;
}
//--------------------------------------------------------------------
void tst_QIODevice::unget()
{
#if defined(Q_OS_WINCE) && defined(WINCE_EMULATOR_TEST)
QSKIP("Networking tests in a WinCE emulator are unstable", SkipAll);
#endif
QBuffer buffer;
buffer.open(QBuffer::ReadWrite);
buffer.write("ZXCV");
buffer.seek(0);
QCOMPARE(buffer.read(4), QByteArray("ZXCV"));
QCOMPARE(buffer.pos(), qint64(4));
buffer.ungetChar('a');
buffer.ungetChar('b');
buffer.ungetChar('c');
buffer.ungetChar('d');
QCOMPARE(buffer.pos(), qint64(0));
char buf[6];
QCOMPARE(buffer.readLine(buf, 5), qint64(4));
QCOMPARE(buffer.pos(), qint64(4));
QCOMPARE(static_cast<const char*>(buf), "dcba");
buffer.ungetChar('a');
buffer.ungetChar('b');
buffer.ungetChar('c');
buffer.ungetChar('d');
QCOMPARE(buffer.pos(), qint64(0));
for (int i = 0; i < 5; ++i) {
buf[0] = '@';
buf[1] = '@';
QTest::ignoreMessage(QtWarningMsg,
"QIODevice::readLine: Called with maxSize < 2");
QCOMPARE(buffer.readLine(buf, 1), qint64(-1));
QCOMPARE(buffer.readLine(buf, 2), qint64(i < 4 ? 1 : -1));
switch (i) {
case 0:
QCOMPARE(buf[0], 'd');
break;
case 1:
QCOMPARE(buf[0], 'c');
break;
case 2:
QCOMPARE(buf[0], 'b');
break;
case 3:
QCOMPARE(buf[0], 'a');
break;
case 4:
QCOMPARE(buf[0], '\0');
break;
}
QCOMPARE(buf[1], i < 4 ? '\0' : '@');
}
buffer.ungetChar('\n');
QCOMPARE(buffer.readLine(), QByteArray("\n"));
buffer.seek(1);
buffer.readLine(buf, 3);
QCOMPARE(static_cast<const char*>(buf), "XC");
buffer.seek(4);
buffer.ungetChar('Q');
QCOMPARE(buffer.readLine(buf, 3), qint64(1));
for (int i = 0; i < 2; ++i) {
QTcpSocket socket;
QIODevice *dev;
QByteArray result;
const char *lineResult;
if (i == 0) {
dev = &buffer;
result = QByteArray("ZXCV");
lineResult = "ZXCV";
} else {
socket.connectToHost(QtNetworkSettings::serverName(), 80);
socket.write("GET / HTTP/1.0\r\n\r\n");
QVERIFY(socket.waitForReadyRead());
dev = &socket;
result = QByteArray("HTTP");
lineResult = "Date";
}
char ch, ch2;
dev->seek(0);
dev->getChar(&ch);
dev->ungetChar(ch);
QCOMPARE(dev->peek(4), result);
dev->getChar(&ch);
dev->getChar(&ch2);
dev->ungetChar(ch2);
dev->ungetChar(ch);
QCOMPARE(dev->read(1), result.left(1));
QCOMPARE(dev->read(3), result.right(3));
if (i == 0)
dev->seek(0);
else
dev->readLine();
dev->getChar(&ch);
dev->ungetChar(ch);
dev->readLine(buf, 5);
QCOMPARE(static_cast<const char*>(buf), lineResult);
if (i == 1)
socket.close();
}
}
QByteArray MocParser::readLine()
{
++lineNumber;
return input->readLine();
}
qint64 FlushedProcess::readLine(char * data, qint64 maxSize) {
QIODevice * dev = readingIODevice();
return (dev == NULL)?-1:dev->readLine(data,maxSize);
}
/**
* Verifies contents of specified archive against test fileset
* @param archive archive
*/
static void testFileData( KArchive* archive )
{
const KArchiveDirectory* dir = archive->directory();
const KArchiveEntry* e = dir->entry( "z/test3" );
QVERIFY( e );
QVERIFY( e->isFile() );
const KArchiveFile* f = static_cast<const KArchiveFile*>( e );
QByteArray arr( f->data() );
QCOMPARE( arr.size(), 13 );
QCOMPARE( arr, QByteArray( "Noch so einer" ) );
// Now test using createDevice()
QIODevice *dev = f->createDevice();
QByteArray contents = dev->readAll();
QCOMPARE( contents, arr );
delete dev;
dev = f->createDevice();
contents = dev->read(5); // test reading in two chunks
QCOMPARE(contents.size(), 5);
contents += dev->read(50);
QCOMPARE(contents.size(), 13);
QCOMPARE( QString::fromLatin1(contents), QString::fromLatin1(arr) );
delete dev;
e = dir->entry( "mediumfile" );
QVERIFY( e && e->isFile() );
f = (KArchiveFile*)e;
QCOMPARE( f->data().size(), SIZE1 );
e = dir->entry( "hugefile" );
QVERIFY( e && e->isFile() );
f = (KArchiveFile*)e;
QCOMPARE( f->data().size(), 20000 );
e = dir->entry( "aaaemptydir" );
QVERIFY( e && e->isDirectory() );
e = dir->entry( "my/dir/test3" );
QVERIFY( e && e->isFile() );
f = (KArchiveFile*)e;
dev = f->createDevice();
QByteArray firstLine = dev->readLine();
QCOMPARE(QString::fromLatin1(firstLine), QString::fromLatin1("I do not speak German\n"));
QByteArray secondLine = dev->read(100);
QCOMPARE(QString::fromLatin1(secondLine), QString::fromLatin1("David."));
delete dev;
#ifndef Q_OS_WIN
e = dir->entry( "z/test3_symlink" );
QVERIFY(e);
QVERIFY(e->isFile());
QCOMPARE(e->symLinkTarget(), QString("test3"));
#endif
// Test "./" prefix for KOffice (xlink:href="./ObjectReplacements/Object 1")
e = dir->entry( "./hugefile" );
QVERIFY( e && e->isFile() );
e = dir->entry( "./my/dir/test3" );
QVERIFY( e && e->isFile() );
// Test directory entries
e = dir->entry( "my" );
QVERIFY(e && e->isDirectory());
e = dir->entry( "my/" );
QVERIFY(e && e->isDirectory());
e = dir->entry( "./my/" );
QVERIFY(e && e->isDirectory());
}
int main(int argc, char **argv)
{
QCoreApplication application(argc, argv);
QCoreApplication::setOrganizationDomain(QLatin1String("sites.google.com/site/zeromusparadoxe01"));
QCoreApplication::setApplicationName(QLatin1String("zBrowser"));
QStringList args = application.arguments();
args.takeFirst();
if (args.isEmpty()) {
QTextStream stream(stdout);
stream << "zbrowser-cacheinfo is a tool for viewing and extracting information out of zBrowser cache files." << endl;
stream << "zbrowser-cacheinfo [-o cachefile] [file | url]" << endl;
return 0;
}
NetworkDiskCache diskCache;
QString location = QDesktopServices::storageLocation(QDesktopServices::CacheLocation)
+ QLatin1String("/browser/");
diskCache.setCacheDirectory(location);
QNetworkCacheMetaData metaData;
QString last = args.takeLast();
if (QFile::exists(last)) {
qDebug() << "Reading in from a file and not a URL.";
metaData = diskCache._fileMetaData(last);
} else {
qDebug() << "Reading in from a URL and not a file.";
metaData = diskCache.metaData(last);
}
if (!args.isEmpty()
&& args.count() >= 1
&& args.first() == QLatin1String("-o")) {
QUrl url = metaData.url();
QIODevice *device = diskCache.data(url);
if (!device) {
qDebug() << "Error: data for URL is 0!";
return 1;
}
QString fileName;
if (args.count() == 2) {
fileName = args.last();
} else {
QFileInfo info(url.path());
fileName = info.fileName();
if (fileName.isEmpty()) {
qDebug() << "URL file name is empty, please specify an output file, I wont guess.";
return 1;
}
if (QFile::exists(fileName)) {
qDebug() << "File already exists, not overwriting, please specify an output file.";
return 1;
}
}
qDebug() << "Saved cache file to:" << fileName;
QFile file(fileName);
if (!file.open(QFile::ReadWrite))
qDebug() << "Unable to open the output file for writing.";
else
file.write(device->readAll());
delete device;
}
QTextStream stream(stdout);
stream << "URL: " << metaData.url().toString() << endl;
stream << "Expiration Date: " << metaData.expirationDate().toString() << endl;
stream << "Last Modified Date: " << metaData.lastModified().toString() << endl;
stream << "Save to disk: " << metaData.saveToDisk() << endl;
stream << "Headers:" << endl;
foreach (const QNetworkCacheMetaData::RawHeader &header, metaData.rawHeaders())
stream << "\t" << header.first << ": " << header.second << endl;
QIODevice *device = diskCache.data(metaData.url());
if (device) {
stream << "Data Size: " << device->size() << endl;
stream << "First line: " << device->readLine(100);
} else {
stream << "No data? Either the file is corrupt or there is an error." << endl;
}
delete device;
return 0;
}
QByteArray FlushedProcess::readLine(qint64 maxSize) {
QIODevice * dev = readingIODevice();
return (dev == NULL)?QByteArray():dev->readLine(maxSize);
}