void read_and_check_pixels(skiatest::Reporter* reporter, GrTexture* texture, U8CPU expected,
U8CPU error, const char* subtestName) {
int w = texture->width();
int h = texture->height();
SkAutoTMalloc<uint32_t> readData(w * h);
memset(readData.get(), 0, sizeof(uint32_t) * w * h);
if (!texture->readPixels(0, 0, w, h, texture->config(), readData.get())) {
ERRORF(reporter, "Could not read pixels for %s.", subtestName);
return;
}
for (int j = 0; j < h; ++j) {
for (int i = 0; i < w; ++i) {
uint32_t read = readData[j * w + i];
bool success =
check_value(read & 0xff, expected, error) &&
check_value((read >> 8) & 0xff, expected, error) &&
check_value((read >> 16) & 0xff, expected, error);
if (!success) {
ERRORF(reporter, "Expected 0xff%02x%02x%02x, read back as 0x%08x in %s at %d, %d.",
expected, expected, expected, read, subtestName, i, j);
return;
}
}
}
}
static void test_abortWithFile(skiatest::Reporter* reporter) {
SkString tmpDir = skiatest::GetTmpDir();
if (tmpDir.isEmpty()) {
ERRORF(reporter, "missing tmpDir.");
return;
}
SkString path = SkOSPath::Join(tmpDir.c_str(), "aborted.pdf");
if (!SkFILEWStream(path.c_str()).isValid()) {
ERRORF(reporter, "unable to write to: %s", path.c_str());
return;
}
// Make sure doc's destructor is called to flush.
{
SkFILEWStream stream(path.c_str());
auto doc = SkPDF::MakeDocument(&stream);
SkCanvas* canvas = doc->beginPage(100, 100);
canvas->drawColor(SK_ColorRED);
doc->endPage();
doc->abort();
}
FILE* file = fopen(path.c_str(), "r");
// Test that only the header is written, not the full document.
char buffer[256];
REPORTER_ASSERT(reporter, fread(buffer, 1, sizeof(buffer), file) < sizeof(buffer));
fclose(file);
}
void run(skiatest::Reporter* reporter) {
GrMockOptions mockOptions;
mockOptions.fInstanceAttribSupport = true;
mockOptions.fMapBufferFlags = GrCaps::kCanMap_MapFlag;
mockOptions.fConfigOptions[kAlpha_half_GrPixelConfig].fRenderability =
GrMockOptions::ConfigOptions::Renderability::kNonMSAA;
mockOptions.fConfigOptions[kAlpha_half_GrPixelConfig].fTexturable = true;
mockOptions.fGeometryShaderSupport = true;
mockOptions.fIntegerSupport = true;
mockOptions.fFlatInterpolationSupport = true;
GrContextOptions ctxOptions;
ctxOptions.fAllowPathMaskCaching = false;
ctxOptions.fGpuPathRenderers = GpuPathRenderers::kCoverageCounting;
fMockContext = GrContext::MakeMock(&mockOptions, ctxOptions);
if (!fMockContext) {
ERRORF(reporter, "could not create mock context");
return;
}
if (!fMockContext->unique()) {
ERRORF(reporter, "mock context is not unique");
return;
}
CCPRPathDrawer ccpr(fMockContext.get(), reporter);
if (!ccpr.valid()) {
return;
}
fPath.moveTo(0, 0);
fPath.cubicTo(50, 50, 0, 50, 50, 0);
this->onRun(reporter, ccpr);
}
static void test_file(skiatest::Reporter* reporter) {
SkString tmpDir = skiatest::GetTmpDir();
if (tmpDir.isEmpty()) {
ERRORF(reporter, "missing tmpDir.");
return;
}
SkString path = SkOSPath::Join(tmpDir.c_str(), "file.pdf");
if (!SkFILEWStream(path.c_str()).isValid()) {
ERRORF(reporter, "unable to write to: %s", path.c_str());
return;
}
{
SkFILEWStream stream(path.c_str());
auto doc = SkPDF::MakeDocument(&stream);
SkCanvas* canvas = doc->beginPage(100, 100);
canvas->drawColor(SK_ColorRED);
doc->endPage();
doc->close();
}
FILE* file = fopen(path.c_str(), "r");
REPORTER_ASSERT(reporter, file != nullptr);
char header[100];
REPORTER_ASSERT(reporter, fread(header, 4, 1, file) != 0);
REPORTER_ASSERT(reporter, strncmp(header, "%PDF", 4) == 0);
fclose(file);
}
DEF_TEST(JpegIdentification, r) {
static struct {
const char* path;
bool isJfif;
SkJFIFInfo::Type type;
} kTests[] = {{"CMYK.jpg", false, SkJFIFInfo::kGrayscale},
{"color_wheel.jpg", true, SkJFIFInfo::kYCbCr},
{"grayscale.jpg", true, SkJFIFInfo::kGrayscale},
{"mandrill_512_q075.jpg", true, SkJFIFInfo::kYCbCr},
{"randPixels.jpg", true, SkJFIFInfo::kYCbCr}};
for (size_t i = 0; i < SK_ARRAY_COUNT(kTests); ++i) {
SkAutoTUnref<SkData> data(
load_resource(r, "JpegIdentification", kTests[i].path));
if (!data) {
continue;
}
SkJFIFInfo info;
bool isJfif = SkIsJFIF(data, &info);
if (isJfif != kTests[i].isJfif) {
ERRORF(r, "%s failed isJfif test", kTests[i].path);
continue;
}
if (!isJfif) {
continue; // not applicable
}
if (kTests[i].type != info.fType) {
ERRORF(r, "%s failed jfif type test", kTests[i].path);
continue;
}
if (r->verbose()) {
SkDebugf("\nJpegIdentification: %s [%d x %d]\n", kTests[i].path,
info.fSize.width(), info.fSize.height());
}
}
}
void test_write_pixels(skiatest::Reporter* reporter,
GrSurfaceContext* dstContext, bool expectedToWork,
const char* testName) {
int pixelCnt = dstContext->width() * dstContext->height();
SkAutoTMalloc<uint32_t> pixels(pixelCnt);
for (int y = 0; y < dstContext->width(); ++y) {
for (int x = 0; x < dstContext->height(); ++x) {
pixels.get()[y * dstContext->width() + x] =
GrPremulColor(GrColorPackRGBA(x, y, x + y, 2*y));
}
}
SkImageInfo ii = SkImageInfo::Make(dstContext->width(), dstContext->height(),
kRGBA_8888_SkColorType, kPremul_SkAlphaType);
bool write = dstContext->writePixels(ii, pixels.get(), 0, 0, 0);
if (!write) {
if (expectedToWork) {
ERRORF(reporter, "%s: Error writing to texture.", testName);
}
return;
}
if (write && !expectedToWork) {
ERRORF(reporter, "%s: writePixels succeeded when it wasn't supposed to.", testName);
return;
}
test_read_pixels(reporter, dstContext, pixels.get(), testName);
}
/**
* @brief Prepares AES encryption and decryption contexts.
*
* Create an 256 bit key and IV using the supplied key_data. salt can be added for taste.
* Fills in the encryption and decryption ctx objects and returns 0 on success
*
* Code adapted from: http://saju.net.in/code/misc/openssl_aes.c.txt
*
* @param key_data
* @param key_data_len
* @param salt
* @param e_ctx
* @param d_ctx
*
* @return 0 on success
*/
int aes_init(unsigned char *en_key_data, int en_key_data_len,
unsigned char *de_key_data, int de_key_data_len,
unsigned char *salt, EVP_CIPHER_CTX *e_ctx,
EVP_CIPHER_CTX *d_ctx) {
int i, nrounds = 5;
unsigned char en_key[32], en_iv[32], de_key[32], de_iv[32];
/*
* Gen key & IV for AES 256 CBC mode. A SHA1 digest is used to hash the supplied key material.
* nrounds is the number of times the we hash the material. More rounds are more secure but
* slower.
*/
i = EVP_BytesToKey(EVP_aes_256_cbc(), EVP_sha1(), salt, en_key_data, en_key_data_len, nrounds, en_key, en_iv);
if (i != 32) {
ERRORF("Key size is %d bits - should be 256 bits", i);
return -1;
}
if (EVP_EncryptInit_ex(e_ctx, EVP_aes_256_cbc(), NULL, en_key, en_iv) != 1) {
ERROR("ERROR initializing encryption context");
return -1;
}
i = EVP_BytesToKey(EVP_aes_256_cbc(), EVP_sha1(), salt, de_key_data, de_key_data_len, nrounds, de_key, de_iv);
if (i != 32) {
ERRORF("Key size is %d bits - should be 256 bits", i);
return -1;
}
if (EVP_DecryptInit_ex(d_ctx, EVP_aes_256_cbc(), NULL, de_key, de_iv) != 1) {
ERROR("ERROR initializing decryption context");
return -1;
}
return 0;
}
static void TestPackedUInt(skiatest::Reporter* reporter) {
// we know that packeduint tries to write 1, 2 or 4 bytes for the length,
// so we test values around each of those transitions (and a few others)
const size_t sizes[] = {
0, 1, 2, 0xFC, 0xFD, 0xFE, 0xFF, 0x100, 0x101, 32767, 32768, 32769,
0xFFFD, 0xFFFE, 0xFFFF, 0x10000, 0x10001,
0xFFFFFD, 0xFFFFFE, 0xFFFFFF, 0x1000000, 0x1000001,
0x7FFFFFFE, 0x7FFFFFFF, 0x80000000, 0x80000001, 0xFFFFFFFE, 0xFFFFFFFF
};
size_t i;
SkDynamicMemoryWStream wstream;
for (i = 0; i < SK_ARRAY_COUNT(sizes); ++i) {
bool success = wstream.writePackedUInt(sizes[i]);
REPORTER_ASSERT(reporter, success);
}
std::unique_ptr<SkStreamAsset> rstream(wstream.detachAsStream());
for (i = 0; i < SK_ARRAY_COUNT(sizes); ++i) {
size_t n;
if (!rstream->readPackedUInt(&n)) {
ERRORF(reporter, "[%d] sizes:%x could not be read\n", i, sizes[i]);
}
if (sizes[i] != n) {
ERRORF(reporter, "[%d] sizes:%x != n:%x\n", i, sizes[i], n);
}
}
}
// Asserts that asset == expected and is peekable.
static void stream_peek_test(skiatest::Reporter* rep,
SkStreamAsset* asset,
const SkData* expected) {
if (asset->getLength() != expected->size()) {
ERRORF(rep, "Unexpected length.");
return;
}
SkRandom rand;
uint8_t buffer[4096];
const uint8_t* expect = expected->bytes();
for (size_t i = 0; i < asset->getLength(); ++i) {
uint32_t maxSize =
SkToU32(SkTMin(sizeof(buffer), asset->getLength() - i));
size_t size = rand.nextRangeU(1, maxSize);
SkASSERT(size >= 1);
SkASSERT(size <= sizeof(buffer));
SkASSERT(size + i <= asset->getLength());
if (asset->peek(buffer, size) < size) {
ERRORF(rep, "Peek Failed!");
return;
}
if (0 != memcmp(buffer, &expect[i], size)) {
ERRORF(rep, "Peek returned wrong bytes!");
return;
}
uint8_t value;
REPORTER_ASSERT(rep, 1 == asset->read(&value, 1));
if (value != expect[i]) {
ERRORF(rep, "Read Failed!");
return;
}
}
}
char* PEGCU_get_confpath(){
char* config;
config = getenv("EGC_CONFIG");
if(config == NULL){
ERRORF("EGC: No config file.\n");
ERRORF(" : the file name must be set on ENV value \"EGC_CONFIG\".\n");
ERROR_EXIT();
}
return config;
}
DEF_TEST(SkDeflateWStream, r) {
SkRandom random(123456);
for (int i = 0; i < 50; ++i) {
uint32_t size = random.nextULessThan(10000);
SkAutoTMalloc<uint8_t> buffer(size);
for (uint32_t j = 0; j < size; ++j) {
buffer[j] = random.nextU() & 0xff;
}
SkDynamicMemoryWStream dynamicMemoryWStream;
{
SkDeflateWStream deflateWStream(&dynamicMemoryWStream);
uint32_t j = 0;
while (j < size) {
uint32_t writeSize =
SkTMin(size - j, random.nextRangeU(1, 400));
if (!deflateWStream.write(&buffer[j], writeSize)) {
ERRORF(r, "something went wrong.");
return;
}
j += writeSize;
}
}
SkAutoTDelete<SkStreamAsset> compressed(
dynamicMemoryWStream.detachAsStream());
SkAutoTDelete<SkStreamAsset> decompressed(stream_inflate(compressed));
if (decompressed->getLength() != size) {
ERRORF(r, "Decompression failed to get right size [%d]."
" %u != %u", i, (unsigned)(decompressed->getLength()),
(unsigned)size);
SkString s = SkStringPrintf("/tmp/deftst_compressed_%d", i);
SkFILEWStream o(s.c_str());
o.writeStream(compressed.get(), compressed->getLength());
compressed->rewind();
s = SkStringPrintf("/tmp/deftst_input_%d", i);
SkFILEWStream o2(s.c_str());
o2.write(&buffer[0], size);
continue;
}
uint32_t minLength = SkTMin(size,
(uint32_t)(decompressed->getLength()));
for (uint32_t i = 0; i < minLength; ++i) {
uint8_t c;
SkDEBUGCODE(size_t rb =)decompressed->read(&c, sizeof(uint8_t));
SkASSERT(sizeof(uint8_t) == rb);
if (buffer[i] != c) {
ERRORF(r, "Decompression failed at byte %u.", (unsigned)i);
break;
}
}
}
}
int PEGCU_get_jobid(){
char* idstr;
int jid;
idstr = getenv("EGC_JID");
if(idstr == NULL){
ERRORF("EGC: No Assined JOBID.\n");
ERRORF(" : the jobid must be set on ENV value \"EGC_JID\".\n");
ERROR_EXIT();
}
jid = atoi(idstr);
return jid;
}
CCPRPathDrawer(GrContext* ctx, skiatest::Reporter* reporter)
: fCtx(ctx)
, fCCPR(fCtx->contextPriv().drawingManager()->getCoverageCountingPathRenderer())
, fRTC(fCtx->makeDeferredRenderTargetContext(SkBackingFit::kExact, kCanvasSize,
kCanvasSize, kRGBA_8888_GrPixelConfig,
nullptr)) {
if (!fCCPR) {
ERRORF(reporter, "ccpr not enabled in GrContext for ccpr tests");
}
if (!fRTC) {
ERRORF(reporter, "failed to create GrRenderTargetContext for ccpr tests");
}
}
DEF_GPUTEST_FOR_ALL_GL_CONTEXTS(VertexAttributeCount, reporter, ctxInfo) {
GrContext* context = ctxInfo.fGrContext;
GrTextureDesc desc;
desc.fHeight = 1;
desc.fWidth = 1;
desc.fFlags = kRenderTarget_GrSurfaceFlag;
desc.fConfig = kRGBA_8888_GrPixelConfig;
SkAutoTUnref<GrTexture> target(context->textureProvider()->createTexture(desc,
SkBudgeted::kYes));
if (!target) {
ERRORF(reporter, "Could not create render target.");
return;
}
SkAutoTUnref<GrDrawContext> dc(context->drawContext(target->asRenderTarget()));
if (!dc) {
ERRORF(reporter, "Could not create draw context.");
return;
}
int attribCnt = context->caps()->maxVertexAttributes();
if (!attribCnt) {
ERRORF(reporter, "No attributes allowed?!");
return;
}
context->flush();
context->resetGpuStats();
#if GR_GPU_STATS
REPORTER_ASSERT(reporter, context->getGpu()->stats()->numDraws() == 0);
REPORTER_ASSERT(reporter, context->getGpu()->stats()->numFailedDraws() == 0);
#endif
SkAutoTUnref<GrDrawBatch> batch;
GrPipelineBuilder pb;
pb.setRenderTarget(target->asRenderTarget());
// This one should succeed.
batch.reset(new Batch(attribCnt));
dc->drawContextPriv().testingOnly_drawBatch(pb, batch);
context->flush();
#if GR_GPU_STATS
REPORTER_ASSERT(reporter, context->getGpu()->stats()->numDraws() == 1);
REPORTER_ASSERT(reporter, context->getGpu()->stats()->numFailedDraws() == 0);
#endif
context->resetGpuStats();
// This one should fail.
batch.reset(new Batch(attribCnt+1));
dc->drawContextPriv().testingOnly_drawBatch(pb, batch);
context->flush();
#if GR_GPU_STATS
REPORTER_ASSERT(reporter, context->getGpu()->stats()->numDraws() == 0);
REPORTER_ASSERT(reporter, context->getGpu()->stats()->numFailedDraws() == 1);
#endif
}
int app_receive_data_packet(int fd, int* seq_number, char** buffer, int* length)
{
char* packet_buffer;
ssize_t total_size = ll_read(fd, &packet_buffer);
if (total_size < 0)
{
perror("ll_read");
return -1;
}
int ctrl = packet_buffer[0];
if (ctrl != CONTROL_FIELD_DATA)
{
ERRORF("Control field received (%d) is not CONTROL_FIELD_DATA", ctrl);
return -1;
}
int seq = (unsigned char)packet_buffer[1];
int32 size;
size.b[0] = packet_buffer[2];
size.b[1] = packet_buffer[3];
size.b[2] = packet_buffer[4];
size.b[3] = packet_buffer[5];
*buffer = malloc(size.w);
memcpy(*buffer, &packet_buffer[6], size.w);
free(packet_buffer);
*seq_number = seq;
*length = size.w;
return 0;
}
static void test_dimensions(skiatest::Reporter* r, const char path[]) {
// Create the codec from the resource file
SkAutoTDelete<SkStream> stream(resource(path));
if (!stream) {
SkDebugf("Missing resource '%s'\n", path);
return;
}
SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(stream.detach()));
if (!codec) {
ERRORF(r, "Unable to create codec '%s'", path);
return;
}
// Check that the decode is successful for a variety of scales
for (float scale = -0.05f; scale < 2.0f; scale += 0.05f) {
// Scale the output dimensions
SkISize scaledDims = codec->getScaledDimensions(scale);
SkImageInfo scaledInfo = codec->getInfo().makeWH(scaledDims.width(), scaledDims.height());
// Set up for the decode
size_t rowBytes = scaledDims.width() * sizeof(SkPMColor);
size_t totalBytes = scaledInfo.getSafeSize(rowBytes);
SkAutoTMalloc<SkPMColor> pixels(totalBytes);
SkImageGenerator::Result result =
codec->getPixels(scaledInfo, pixels.get(), rowBytes, NULL, NULL, NULL);
REPORTER_ASSERT(r, SkImageGenerator::kSuccess == result);
}
}
DEF_TEST(DiscardablePixelRef_SecondLockColorTableCheck, r) {
SkString resourceDir = GetResourcePath();
SkString path = SkOSPath::Join(resourceDir.c_str(), "randPixels.gif");
if (!sk_exists(path.c_str())) {
return;
}
SkAutoDataUnref encoded(SkData::NewFromFileName(path.c_str()));
SkBitmap bitmap;
if (!SkInstallDiscardablePixelRef(
SkDecodingImageGenerator::Create(
encoded, SkDecodingImageGenerator::Options()), &bitmap)) {
#ifndef SK_BUILD_FOR_WIN
ERRORF(r, "SkInstallDiscardablePixelRef [randPixels.gif] failed.");
#endif
return;
}
if (kIndex_8_SkColorType != bitmap.colorType()) {
return;
}
{
SkAutoLockPixels alp(bitmap);
REPORTER_ASSERT(r, bitmap.getColorTable() && "first pass");
}
{
SkAutoLockPixels alp(bitmap);
REPORTER_ASSERT(r, bitmap.getColorTable() && "second pass");
}
}
void check_pixels(skiatest::Reporter* reporter, const SkBitmap& bitmap) {
const uint32_t* canvasPixels = static_cast<const uint32_t*>(bitmap.getPixels());
bool failureFound = false;
SkPMColor expectedPixel;
for (int cy = 0; cy < CHILD_H && !failureFound; ++cy) {
for (int cx = 0; cx < CHILD_W && !failureFound; ++cx) {
SkPMColor canvasPixel = canvasPixels[cy * CHILD_W + cx];
if (cy < CHILD_H / 2) {
if (cx < CHILD_W / 2) {
expectedPixel = 0xFF0000FF; // Red
} else {
expectedPixel = 0xFFFF0000; // Blue
}
} else {
expectedPixel = 0xFF00FF00; // Green
}
if (expectedPixel != canvasPixel) {
failureFound = true;
ERRORF(reporter, "Wrong color at %d, %d. Got 0x%08x when we expected 0x%08x",
cx, cy, canvasPixel, expectedPixel);
}
}
}
}
/**
* Finally, make sure that if we get ETC1 data from a PKM file that we can then
* accurately write it out into a KTX file (i.e. transferring the ETC1 data from
* the PKM to the KTX should produce an identical KTX to the one we have on file)
*/
DEF_TEST(KtxReexportPKM, reporter) {
SkString pkmFilename = GetResourcePath("mandrill_128.pkm");
// Load PKM file into a bitmap
SkBitmap etcBitmap;
SkAutoTUnref<SkData> fileData(SkData::NewFromFileName(pkmFilename.c_str()));
if (nullptr == fileData) {
SkDebugf("KtxReexportPKM: can't load test file %s\n", pkmFilename.c_str());
return;
}
bool installDiscardablePixelRefSuccess =
SkDEPRECATED_InstallDiscardablePixelRef(fileData, &etcBitmap);
if (!installDiscardablePixelRefSuccess) {
ERRORF(reporter, "failed to create discardable pixelRef from KTX file");
return;
}
// Write the bitmap out to a KTX file.
SkData *ktxDataPtr = SkImageEncoder::EncodeData(etcBitmap, SkImageEncoder::kKTX_Type, 0);
SkAutoDataUnref newKtxData(ktxDataPtr);
REPORTER_ASSERT(reporter, ktxDataPtr);
// See is this data is identical to data in existing ktx file.
SkString ktxFilename = GetResourcePath("mandrill_128.ktx");
SkAutoDataUnref oldKtxData(SkData::NewFromFileName(ktxFilename.c_str()));
REPORTER_ASSERT(reporter, oldKtxData->equals(newKtxData));
}
void Arc::GraphicsSystem::resetGL( void )
{
// Setup OpenGL for drawing 2D
glViewport(0, 0, (int)_windowSize.X, (int)_windowSize.Y);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, (int)_windowSize.X, (int)_windowSize.Y, 0, 1, -1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// Enable blending and set the blending function for scaling
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// Clear the background to the clear color
glClearColor(_clearColor.getFracR(), _clearColor.getFracG(), _clearColor.getFracB(), _clearColor.getFracA());
glClear(GL_COLOR_BUFFER_BIT);
SDL_GL_SwapBuffers();
GLenum error = glGetError();
// Handle any errors
if (error != GL_NO_ERROR)
{
ERRORF(toString(), "Failed to initialize OpenGL (%s)", gluErrorString(error));
die();
}
// Tell any textures or fonts to reload their data
dispatchEvent(Event(EVENT_GRAPHICS_RESET));
}
DEF_TEST(Image_NewFromGenerator, r) {
TestImageGenerator::TestType testTypes[] = {
TestImageGenerator::kFailGetPixels_TestType,
TestImageGenerator::kSucceedGetPixels_TestType,
};
for (size_t i = 0; i < SK_ARRAY_COUNT(testTypes); ++i) {
TestImageGenerator::TestType test = testTypes[i];
SkImageGenerator* gen = SkNEW_ARGS(TestImageGenerator, (test, r));
SkAutoTUnref<SkImage> image(SkImage::NewFromGenerator(gen));
if (NULL == image.get()) {
ERRORF(r, "SkImage::NewFromGenerator unexpecedly failed ["
SK_SIZE_T_SPECIFIER "]", i);
continue;
}
REPORTER_ASSERT(r, TestImageGenerator::Width() == image->width());
REPORTER_ASSERT(r, TestImageGenerator::Height() == image->height());
SkBitmap bitmap;
bitmap.allocN32Pixels(TestImageGenerator::Width(), TestImageGenerator::Height());
SkCanvas canvas(bitmap);
const SkColor kDefaultColor = 0xffabcdef;
canvas.clear(kDefaultColor);
canvas.drawImage(image, 0, 0, NULL);
if (TestImageGenerator::kSucceedGetPixels_TestType == test) {
REPORTER_ASSERT(
r, TestImageGenerator::Color() == *bitmap.getAddr32(0, 0));
} else {
REPORTER_ASSERT(r, kDefaultColor == bitmap.getColor(0,0));
}
}
}
/**
* @brief Sign a message with provided RSA key.
*
* Hash msg (SHA1) and encrypt the resulting digest. The buffer supplied to hold
* the signature must be at least RSA_size(keypair) bytes long.
*
* @param msg Data to sign.
* @param msg_len Size of data to sign.
* @param sigbuf Buffer to hold created signature.
* @param sigbuflen Space available for signature.
*
* @return Size of signature on success, 0 on error.
*/
uint32_t sign(RSA *keypair, char *msg, size_t msg_len, char *sigbuf, int sigbuflen) {
if (sigbuflen < RSA_size(keypair)) {
ERROR("ERROR: Could not sign message because sigbuf is too small");
return 0;
}
/* first hash msg */
unsigned char *digest = hash(msg, msg_len);
if (digest == NULL) {
ERROR("ERROR: Unable to hash message");
return 0;
}
/* now sign the hash */
uint32_t siglen;
if (RSA_sign(NID_sha1, digest, SHA_DIGEST_LENGTH, (unsigned char*)sigbuf, &siglen, keypair) != 1) {
char *err = (char *)malloc(130); //FIXME?
ERR_load_crypto_strings();
ERR_error_string(ERR_get_error(), err);
ERRORF("Error signing message: %s", err);
free(err);
return 0;
}
free(digest);
return siglen;
}
DEF_TEST(SVGDevice_image_shader_tileboth, reporter) {
SkDOM dom;
SkPaint paint;
int imageWidth = 3, imageHeight = 3;
int rectWidth = 10, rectHeight = 10;
ImageShaderTestSetup(&dom, &paint, imageWidth, imageHeight, rectWidth, rectHeight,
SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);
const SkDOM::Node* root = dom.finishParsing();
const SkDOM::Node *patternNode, *imageNode, *rectNode;
const SkDOM::Node* innerSvg = dom.getFirstChild(root, "svg");
if (innerSvg == nullptr) {
ERRORF(reporter, "inner svg element not found");
return;
}
bool structureAppropriate =
FindImageShaderNodes(reporter, &dom, innerSvg, &patternNode, &imageNode, &rectNode);
REPORTER_ASSERT(reporter, structureAppropriate);
// the imageNode should always maintain its size.
REPORTER_ASSERT(reporter, atoi(dom.findAttr(imageNode, "width")) == imageWidth);
REPORTER_ASSERT(reporter, atoi(dom.findAttr(imageNode, "height")) == imageHeight);
REPORTER_ASSERT(reporter, atoi(dom.findAttr(patternNode, "width")) == imageWidth);
REPORTER_ASSERT(reporter, atoi(dom.findAttr(patternNode, "height")) == imageHeight);
}
static int
_search_wait_for_child(ParentCtx *ctx, int status)
{
assert(ctx != NULL);
assert(ctx->child_pid > 0);
DEBUGF("search", "Waiting for child process with pid %ld.", ctx->child_pid);
int child_status;
int rc;
if((rc = waitpid(ctx->child_pid, &child_status, 0)) == ctx->child_pid)
{
if(WIFEXITED(child_status) && status == PROCESS_STATUS_OK)
{
if(child_status)
{
status = PROCESS_STATUS_ERROR;
}
else
{
status = PROCESS_STATUS_FINISHED;
}
}
}
else if(rc == -1)
{
ERRORF("search", "`waitpid' failed, rc=%d.", rc);
status = PROCESS_STATUS_ERROR;
}
return status;
}
static void TestPackedUInt(skiatest::Reporter* reporter) {
// we know that packeduint tries to write 1, 2 or 4 bytes for the length,
// so we test values around each of those transitions (and a few others)
const size_t sizes[] = {
0, 1, 2, 0xFC, 0xFD, 0xFE, 0xFF, 0x100, 0x101, 32767, 32768, 32769,
0xFFFD, 0xFFFE, 0xFFFF, 0x10000, 0x10001,
0xFFFFFD, 0xFFFFFE, 0xFFFFFF, 0x1000000, 0x1000001,
0x7FFFFFFE, 0x7FFFFFFF, 0x80000000, 0x80000001, 0xFFFFFFFE, 0xFFFFFFFF
};
size_t i;
char buffer[sizeof(sizes) * 4];
SkMemoryWStream wstream(buffer, sizeof(buffer));
for (i = 0; i < SK_ARRAY_COUNT(sizes); ++i) {
bool success = wstream.writePackedUInt(sizes[i]);
REPORTER_ASSERT(reporter, success);
}
wstream.flush();
SkMemoryStream rstream(buffer, sizeof(buffer));
for (i = 0; i < SK_ARRAY_COUNT(sizes); ++i) {
size_t n = rstream.readPackedUInt();
if (sizes[i] != n) {
ERRORF(reporter, "sizes:%x != n:%x\n", i, sizes[i], n);
}
}
}
static void test_dimensions(skiatest::Reporter* r, const char path[]) {
// Create the codec from the resource file
SkAutoTDelete<SkStream> stream(resource(path));
if (!stream) {
SkDebugf("Missing resource '%s'\n", path);
return;
}
SkAutoTDelete<SkAndroidCodec> codec(SkAndroidCodec::NewFromStream(stream.detach()));
if (!codec) {
ERRORF(r, "Unable to create codec '%s'", path);
return;
}
// Check that the decode is successful for a variety of scales
for (int sampleSize = 1; sampleSize < 32; sampleSize++) {
// Scale the output dimensions
SkISize scaledDims = codec->getSampledDimensions(sampleSize);
SkImageInfo scaledInfo = codec->getInfo()
.makeWH(scaledDims.width(), scaledDims.height())
.makeColorType(kN32_SkColorType);
// Set up for the decode
size_t rowBytes = scaledDims.width() * sizeof(SkPMColor);
size_t totalBytes = scaledInfo.getSafeSize(rowBytes);
SkAutoTMalloc<SkPMColor> pixels(totalBytes);
SkAndroidCodec::AndroidOptions options;
options.fSampleSize = sampleSize;
SkCodec::Result result =
codec->getAndroidPixels(scaledInfo, pixels.get(), rowBytes, &options);
REPORTER_ASSERT(r, SkCodec::kSuccess == result);
}
}
DEF_TEST(Codec_jpeg_rewind, r) {
const char* path = "mandrill_512_q075.jpg";
SkAutoTDelete<SkStream> stream(resource(path));
if (!stream) {
SkDebugf("Missing resource '%s'\n", path);
return;
}
SkAutoTDelete<SkAndroidCodec> codec(SkAndroidCodec::NewFromStream(stream.release()));
if (!codec) {
ERRORF(r, "Unable to create codec '%s'.", path);
return;
}
const int width = codec->getInfo().width();
const int height = codec->getInfo().height();
size_t rowBytes = sizeof(SkPMColor) * width;
SkAutoMalloc pixelStorage(height * rowBytes);
// Perform a sampled decode.
SkAndroidCodec::AndroidOptions opts;
opts.fSampleSize = 12;
codec->getAndroidPixels(codec->getInfo().makeWH(width / 12, height / 12), pixelStorage.get(),
rowBytes, &opts);
// Rewind the codec and perform a full image decode.
SkCodec::Result result = codec->getPixels(codec->getInfo(), pixelStorage.get(), rowBytes);
REPORTER_ASSERT(r, SkCodec::kSuccess == result);
}
/* Select the loudness approximation used by the ATH adaptive auto-leveling. */
int
lame_set_athaa_loudapprox( lame_global_flags* gfp,
int athaa_loudapprox )
{
ERRORF(gfp->internal_flags, "--athaa-loudapprox is obsolete\n");
return 0;
}
static void test_files(skiatest::Reporter* reporter) {
SkString tmpDir = skiatest::Test::GetTmpDir();
if (tmpDir.isEmpty()) {
return;
}
SkString path = SkOSPath::SkPathJoin(tmpDir.c_str(), "data_test");
const char s[] = "abcdefghijklmnopqrstuvwxyz";
{
SkFILEWStream writer(path.c_str());
if (!writer.isValid()) {
ERRORF(reporter, "Failed to create tmp file %s\n", path.c_str());
return;
}
writer.write(s, 26);
}
SkFILE* file = sk_fopen(path.c_str(), kRead_SkFILE_Flag);
SkAutoTUnref<SkData> r1(SkData::NewFromFILE(file));
REPORTER_ASSERT(reporter, r1.get() != NULL);
REPORTER_ASSERT(reporter, r1->size() == 26);
REPORTER_ASSERT(reporter, strncmp(static_cast<const char*>(r1->data()), s, 26) == 0);
int fd = sk_fileno(file);
SkAutoTUnref<SkData> r2(SkData::NewFromFD(fd));
REPORTER_ASSERT(reporter, r2.get() != NULL);
REPORTER_ASSERT(reporter, r2->size() == 26);
REPORTER_ASSERT(reporter, strncmp(static_cast<const char*>(r2->data()), s, 26) == 0);
}
int op_parse_obj(t_objmodel *m, char const *filepath)
{
FILE *stream;
int i;
char buf[BFSZ];
init_instance(m);
if ((stream = fopen(filepath, "r")) == NULL)
return (ERRORNOF("fopen(\"%s\")", filepath));
while ((i = next_line_index(stream, buf)) >= 0)
{
if (i == EMPTY_LINE)
continue ;
if (g_tokens[i].fun(m, buf))
return (ERRORF("g_tokens[i].fun(..., '%s')", buf));
}
if (i != -1)
return (ERROR("parsing failed"));
qprintf(" Parsed \"\033[33m%s\033[0m\": ", filepath);
qprintf("%dposs, ", m->coords.size);
qprintf("%dtexs, ", m->textures.size);
qprintf("%dnors, ", m->normals.size);
qprintf("%dverts, ", m->vertices.size);
qprintf("%dfaces\n", m->faces.size);
fclose(stream);
return (0);
}