static void
compressor_fixup_params(struct compress_params *params)
{
compressor(params->type)->fixup_params(params);
if (params->level < 0)
params->level = compressor(params->type)->default_level;
}
int main(void)
{
signed int fridgeTemp;
signed int freezeTemp;
signed int defrostTemp;
signed int fridgePro;
network_control(ENABLE);
iomod_backlight(ON);
/* Initialize servo and temperature sensor ports */
DDRB = 0x0F;
PORTB = 0x00;
set_bit(DDRD, 2);
clear_bit(PORTD, 2);
/* Set up .01 sec timer */
TCCR0A = (2 << WGM00);
TCCR0B = (5 << CS00);
TIMSK0 = (1 << OCIE0A);
OCR0A = 195;
sei();
//fridgeTemp = -5;
//freezeTemp = -18;
while(1) {
/* Check tempreture in fridge and freezer */
fridgeTemp = temp_sensor_read(FRIDGE_SENSE, TEMPERATURE);
freezeTemp = temp_sensor_read(FREEZE_SENSE, TEMPERATURE);
// defrostTemp = temp_sensor_read(DEFROST_SENSE, TEMPERATURE);
/* Control freezer */
if (freezeTemp > (freezerSet + FREEZE_RANGE))
compressor(ON);
else if (freezeTemp < (freezerSet - FREEZE_RANGE))
compressor(OFF);
/* Control refridgerator */
fridgePro = ((fridgeTemp - fridgeSet) * 100) / FRIDGE_RANGE;
if (fridgePro > 100) fridgePro = 100;
if (fridgePro < -100) fridgePro = -100;
damper_control(1200 + (fridgePro * 4));
/* Display information on LCD */
iomod_text(FIRST_LINE, "FD:");
iomod_signed(FIRST_LINE+3, fridgeTemp, 2);
iomod_text(SECOND_LINE, "FZ:");
iomod_signed(SECOND_LINE+3, freezeTemp, 2);
// iomod_text(SECOND_LINE+6, "FZ:");
// iomod_signed(SECOND_LINE+9, defrostTemp, 2);
}
}
std::unique_ptr<std::vector<char>> Format::pack(
Data::PooledStack dataStack,
const ChunkType chunkType) const
{
std::unique_ptr<std::vector<char>> data;
const std::size_t numPoints(dataStack.size());
const std::size_t pointSize(schema().pointSize());
if (m_compress)
{
Compressor compressor(m_metadata.schema(), dataStack.size());
for (const char* pos : dataStack) compressor.push(pos, pointSize);
data = compressor.data();
}
else
{
data = makeUnique<std::vector<char>>();
data->reserve(numPoints * pointSize);
for (const char* pos : dataStack)
{
data->insert(data->end(), pos, pos + pointSize);
}
}
assert(data);
dataStack.reset();
Packer packer(m_tailFields, *data, numPoints, chunkType);
append(*data, packer.buildTail());
return data;
}
static int filter_frame(AVFilterLink *link, AVFrame *frame)
{
AVFilterContext *ctx = link->dst;
SidechainCompressContext *s = ctx->priv;
AVFilterLink *outlink = ctx->outputs[0];
const double *scsrc;
double *sample;
int nb_samples;
int ret, i;
for (i = 0; i < 2; i++)
if (link == ctx->inputs[i])
break;
av_assert0(i < 2 && !s->input_frame[i]);
s->input_frame[i] = frame;
if (!s->input_frame[0] || !s->input_frame[1])
return 0;
nb_samples = FFMIN(s->input_frame[0]->nb_samples,
s->input_frame[1]->nb_samples);
sample = (double *)s->input_frame[0]->data[0];
scsrc = (const double *)s->input_frame[1]->data[0];
compressor(s, sample, sample, scsrc, nb_samples,
s->level_in, s->level_sc,
ctx->inputs[0], ctx->inputs[1]);
ret = ff_filter_frame(outlink, s->input_frame[0]);
s->input_frame[0] = NULL;
av_frame_free(&s->input_frame[1]);
return ret;
}
void BpfWriter::writeByteMajor(const PointView* data)
{
union
{
float f;
uint32_t u32;
} uu;
// We're going to pretend for now that we only ever have one point buffer.
BpfCompressor compressor(m_stream,
data->size() * sizeof(float) * m_dims.size());
if (m_header.m_compression)
compressor.startBlock();
for (auto & bpfDim : m_dims)
{
for (size_t b = 0; b < sizeof(float); b++)
{
for (PointId idx = 0; idx < data->size(); ++idx)
{
uu.f = (float)getAdjustedValue(data, bpfDim, idx);
uint8_t u8 = (uint8_t)(uu.u32 >> (b * CHAR_BIT));
m_stream << u8;
}
}
}
if (m_header.m_compression)
{
compressor.compress();
compressor.finish();
}
}
void BpfWriter::writePointMajor(const PointView* data)
{
// Blocks of 10,000 points will ensure that we're under 16MB, even
// for 255 dimensions.
size_t blockpoints = std::min<point_count_t>(10000UL, data->size());
// For compression we're going to write to a buffer so that it can be
// compressed before it's written to the file stream.
BpfCompressor compressor(m_stream,
blockpoints * sizeof(float) * m_dims.size());
PointId idx = 0;
while (idx < data->size())
{
if (m_header.m_compression)
compressor.startBlock();
size_t blockId;
for (blockId = 0; idx < data->size() && blockId < blockpoints;
++idx, ++blockId)
{
for (auto & bpfDim : m_dims)
{
double d = getAdjustedValue(data, bpfDim, idx);
m_stream << (float)d;
}
}
if (m_header.m_compression)
{
compressor.compress();
compressor.finish();
}
}
}
void bunzip2OstreamTest()
{
// test
std::stringstream bzip2target;
{
zim::Bzip2Stream compressor(bzip2target);
compressor << testtext << std::flush;
compressor.end();
}
{
std::ostringstream msg;
msg << "teststring with " << testtext.size() << " bytes compressed into " << bzip2target.str().size() << " bytes";
reportMessage(msg.str());
}
std::ostringstream bunzip2target;
{
zim::Bunzip2Stream bunzip2(bunzip2target); // bunzip2 is a ostream here
bunzip2 << bzip2target.str() << std::flush;
}
{
std::ostringstream msg;
msg << "teststring uncompressed to " << bunzip2target.str().size() << " bytes";
reportMessage(msg.str());
}
CXXTOOLS_UNIT_ASSERT_EQUALS(testtext, bunzip2target.str());
}
static int acompressor_filter_frame(AVFilterLink *inlink, AVFrame *in)
{
const double *src = (const double *)in->data[0];
AVFilterContext *ctx = inlink->dst;
SidechainCompressContext *s = ctx->priv;
AVFilterLink *outlink = ctx->outputs[0];
AVFrame *out;
double *dst;
if (av_frame_is_writable(in)) {
out = in;
} else {
out = ff_get_audio_buffer(inlink, in->nb_samples);
if (!out) {
av_frame_free(&in);
return AVERROR(ENOMEM);
}
av_frame_copy_props(out, in);
}
dst = (double *)out->data[0];
compressor(s, src, dst, src, in->nb_samples,
s->level_in, s->level_in,
inlink, inlink);
if (out != in)
av_frame_free(&in);
return ff_filter_frame(outlink, out);
}
// This example demonstrates how to use the Qt Xml classes together with QtIOCompressor to store
// compressed xml data in a file.
int main()
{
// Create some xml.
QDomDocument doc("MyML");
QDomElement root = doc.createElement("MyML");
doc.appendChild(root);
QDomElement tag = doc.createElement("Greeting");
root.appendChild(tag);
QDomText t = doc.createTextNode("Hello World");
tag.appendChild(t);
// Write it to a compressed file using a QTextStream.
QFile file("xmltest");
file.open(QIODevice::ReadWrite);
QtIOCompressor compressor(&file);
compressor.open(QIODevice::WriteOnly);
QTextStream textStream(&compressor);
const int indent = 0;
doc.save(textStream, indent);
// Close the QtIOCompressor and seek to start of file.
compressor.close();
file.seek(0);
// Read compressed xml from file and print it.
compressor.open(QIODevice::ReadOnly);
QDomDocument readDoc;
readDoc.setContent(&compressor);
const QString readXml = readDoc.toString();
qDebug() << readXml;
}
// Main do Programa de compressão
// @param argc numero de parametros
// @param [in] argv array com os parametros
// @retval EXIT_FAILURE se falhar na execução
// @retval 0 se executar corretamente
int main(int argc, char *argv[]) {
cout << "TRABALHO PRATICO 1 - INTRODUCAO A COMPUTACAO VISUAL - DCC - UFMG" << endl;
cout << "NOME : Guilherme Henrique Rodrigues Nascimento" << endl;
cout << "MATRICULA: 2010054460" << endl;
cout << "Programa de compressão com LZW" << endl;
ifstream arquivo_ent(argv[1], ios_base::binary);
if (!arquivo_ent.is_open()) {
cout << argv[1] << " não pode ser aberto" << endl;
return EXIT_FAILURE;
}
string nome = argv[1];
int tamanho = (int) nome.size();
//cout << tamanho;
string nomesaida = nome.substr(0, tamanho - 4);
ofstream arquivo_saida(nomesaida.append(".compactado"), ios_base::binary);
if (!arquivo_saida.is_open()) {
cout << "arquivo de saida " << argv[2] << " não pode ser criado." << endl;
return EXIT_FAILURE;
}
compressor(arquivo_ent, arquivo_saida);
cout << "Aquivo compactado" << endl;
return 0;
}
int main(int argc, char **argv) {
if (!ReadParameter(argc, argv)) {
std::cout << "Bad Parameters.\n";
return 1;
}
SetConfig();
if (compress) {
// Compress
db_compress::Compressor compressor(outputFileName, schema, config);
int iter_cnt = 0;
while (1) {
std::cout << "Iteration " << ++iter_cnt << " Starts\n";
std::ifstream inFile(inputFileName);
std::string str;
int tuple_cnt = 0;
while (std::getline(inFile,str)) {
std::stringstream sstream(str);
std::string item;
db_compress::Tuple tuple(schema.attr_type.size());
db_compress::IntegerAttrValue attr(++tuple_cnt);
tuple.attr[0] = &attr;
size_t count = 0;
std::vector< std::unique_ptr<ColorAttr> > vec;
while (std::getline(sstream, item, ' ')) {
if (++ count > 1)
AppendAttr(std::stod(item), &tuple, count - 1);
}
// The first item is tuple id
if (count != schema.attr_type.size()) {
std::cerr << "File Format Error!\n";
}
compressor.ReadTuple(tuple);
if (!compressor.RequireFullPass() &&
tuple_cnt >= NonFullPassStopPoint) {
break;
}
}
compressor.EndOfData();
if (!compressor.RequireMoreIterations())
break;
}
} else {
// Decompress
db_compress::Decompressor decompressor(inputFileName, schema);
std::ofstream outFile(outputFileName);
decompressor.Init();
while (decompressor.HasNext()) {
db_compress::Tuple tuple(33);
decompressor.ReadNextTuple(&tuple);
for (size_t i = 0; i < schema.attr_type.size(); ++i) {
double attr = ExtractAttr(&tuple, i);
outFile << attr << (i == schema.attr_type.size() - 1 ? '\n' : ' ');
}
}
}
return 0;
}
void write_compressed(std::ostream &out, config const &cfg)
{
boost::iostreams::filtering_stream<boost::iostreams::output> filter;
filter.push(compressor());
filter.push(out);
write(filter, cfg);
// prevent empty gz files because of https://svn.boost.org/trac/boost/ticket/5237
filter << "\n";
}
int main(int argc, char *argv[])
{
int n = 5;
uchar row1[] = {0, 0, 0, 0, 0};
uchar row2[] = {0, 1, 0, 0, 0};
uchar row3[] = {1, 1, 0, 2, 2};
DeltaRowCompressor compressor(n, 0);
test(&compressor, row1);
test(&compressor, row2);
test(&compressor, row3);
}
bool PodcastService::Podcast::load()
{
if (fileName.isEmpty()) {
return false;
}
QFile file(fileName);
QtIOCompressor compressor(&file);
compressor.setStreamFormat(QtIOCompressor::GzipFormat);
if (!compressor.open(QIODevice::ReadOnly)) {
return false;
}
QXmlStreamReader reader(&compressor);
unplayedCount=0;
while (!reader.atEnd()) {
reader.readNext();
if (!reader.error() && reader.isStartElement()) {
QString element = reader.name().toString();
QXmlStreamAttributes attributes=reader.attributes();
if (constTopTag == element) {
imageUrl=attributes.value(constImageAttribute).toString();
url=attributes.value(constRssAttribute).toString();
name=attributes.value(constNameAttribute).toString();
if (url.isEmpty() || name.isEmpty()) {
return false;
}
} else if (constEpisodeTag == element) {
QString epName=attributes.value(constNameAttribute).toString();
QString epUrl=attributes.value(constUrlAttribute).toString();
if (!epName.isEmpty() && !epUrl.isEmpty()) {
Episode *ep=new Episode(QDateTime::fromString(attributes.value(constDateAttribute).toString(), Qt::ISODate), epName, epUrl, this);
QString localFile=attributes.value(constLocalAttribute).toString();
QString time=attributes.value(constTimeAttribute).toString();
ep->duration=time.isEmpty() ? 0 : time.toUInt();
ep->played=constTrue==attributes.value(constPlayedAttribute).toString();
if (QFile::exists(localFile)) {
ep->localFile=localFile;
}
episodes.append(ep);
if (!ep->played) {
unplayedCount++;
}
}
}
}
}
return true;
}
void
compress_filter(struct compress_params *params, int fd_in, int fd_out,
const char *desc_fmt, ...)
{
va_list args;
struct varbuf desc = VARBUF_INIT;
va_start(args, desc_fmt);
varbuf_vprintf(&desc, desc_fmt, args);
va_end(args);
compressor(params->type)->compress(fd_in, fd_out, params, desc.buf);
}
void
decompress_filter(enum compressor_type type, int fd_in, int fd_out,
const char *desc_fmt, ...)
{
va_list args;
struct varbuf desc = VARBUF_INIT;
va_start(args, desc_fmt);
varbuf_vprintf(&desc, desc_fmt, args);
va_end(args);
compressor(type)->decompress(fd_in, fd_out, desc.buf);
}
TEST(Decompressor, GZip) {
StringWriter* writer = new StringWriter;
GZipCompressor compressor(writer);
EXPECT_LT(0, compressor.WriteString(IPSUM));
EXPECT_LT(writer->GetBuffer().size(), compressor.totalBytesIn());
StringWriter* outputWriter = new StringWriter;
GZipDecompressor decompressor(outputWriter);
EXPECT_EQ(decompressor.WriteString(writer->GetBuffer()), IPSUM.size());
ASSERT_EQ(compressor.totalBytesIn(), outputWriter->GetBuffer().size());
for (int i = 0; i < outputWriter->GetBuffer().size(); ++i) {
EXPECT_EQ(IPSUM.data()[i], outputWriter->GetBuffer()[i]);
};
};
static int filter_frame(AVFilterLink *link, AVFrame *frame)
{
AVFilterContext *ctx = link->dst;
SidechainCompressContext *s = ctx->priv;
AVFilterLink *outlink = ctx->outputs[0];
AVFrame *out = NULL, *in[2] = { NULL };
double *dst;
int nb_samples;
int i;
for (i = 0; i < 2; i++)
if (link == ctx->inputs[i])
break;
av_assert0(i < 2);
av_audio_fifo_write(s->fifo[i], (void **)frame->extended_data,
frame->nb_samples);
av_frame_free(&frame);
nb_samples = FFMIN(av_audio_fifo_size(s->fifo[0]), av_audio_fifo_size(s->fifo[1]));
if (!nb_samples)
return 0;
out = ff_get_audio_buffer(outlink, nb_samples);
if (!out)
return AVERROR(ENOMEM);
for (i = 0; i < 2; i++) {
in[i] = ff_get_audio_buffer(ctx->inputs[i], nb_samples);
if (!in[i]) {
av_frame_free(&in[0]);
av_frame_free(&in[1]);
av_frame_free(&out);
return AVERROR(ENOMEM);
}
av_audio_fifo_read(s->fifo[i], (void **)in[i]->data, nb_samples);
}
dst = (double *)out->data[0];
out->pts = s->pts;
s->pts += nb_samples;
compressor(s, (double *)in[0]->data[0], dst,
(double *)in[1]->data[0], nb_samples,
s->level_in, s->level_sc,
ctx->inputs[0], ctx->inputs[1]);
av_frame_free(&in[0]);
av_frame_free(&in[1]);
return ff_filter_frame(outlink, out);
}
void VlrCompressor::done()
{
// Close and clear the point encoder.
m_encoder->done();
m_encoder.reset();
newChunk();
// Save our current position. Go to the location where we need
// to write the chunk table offset at the beginning of the point data.
uint64_t chunkTablePos = htole64((uint64_t) m_stream.m_buf.size());
// We need to add the offset given a construction time since
// we did not use a stream to write the header and vlrs
uint64_t trueChunkTablePos = htole64((uint64_t) m_stream.m_buf.size() + m_offsetToData);
// Equivalent of stream.seekp(m_chunkInfoPos); stream << chunkTablePos
memcpy(&m_stream.m_buf[m_chunkInfoPos], (char*) &trueChunkTablePos, sizeof(uint64_t));
// Move to the start of the chunk table.
// Which in our case is the end of the m_stream vector
// Write the chunk table header in two steps
// 1. Push bytes into the stream
// 2. memcpy the data into the pushed bytes
unsigned char skip[2 * sizeof(uint32_t)] = {0};
m_stream.putBytes(skip, sizeof(skip));
uint32_t version = htole32(0);
uint32_t chunkTableSize = htole32((uint32_t) m_chunkTable.size());
memcpy(&m_stream.m_buf[chunkTablePos], &version, sizeof(uint32_t));
memcpy(&m_stream.m_buf[chunkTablePos + sizeof(uint32_t)], &chunkTableSize, sizeof(uint32_t));
// Encode and write the chunk table.
// OutputStream outputStream(m_stream);
TypedLazPerfBuf<uint8_t> outputStream(m_stream);
Encoder encoder(outputStream);
laszip::compressors::integer compressor(32, 2);
compressor.init();
uint32_t predictor = 0;
for (uint32_t chunkSize : m_chunkTable)
{
chunkSize = htole32(chunkSize);
compressor.compress(encoder, predictor, chunkSize, 1);
predictor = chunkSize;
}
encoder.done();
}
std::unique_ptr<std::vector<char>> Compression::compress(
const char* data,
const std::size_t size,
const Schema& schema)
{
CompressionStream compressionStream(size);
pdal::LazPerfCompressor<CompressionStream> compressor(
compressionStream,
schema.pdalLayout().dimTypes());
compressor.compress(data, size);
compressor.done();
return compressionStream.data();
}
int alpng_deflate(uint8_t* data, uint32_t data_length, uint8_t** compressed_data, uint32_t* compressed_data_length, char** error_msg) {
CryptoPP::ZlibCompressor compressor(0, 9);
compressor.Put((byte *)data, data_length);
compressor.MessageEnd();
unsigned int dest_length = compressor.MaxRetrievable();
*compressed_data = (uint8_t*) malloc(dest_length);
if (!*compressed_data) {
*error_msg = "Cannot allocate memory!";
return 0;
}
compressor.Get((byte *)*compressed_data, dest_length);
*compressed_data_length = dest_length;
return 1;
}
bool CompressedImage::import(const RasterImage& rasterImage, unsigned char rangeRegionSize)
{
//Retrieve all raster layers
std::vector<Pixmap*> layers = rasterImage.getLayers();
PixmapCompressor compressor(rangeRegionSize, rangeRegionSize * 2);
//Compress each layer separately
for (unsigned int i = 0; i < layers.size(); ++i)
{
std::cout << "====================\nLayer " << i << "\n====================" << std::endl;
m_layers.push_back(compressor.compress(layers[i]));
}
return true;
}
static int parse_line_instruction(t_parser *parser, char **my_tab)
{
if (is_defined(my_tab[0]) == 1)
{
if (compressor(&my_tab) == 1)
{
my_putstr_err("Can’t perform malloc", 2);
return (1);
}
if (is_number_valid(my_tab, my_tab[0]) == 1)
parser->current_address += get_incsize(my_tab);
else
return (syntax_error_and_return(parser->line_nb));
if (valid_args(my_tab) == 0)
return (syntax_error_and_return(parser->line_nb));
}
else
return (syntax_error_and_return(parser->line_nb));
return (0);
}
void WikipediaSettings::parseLangs()
{
NetworkJob *reply = qobject_cast<NetworkJob*>(sender());
if (!reply) {
return;
}
reload->setEnabled(true);
reply->deleteLater();
if (reply!=job) {
return;
}
job=0;
QByteArray data=reply->readAll();
parseLangs(data);
QFile f(localeFile());
QtIOCompressor compressor(&f);
compressor.setStreamFormat(QtIOCompressor::GzipFormat);
if (compressor.open(QIODevice::WriteOnly)) {
compressor.write(data);
}
}
void KdbxXmlWriter::writeBinaries()
{
m_xml.writeStartElement("Binaries");
QHash<QByteArray, int>::const_iterator i;
for (i = m_idMap.constBegin(); i != m_idMap.constEnd(); ++i) {
m_xml.writeStartElement("Binary");
m_xml.writeAttribute("ID", QString::number(i.value()));
QByteArray data;
if (m_db->compressionAlgorithm() == Database::CompressionGZip) {
m_xml.writeAttribute("Compressed", "True");
QBuffer buffer;
buffer.open(QIODevice::ReadWrite);
QtIOCompressor compressor(&buffer);
compressor.setStreamFormat(QtIOCompressor::GzipFormat);
compressor.open(QIODevice::WriteOnly);
qint64 bytesWritten = compressor.write(i.key());
Q_ASSERT(bytesWritten == i.key().size());
Q_UNUSED(bytesWritten);
compressor.close();
buffer.seek(0);
data = buffer.readAll();
} else {
data = i.key();
}
if (!data.isEmpty()) {
m_xml.writeCharacters(QString::fromLatin1(data.toBase64()));
}
m_xml.writeEndElement();
}
m_xml.writeEndElement();
}
static int crypt_all(int *pcount, struct db_salt *salt)
{
const int count = *pcount;
int index = 0;
#ifdef _OPENMP
#pragma omp parallel for
for (index = 0; index < count; index++)
#endif
{
// hash is compressor(md5(password))
MD5_CTX ctx;
unsigned char *out = (unsigned char*)crypt_out[index];
unsigned char hash[16];
MD5_Init(&ctx);
MD5_Update(&ctx, saved_key[index], saved_len[index]);
MD5_Final(hash, &ctx);
compressor(hash, out);
}
return count;
}
/*static*/
KValueRef Codec::CreateZipAsync(const ValueList& args)
{
std::string directory = args.GetString(0);
std::string zipFile = args.GetString(1);
AutoPtr<AsyncJob> job = args.GetObject(2).cast<AsyncJob>();
KMethodRef callback = 0;
if (args.size() > 3)
{
callback = args.GetMethod(3);
}
Poco::Path path(directory);
path.makeDirectory();
std::ofstream stream(UTF8ToSystem(zipFile).c_str(),
std::ios::binary | std::ios::trunc);
Poco::Zip::Compress compressor(stream, true);
try
{
compressor.addRecursive(path);
}
catch (std::exception& e)
{
Logger::Get("Codec")->Error("exception compressing: %s", e.what());
throw ValueException::FromFormat("Exception during zip: %s", e.what());
}
compressor.close();
stream.close();
if (!callback.isNull())
{
ValueList args;
args.push_back(Value::NewString(zipFile));
RunOnMainThread(callback, args, true);
}
return Value::Undefined;
}
void MusicLibraryModel::convertCache(const QString &compressedName)
{
QString prev=compressedName;
prev.replace(constLibraryCompressedExt, constLibraryExt);
if (QFile::exists(prev) && !QFile::exists(compressedName)) {
QFile old(prev);
if (old.open(QIODevice::ReadOnly)) {
QByteArray a=old.readAll();
old.close();
QFile newCache(compressedName);
QtIOCompressor compressor(&newCache);
compressor.setStreamFormat(QtIOCompressor::GzipFormat);
if (compressor.open(QIODevice::WriteOnly)) {
compressor.write(a);
compressor.close();
QFile::remove(prev);
}
}
}
}
void BpfWriter::writeDimMajor(const PointView* data)
{
// We're going to pretend for now that we only even have one point buffer.
BpfCompressor compressor(m_stream, data->size() * sizeof(float));
for (auto & bpfDim : m_dims)
{
if (m_header.m_compression)
compressor.startBlock();
for (PointId idx = 0; idx < data->size(); ++idx)
{
double d = getAdjustedValue(data, bpfDim, idx);
m_stream << (float)d;
}
if (m_header.m_compression)
{
compressor.compress();
compressor.finish();
}
}
}
void ImapTransport::test()
{
#if 0
qMailLog(IMAP) << "Rfc1951Compressor and Rfc1951Decompressor functional testing running...";
// Mainly aiming to test for bounday conditions
// So make the compression/decompression buffers about the same size as the input/output
QByteArray data("This\n is some test data.\r\n The quick brown fox jumps over the lazy dog. 0123456789.\r\n");
for(int i = 10; i <= 100; ++ i) {
for(int j = 10; i <= 100; ++ i) {
for (int k = 10; k <= 100; ++k) {
Rfc1951Compressor compressor(i);
Rfc1951Decompressor decompressor(j);
QByteArray input(data.left(k));
input += "\r\n";
QByteArray compressed;
{
QDataStream stream(&compressed, QIODevice::WriteOnly);
compressor.write(&stream, &input);
}
{
QByteArray output;
QBuffer buffer(&compressed);
buffer.open(QIODevice::ReadOnly);
decompressor.consume(&buffer);
while (decompressor.canReadLine()) {
output += decompressor.readLine();
}
if (input != output) {
qMailLog(IMAP) << "Test failure: input" << input.toHex() << "output" << output.toHex();
Q_ASSERT(input == output);
}
}
}
}
}
qMailLog(IMAP) << "Rfc1951Compressor and Rfc1951Decompressor functional testing completed OK";
#endif
}
