432 lines
No EOL
14 KiB
C++
432 lines
No EOL
14 KiB
C++
////////////////////////////////////////////////////////////////////////////////
|
|
// (c) Copyright, Ubisoft Entertainment Inc. || Created by Harbour //
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
#include "tests/config.h"
|
|
#include "tests/fixture/memoryCheckFixture.h"
|
|
#include <ubiservices/core/http/httpBinaryEntity.h>
|
|
#include <ubiservices/core/http/httpEntityBuffer.h>
|
|
#include <ubiservices/core/http/httpEntityReader.h>
|
|
#include <ubiservices/core/http/httpEntityWriter.h>
|
|
#include <ubiservices/core/http/httpStringEntity.h>
|
|
#include <ubiservices/core/http/httpStreamEntity.h>
|
|
#include <ubiservices/core/types/stringStream.h>
|
|
|
|
namespace US_NS {;
|
|
US_DEFINE_TEST(TestHttpEntity);
|
|
};
|
|
|
|
#ifndef US_DLL
|
|
namespace US_NS {;
|
|
|
|
typedef LeakChecker HTTP_ENTITY;
|
|
|
|
TEST_F(HTTP_ENTITY, LOCAL_HttpEntityReaderBinary)
|
|
{
|
|
const uint8* data = reinterpret_cast<const uint8*>("Data of the entity!!"); // 20 chars
|
|
const uint32 dataSize = 20;
|
|
const uint32 readSize = dataSize / 2;
|
|
uint8 dest[dataSize];
|
|
memset(dest, 0, dataSize);
|
|
|
|
SmartPtr<HttpEntity> entity(US_NEW(HttpBinaryEntity, data, dataSize));
|
|
|
|
HttpEntityReader reader(entity);
|
|
EXPECT_EQ(dataSize, reader.getRemaining());
|
|
|
|
uint32 byteRead = reader.read(dest, readSize);
|
|
|
|
EXPECT_EQ(readSize, byteRead);
|
|
EXPECT_EQ(dataSize - readSize, reader.getRemaining());
|
|
|
|
byteRead = reader.read(dest + byteRead, readSize);
|
|
|
|
EXPECT_EQ(readSize, byteRead);
|
|
EXPECT_EQ(0u, reader.getRemaining());
|
|
|
|
EXPECT_TRUE(memcmp(data, dest, dataSize) == 0);
|
|
}
|
|
|
|
TEST_F(HTTP_ENTITY, LOCAL_HttpEntityReaderBinaryDeferred)
|
|
{
|
|
const uint8* data = reinterpret_cast<const uint8*>("Data of the entity!!"); // 20 chars
|
|
const uint32 dataSize = 20;
|
|
const uint32 readSize = dataSize / 2;
|
|
uint32 readBytes = 0;
|
|
uint8 dest[dataSize];
|
|
memset(dest, 0, dataSize);
|
|
|
|
SmartPtr<HttpEntity> entity(US_NEW(HttpBinaryEntity, data, dataSize));
|
|
|
|
HttpEntityReader reader(entity);
|
|
EXPECT_EQ(dataSize, reader.getRemaining());
|
|
|
|
HttpEntityBuffer buffer = reader.readDeferred(readSize);
|
|
memcpy(dest, buffer.getPtr(), buffer.getSize());
|
|
readBytes += buffer.getSize();
|
|
|
|
reader.notifyReadDeferred(buffer.getSize());
|
|
EXPECT_EQ(readSize, buffer.getSize());
|
|
EXPECT_EQ(dataSize - readSize, reader.getRemaining());
|
|
|
|
buffer = reader.readDeferred(readSize);
|
|
memcpy(dest + readBytes, buffer.getPtr(), buffer.getSize());
|
|
readBytes += buffer.getSize();
|
|
|
|
reader.notifyReadDeferred(buffer.getSize());
|
|
EXPECT_EQ(dataSize, readBytes);
|
|
EXPECT_EQ(0u, reader.getRemaining());
|
|
|
|
EXPECT_TRUE(memcmp(data, dest, dataSize) == 0);
|
|
}
|
|
|
|
TEST_F(HTTP_ENTITY, LOCAL_HttpEntityReaderString)
|
|
{
|
|
const String data("Data of the entity!!"); // 20 chars
|
|
const uint32 dataSize = static_cast<uint32>(data.getLength());
|
|
const uint32 readSize = dataSize / 2;
|
|
uint8* dest = US_NEW_ARRAY(uint8, dataSize + 1);
|
|
memset(dest, 0, dataSize + 1);
|
|
|
|
SmartPtr<HttpEntity> entity(US_NEW(HttpStringEntity, data));
|
|
|
|
HttpEntityReader reader(entity);
|
|
EXPECT_EQ(dataSize, reader.getRemaining());
|
|
|
|
uint32 byteRead = reader.read(dest, readSize);
|
|
|
|
EXPECT_EQ(readSize, byteRead);
|
|
EXPECT_EQ(dataSize - readSize, reader.getRemaining());
|
|
|
|
byteRead = reader.read(dest + byteRead, readSize);
|
|
|
|
EXPECT_EQ(readSize, byteRead);
|
|
EXPECT_EQ(0u, reader.getRemaining());
|
|
|
|
EXPECT_STREQ(data.getUtf8(), reinterpret_cast<char*>(dest));
|
|
|
|
US_DELETE_ARRAY(dest);
|
|
}
|
|
|
|
TEST_F(HTTP_ENTITY, LOCAL_HttpEntityReaderStringDeferred)
|
|
{
|
|
const String data("Data of the entity!!"); // 20 chars
|
|
const uint32 dataSize = static_cast<uint32>(data.getLength());
|
|
const uint32 readSize = dataSize;
|
|
uint8* dest = US_NEW_ARRAY(uint8, dataSize + 1);
|
|
memset(dest, 0, dataSize + 1);
|
|
StringStream sstream;
|
|
|
|
SmartPtr<HttpEntity> entity(US_NEW(HttpStringEntity, data));
|
|
|
|
HttpEntityReader reader(entity);
|
|
EXPECT_EQ(dataSize, reader.getRemaining());
|
|
|
|
const HttpEntityBuffer buffer = reader.readDeferred(readSize);
|
|
memcpy(dest, buffer.getPtr(), buffer.getSize());
|
|
sstream << reinterpret_cast<char*>(dest);
|
|
|
|
reader.notifyReadDeferred(buffer.getSize());
|
|
|
|
EXPECT_EQ(readSize, buffer.getSize());
|
|
EXPECT_EQ(0u, reader.getRemaining());
|
|
|
|
EXPECT_STREQ(data.getUtf8(), sstream.getContent().getUtf8());
|
|
|
|
US_DELETE_ARRAY(dest);
|
|
}
|
|
|
|
TEST_F(HTTP_ENTITY, LOCAL_HttpEntityReaderPastEnd)
|
|
{
|
|
const uint8* data = reinterpret_cast<const uint8*>("Data of the entity!!"); // 20 chars
|
|
const uint32 dataSize = 20;
|
|
const uint32 readSize = dataSize;
|
|
uint8 dest[dataSize];
|
|
memset(dest, 0, dataSize);
|
|
|
|
SmartPtr<HttpEntity> entity(US_NEW(HttpBinaryEntity, data, dataSize));
|
|
|
|
HttpEntityReader reader(entity);
|
|
EXPECT_EQ(dataSize, reader.getRemaining());
|
|
|
|
uint32 byteRead = reader.read(dest, readSize);
|
|
|
|
EXPECT_EQ(readSize, byteRead);
|
|
EXPECT_EQ(0u, reader.getRemaining());
|
|
|
|
// Try to read again, this shouldn't do anything
|
|
byteRead = reader.read(dest, readSize);
|
|
|
|
EXPECT_EQ(0u, byteRead);
|
|
EXPECT_EQ(0u, reader.getRemaining());
|
|
|
|
EXPECT_TRUE(memcmp(data, dest, dataSize) == 0);
|
|
}
|
|
|
|
TEST_F(HTTP_ENTITY, LOCAL_HttpEntityReaderReadAsString)
|
|
{
|
|
const uint8* data = reinterpret_cast<const uint8*>("Data of the entity!!"); // 20 chars
|
|
const uint32 dataSize = 20;
|
|
String dest;
|
|
|
|
SmartPtr<HttpEntity> entity(US_NEW(HttpBinaryEntity, data, dataSize));
|
|
|
|
dest = HttpEntityReader::readAllAsString(entity);
|
|
|
|
EXPECT_STREQ(reinterpret_cast<const char*>(data), dest.getUtf8());
|
|
}
|
|
|
|
TEST_F(HTTP_ENTITY, LOCAL_HttpEntityWriterBinary)
|
|
{
|
|
const uint8* writeData = reinterpret_cast<const uint8*>("Data of the entity!!"); // 20 chars
|
|
const uint32 dataSize = 20;
|
|
const uint32 writeSize = dataSize / 2;
|
|
uint32 writePos = 0;
|
|
|
|
SmartPtr<HttpEntity> entity(US_NEW(HttpBinaryEntity));
|
|
HttpEntityWriter writer(entity);
|
|
|
|
uint32 writeBytes = writer.write(writeData + writePos, writeSize);
|
|
writePos += writeBytes;
|
|
|
|
EXPECT_EQ(writeSize, writeBytes);
|
|
EXPECT_EQ(writePos, entity->getDataSize());
|
|
EXPECT_EQ(writePos, entity->getAllocatedSize());
|
|
|
|
writeBytes = writer.write(writeData + writePos, writeSize);
|
|
writePos += writeBytes;
|
|
|
|
EXPECT_EQ(writeSize, writeBytes);
|
|
EXPECT_EQ(dataSize, entity->getDataSize());
|
|
EXPECT_EQ(dataSize, entity->getAllocatedSize());
|
|
|
|
// Validate the write by reading everything
|
|
uint8* dest = US_NEW_ARRAY(uint8, dataSize);
|
|
HttpEntityReader reader(entity);
|
|
|
|
reader.read(dest, dataSize);
|
|
EXPECT_TRUE(memcmp(writeData, dest, dataSize) == 0);
|
|
|
|
US_DELETE_ARRAY(dest);
|
|
}
|
|
|
|
TEST_F(HTTP_ENTITY, LOCAL_HttpEntityWriterBinaryDeferred)
|
|
{
|
|
const uint8* writeData = reinterpret_cast<const uint8*>("Data of the entity!!"); // 20 chars
|
|
const uint32 dataSize = 20;
|
|
const uint32 writeSize = dataSize / 2;
|
|
uint32 writePos = 0;
|
|
|
|
SmartPtr<HttpEntity> entity(US_NEW(HttpBinaryEntity));
|
|
HttpEntityWriter writer(entity);
|
|
|
|
HttpEntityBuffer buffer = writer.writeDeferred(writeSize);
|
|
memcpy(buffer.getPtr(), writeData + writePos, buffer.getSize());
|
|
|
|
writer.notifyWriteDeferred(buffer.getSize());
|
|
writePos += buffer.getSize();
|
|
|
|
EXPECT_EQ(writeSize, buffer.getSize());
|
|
EXPECT_EQ(writePos, entity->getDataSize());
|
|
EXPECT_EQ(writePos, entity->getAllocatedSize());
|
|
|
|
buffer = writer.writeDeferred(writeSize);
|
|
memcpy(buffer.getPtr(), writeData + writePos, buffer.getSize());
|
|
|
|
writer.notifyWriteDeferred(buffer.getSize());
|
|
writePos += buffer.getSize();
|
|
|
|
EXPECT_EQ(writeSize, buffer.getSize());
|
|
EXPECT_EQ(dataSize, entity->getDataSize());
|
|
EXPECT_EQ(dataSize, entity->getAllocatedSize());
|
|
|
|
// Validate the write by reading everything
|
|
uint8* dest = US_NEW_ARRAY(uint8, dataSize);
|
|
HttpEntityReader reader(entity);
|
|
|
|
reader.read(dest, dataSize);
|
|
EXPECT_TRUE(memcmp(writeData, dest, dataSize) == 0);
|
|
|
|
US_DELETE_ARRAY(dest);
|
|
}
|
|
|
|
TEST_F(HTTP_ENTITY, LOCAL_HttpStreamEntityAvailableBuffers)
|
|
{
|
|
const uint32 BUFFER_SIZE = 10;
|
|
|
|
HttpStreamEntity streamEntity;
|
|
|
|
// Position is zero based
|
|
EXPECT_EQ(0u, streamEntity.availableBuffers(BUFFER_SIZE - 1).size());
|
|
|
|
streamEntity.pushBuffer(HttpEntityBuffer(US_NEW_ARRAY(uint8, BUFFER_SIZE), BUFFER_SIZE));
|
|
EXPECT_EQ(0u, streamEntity.availableBuffers(BUFFER_SIZE - 1).size());
|
|
EXPECT_EQ(1, streamEntity.availableBuffers(BUFFER_SIZE).size());
|
|
EXPECT_EQ(1, streamEntity.availableBuffers(BUFFER_SIZE * 2).size());
|
|
|
|
streamEntity.pushBuffer(HttpEntityBuffer(US_NEW_ARRAY(uint8, BUFFER_SIZE), BUFFER_SIZE));
|
|
EXPECT_EQ(0u, streamEntity.availableBuffers(BUFFER_SIZE - 1).size());
|
|
EXPECT_EQ(1, streamEntity.availableBuffers(BUFFER_SIZE).size());
|
|
EXPECT_EQ(2, streamEntity.availableBuffers(BUFFER_SIZE * 2).size());
|
|
|
|
uint8* bufferPtr = streamEntity.popBuffer().getPtr();
|
|
US_DELETE_ARRAY(bufferPtr);
|
|
|
|
EXPECT_EQ(0u, streamEntity.availableBuffers(BUFFER_SIZE - 1).size());
|
|
EXPECT_EQ(0u, streamEntity.availableBuffers(BUFFER_SIZE).size());
|
|
EXPECT_EQ(0u, streamEntity.availableBuffers( (BUFFER_SIZE * 2) - 1).size());
|
|
EXPECT_EQ(1, streamEntity.availableBuffers(BUFFER_SIZE * 2).size());
|
|
|
|
bufferPtr = streamEntity.popBuffer().getPtr();
|
|
US_DELETE_ARRAY(bufferPtr);
|
|
}
|
|
|
|
|
|
TEST_F(HTTP_ENTITY, LOCAL_HttpEntityReaderStreamEntity)
|
|
{
|
|
uint8 entityData[] = "Data of the entity!!"; // 20 chars
|
|
const uint32 DATA_SIZE = 20;
|
|
const uint32 BUFFER_SIZE = 5;
|
|
|
|
uint8 dest[DATA_SIZE];
|
|
memset(dest, 0, DATA_SIZE);
|
|
|
|
// Prepare the entity
|
|
SmartPtr<HttpStreamEntity> streamEntity(US_NEW(HttpStreamEntity, DATA_SIZE));
|
|
streamEntity->pushBuffer(HttpEntityBuffer(entityData, BUFFER_SIZE));
|
|
streamEntity->pushBuffer(HttpEntityBuffer(entityData + BUFFER_SIZE, BUFFER_SIZE));
|
|
streamEntity->pushBuffer(HttpEntityBuffer(entityData + BUFFER_SIZE * 2, BUFFER_SIZE));
|
|
streamEntity->pushBuffer(HttpEntityBuffer(entityData + BUFFER_SIZE * 3, BUFFER_SIZE));
|
|
|
|
HttpEntityReader reader(SmartPtr<HttpEntity>(streamEntity.getPtr()));
|
|
EXPECT_EQ(DATA_SIZE, reader.getRemaining());
|
|
|
|
uint32 byteRead = reader.read(dest, DATA_SIZE);
|
|
uint32 totalRead = byteRead;
|
|
|
|
EXPECT_EQ(BUFFER_SIZE, byteRead);
|
|
EXPECT_EQ(DATA_SIZE - totalRead, reader.getRemaining());
|
|
|
|
byteRead = reader.read(dest + totalRead, DATA_SIZE);
|
|
totalRead += byteRead;
|
|
|
|
EXPECT_EQ(BUFFER_SIZE, byteRead);
|
|
EXPECT_EQ(DATA_SIZE - totalRead, reader.getRemaining());
|
|
|
|
byteRead = reader.read(dest + totalRead, DATA_SIZE);
|
|
totalRead += byteRead;
|
|
|
|
EXPECT_EQ(BUFFER_SIZE, byteRead);
|
|
EXPECT_EQ(DATA_SIZE - totalRead, reader.getRemaining());
|
|
|
|
byteRead = reader.read(dest + totalRead, DATA_SIZE);
|
|
totalRead += byteRead;
|
|
|
|
EXPECT_EQ(BUFFER_SIZE, byteRead);
|
|
EXPECT_EQ(DATA_SIZE - totalRead, reader.getRemaining());
|
|
EXPECT_EQ(0u, reader.getRemaining());
|
|
|
|
EXPECT_TRUE(memcmp(entityData, dest, DATA_SIZE) == 0);
|
|
}
|
|
|
|
TEST_F(HTTP_ENTITY, LOCAL_HttpEntityReaderStreamEntityOffset)
|
|
{
|
|
uint8 entityData[] = "Data of the entity!!"; // 20 chars
|
|
const uint32 DATA_SIZE = 20;
|
|
const uint32 BUFFER_SIZE = DATA_SIZE / 2;
|
|
|
|
uint8 dest[DATA_SIZE];
|
|
memset(dest, 0, DATA_SIZE);
|
|
|
|
// Prepare the entity
|
|
SmartPtr<HttpStreamEntity> streamEntity(US_NEW(HttpStreamEntity, DATA_SIZE));
|
|
streamEntity->pushBuffer(HttpEntityBuffer(entityData, BUFFER_SIZE));
|
|
streamEntity->pushBuffer(HttpEntityBuffer(entityData + BUFFER_SIZE, BUFFER_SIZE));
|
|
|
|
HttpEntityReader reader(SmartPtr<HttpEntity>(streamEntity.getPtr()));
|
|
EXPECT_EQ(DATA_SIZE, reader.getRemaining());
|
|
|
|
HttpEntityBuffer buffer = reader.readDeferred(DATA_SIZE);
|
|
memcpy(dest, buffer.getPtr(), buffer.getSize());
|
|
reader.notifyReadDeferred(buffer.getSize());
|
|
uint32 totalRead = buffer.getSize();
|
|
|
|
EXPECT_EQ(BUFFER_SIZE, buffer.getSize());
|
|
EXPECT_EQ(DATA_SIZE - totalRead, reader.getRemaining());
|
|
|
|
// Read a smaller buffer and validate that the returned buffer is offsetted
|
|
const uint32 readSize = BUFFER_SIZE / 2;
|
|
|
|
buffer = reader.readDeferred(readSize);
|
|
memcpy(dest + totalRead, buffer.getPtr(), buffer.getSize());
|
|
reader.notifyReadDeferred(buffer.getSize());
|
|
totalRead += buffer.getSize();
|
|
|
|
uint8* bufferPtr = buffer.getPtr();
|
|
EXPECT_EQ(readSize, buffer.getSize());
|
|
EXPECT_EQ(DATA_SIZE - totalRead, reader.getRemaining());
|
|
|
|
buffer = reader.readDeferred(readSize);
|
|
memcpy(dest + totalRead, buffer.getPtr(), buffer.getSize());
|
|
reader.notifyReadDeferred(buffer.getSize());
|
|
totalRead += buffer.getSize();
|
|
|
|
EXPECT_NE(bufferPtr, buffer.getPtr());
|
|
EXPECT_EQ(readSize, buffer.getSize());
|
|
EXPECT_EQ(0u, reader.getRemaining());
|
|
|
|
EXPECT_TRUE(memcmp(entityData, dest, DATA_SIZE) == 0);
|
|
|
|
// Try to read when there's nothing left
|
|
buffer = reader.readDeferred(readSize);
|
|
EXPECT_EQ(0u, buffer.getSize());
|
|
}
|
|
|
|
TEST_F(HTTP_ENTITY, LOCAL_HttpEntityWriterStreamEntity)
|
|
{
|
|
uint8 entityData[] = "Data of the entity!!"; // 20 chars
|
|
const uint32 DATA_SIZE = 20;
|
|
const uint32 BUFFER_SIZE = 5;
|
|
|
|
uint8 dest[DATA_SIZE];
|
|
memset(dest, 0, DATA_SIZE);
|
|
|
|
// Prepare the entity
|
|
SmartPtr<HttpStreamEntity> streamEntity(US_NEW(HttpStreamEntity));
|
|
|
|
HttpEntityWriter writer(SmartPtr<HttpEntity>(streamEntity.getPtr()));
|
|
|
|
uint32 byteWrite = writer.write(entityData, BUFFER_SIZE);
|
|
uint32 totalWrite = byteWrite;
|
|
EXPECT_EQ(0u, byteWrite);
|
|
|
|
streamEntity->pushBuffer(HttpEntityBuffer(dest, BUFFER_SIZE));
|
|
|
|
// Try to write more then a buffer
|
|
byteWrite = writer.write(entityData + totalWrite, BUFFER_SIZE * 2);
|
|
totalWrite += byteWrite;
|
|
EXPECT_EQ(BUFFER_SIZE, byteWrite);
|
|
|
|
streamEntity->pushBuffer(HttpEntityBuffer(dest + BUFFER_SIZE, BUFFER_SIZE));
|
|
streamEntity->pushBuffer(HttpEntityBuffer(dest + BUFFER_SIZE * 2, BUFFER_SIZE));
|
|
streamEntity->pushBuffer(HttpEntityBuffer(dest + BUFFER_SIZE * 3, BUFFER_SIZE));
|
|
|
|
byteWrite = writer.write(entityData + totalWrite, BUFFER_SIZE);
|
|
totalWrite += byteWrite;
|
|
EXPECT_EQ(BUFFER_SIZE, byteWrite);
|
|
|
|
byteWrite = writer.write(entityData + totalWrite, BUFFER_SIZE);
|
|
totalWrite += byteWrite;
|
|
EXPECT_EQ(BUFFER_SIZE, byteWrite);
|
|
|
|
byteWrite = writer.write(entityData + totalWrite, BUFFER_SIZE);
|
|
totalWrite += byteWrite;
|
|
EXPECT_EQ(BUFFER_SIZE, byteWrite);
|
|
EXPECT_EQ(DATA_SIZE, totalWrite);
|
|
|
|
EXPECT_TRUE(memcmp(entityData, dest, DATA_SIZE) == 0);
|
|
}
|
|
|
|
|
|
};
|
|
|
|
#endif |