自学教程：C++ ERRORF函数代码示例

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;            }        }    }}

    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);    }

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;}

// 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. */intlame_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);}