static void test_synthetic(skiatest::Reporter* reporter, bool verbose) {
for (size_t i = 0; i < SK_ARRAY_COUNT(test); ++i) {
SkOTTableName::Iterator iter(*test[i].data, test[i].nameID.predefined.value);
SkOTTableName::Iterator::Record record;
size_t nameIndex = 0;
while (nameIndex < test[i].nameCount && iter.next(record)) {
REPORTER_ASSERT_MESSAGE(reporter,
strcmp(test[i].names[nameIndex].name, record.name.c_str()) == 0,
"Name did not match."
);
REPORTER_ASSERT_MESSAGE(reporter,
strcmp(test[i].names[nameIndex].language, record.language.c_str()) == 0,
"Language did not match."
);
//printf("%s <%s>\n", record.name.c_str(), record.language.c_str());
++nameIndex;
}
REPORTER_ASSERT_MESSAGE(reporter, nameIndex == test[i].nameCount,
"Fewer names than expected.");
REPORTER_ASSERT_MESSAGE(reporter, !iter.next(record),
"More names than expected.");
}
}
// test that we can draw an aa-rect at coordinates > 32K (bigger than fixedpoint)
static void test_big_aa_rect(skiatest::Reporter* reporter) {
SkBitmap output;
SkPMColor pixel[1];
output.installPixels(SkImageInfo::MakeN32Premul(1, 1), pixel, 4);
SkSurface* surf = SkSurface::NewRasterN32Premul(300, 33300);
SkCanvas* canvas = surf->getCanvas();
SkRect r = { 0, 33000, 300, 33300 };
int x = SkScalarRoundToInt(r.left());
int y = SkScalarRoundToInt(r.top());
// check that the pixel in question starts as transparent (by the surface)
if (canvas->readPixels(&output, x, y)) {
REPORTER_ASSERT(reporter, 0 == pixel[0]);
} else {
REPORTER_ASSERT_MESSAGE(reporter, false, "readPixels failed");
}
SkPaint paint;
paint.setAntiAlias(true);
paint.setColor(SK_ColorWHITE);
canvas->drawRect(r, paint);
// Now check that it is BLACK
if (canvas->readPixels(&output, x, y)) {
// don't know what swizzling PMColor did, but white should always
// appear the same.
REPORTER_ASSERT(reporter, 0xFFFFFFFF == pixel[0]);
} else {
REPORTER_ASSERT_MESSAGE(reporter, false, "readPixels failed");
}
surf->unref();
}
static void assert_one_parse_error_cb(SkError error, void* context) {
ErrorContext* errorContext = static_cast<ErrorContext*>(context);
errorContext->fErrors++;
// This test only expects one error, and that is a kParseError. If there are others,
// there is some unknown problem.
REPORTER_ASSERT_MESSAGE(errorContext->fReporter, 1 == errorContext->fErrors,
"This threw more errors than expected.");
REPORTER_ASSERT_MESSAGE(errorContext->fReporter, kParseError_SkError == error,
SkGetLastErrorString());
}
static void SaveMatrixClipStep(SkCanvas* canvas, const TestData& d,
skiatest::Reporter* reporter, CanvasTestStep* testStep) {
int saveCount = canvas->getSaveCount();
canvas->save();
canvas->translate(SkIntToScalar(1), SkIntToScalar(2));
canvas->clipRegion(d.fRegion);
canvas->restore();
REPORTER_ASSERT_MESSAGE(reporter, canvas->getSaveCount() == saveCount,
testStep->assertMessage());
REPORTER_ASSERT_MESSAGE(reporter, canvas->getTotalMatrix().isIdentity(),
testStep->assertMessage());
// REPORTER_ASSERT_MESSAGE(reporter, canvas->getTotalClip() != kTestRegion, testStep->assertMessage());
}
static void PaintSaveLayerStep(SkCanvas* canvas, const TestData& d,
skiatest::Reporter* reporter, CanvasTestStep* testStep) {
int saveCount = canvas->getSaveCount();
canvas->saveLayer(NULL, &d.fPaint);
canvas->restore();
REPORTER_ASSERT_MESSAGE(reporter, canvas->getSaveCount() == saveCount,
testStep->assertMessage());
}
// If the flag library was passed to this run of the test, attempt to open it using dlopen and
// report whether it succeeded.
OpenLibResult(skiatest::Reporter* reporter) {
if (FLAGS_library.count() == 1) {
fHandle = dlopen(FLAGS_library[0], RTLD_LAZY | RTLD_LOCAL);
REPORTER_ASSERT_MESSAGE(reporter, fHandle != nullptr, "Failed to open library!");
} else {
fHandle = nullptr;
}
}
void assert_equal(skiatest::Reporter* reporter, const SamplePattern& pattern,
const GrGpu::MultisampleSpecs& specs, bool flipY) {
GrAlwaysAssert(specs.fSampleLocations);
if ((int)pattern.size() != specs.fEffectiveSampleCnt) {
REPORTER_ASSERT_MESSAGE(reporter, false, "Sample pattern has wrong number of samples.");
return;
}
for (int i = 0; i < specs.fEffectiveSampleCnt; ++i) {
SkPoint expectedLocation = specs.fSampleLocations[i];
if (flipY) {
expectedLocation.fY = 1 - expectedLocation.fY;
}
if (pattern[i] != expectedLocation) {
REPORTER_ASSERT_MESSAGE(reporter, false, "Sample pattern has wrong sample location.");
return;
}
}
}
static void test_write_pixels(skiatest::Reporter* reporter, GrContext* context,
GrTexture* externalTexture) {
int pixelCnt = externalTexture->width() * externalTexture->height();
SkAutoTMalloc<uint32_t> pixels(pixelCnt);
memset(pixels.get(), 0, sizeof(uint32_t)*pixelCnt);
bool write = externalTexture->writePixels(0, 0, 0, 0, kRGBA_8888_GrPixelConfig, pixels.get());
REPORTER_ASSERT_MESSAGE(reporter, !write, "Should not be able to write to a EXTERNAL"
" texture.");
}
static void BoundedSaveLayerStep(SkCanvas* canvas,
skiatest::Reporter* reporter,
CanvasTestStep* testStep) {
int saveCount = canvas->getSaveCount();
canvas->saveLayer(&kTestRect, NULL);
canvas->restore();
REPORTER_ASSERT_MESSAGE(reporter, canvas->getSaveCount() == saveCount,
testStep->assertMessage());
}
DEF_TEST(SkBlend_optsSqrtCheck, reporter) {
for (int c = 0; c < 256; c++) {
Sk4f i{(float)c};
Sk4f ii = i * i;
Sk4f s = ii.sqrt() + 0.5f;
Sk4f sf = s.floor();
REPORTER_ASSERT_MESSAGE(
reporter, i[0] == sf[0], SkStringPrintf("i: %f, s: %f", i[0], sf[0]));
}
}
static void SaveRestoreTestStep(SkCanvas* canvas, const TestData& d,
skiatest::Reporter* reporter, CanvasTestStep* testStep) {
int baseSaveCount = canvas->getSaveCount();
int n = canvas->save();
REPORTER_ASSERT_MESSAGE(reporter, baseSaveCount == n, testStep->assertMessage());
REPORTER_ASSERT_MESSAGE(reporter, baseSaveCount + 1 == canvas->getSaveCount(),
testStep->assertMessage());
canvas->save();
canvas->save();
REPORTER_ASSERT_MESSAGE(reporter, baseSaveCount + 3 == canvas->getSaveCount(),
testStep->assertMessage());
canvas->restoreToCount(baseSaveCount + 1);
REPORTER_ASSERT_MESSAGE(reporter, baseSaveCount + 1 == canvas->getSaveCount(),
testStep->assertMessage());
// should this pin to 1, or be a no-op, or crash?
canvas->restoreToCount(0);
REPORTER_ASSERT_MESSAGE(reporter, 1 == canvas->getSaveCount(),
testStep->assertMessage());
}
static void test_blender(std::string resourceName, skiatest::Reporter* reporter) {
std::string fileName = resourceName + ".png";
sk_sp<SkImage> image = GetResourceAsImage(fileName.c_str());
if (image == nullptr) {
ERRORF(reporter, "image is NULL");
return;
}
SkBitmap bm;
if (!as_IB(image)->getROPixels(&bm)) {
ERRORF(reporter, "Could not read resource");
return;
}
SkPixmap pixmap;
bm.peekPixels(&pixmap);
SkASSERTF(pixmap.colorType() == kN32_SkColorType, "colorType: %d", pixmap.colorType());
SkASSERT(pixmap.alphaType() != kUnpremul_SkAlphaType);
const uint32_t* src = pixmap.addr32();
const int width = pixmap.rowBytesAsPixels();
SkASSERT(width > 0);
SkASSERT(width < 4000);
SkAutoTArray<uint32_t> correctDst(width);
SkAutoTArray<uint32_t> testDst(width);
for (int y = 0; y < pixmap.height(); y++) {
// TODO: zero is not the most interesting dst to test srcover...
sk_bzero(correctDst.get(), width * sizeof(uint32_t));
sk_bzero(testDst.get(), width * sizeof(uint32_t));
brute_force_srcover_srgb_srgb(correctDst.get(), src, width, width);
SkOpts:: srcover_srgb_srgb( testDst.get(), src, width, width);
for (int x = 0; x < width; x++) {
REPORTER_ASSERT_MESSAGE(
reporter, correctDst[x] == testDst[x],
mismatch_message(resourceName, x, y, src[x], correctDst[x], testDst[x]));
if (correctDst[x] != testDst[x]) break;
}
src += width;
}
}
DEF_TEST(SkRecordingAccuracyXfermode, reporter) {
#define FINEGRAIN 0
const Drawer drawer;
BitmapBackedCanvasStrategy golden(drawer.imageInfo());
PictureStrategy picture(drawer.imageInfo());
#if !FINEGRAIN
unsigned numErrors = 0;
SkString errors;
#endif
for (int iMode = 0; iMode < int(SkXfermode::kLastMode); iMode++) {
const SkRect& clip = SkRect::MakeXYWH(100, 0, 100, 100);
SkXfermode::Mode mode = SkXfermode::Mode(iMode);
const SkBitmap& goldenBM = golden.recordAndReplay(drawer, clip, mode);
const SkBitmap& pictureBM = picture.recordAndReplay(drawer, clip, mode);
size_t pixelsSize = goldenBM.getSize();
REPORTER_ASSERT(reporter, pixelsSize == pictureBM.getSize());
// The pixel arrays should match.
#if FINEGRAIN
REPORTER_ASSERT(reporter,
0 == memcmp(goldenBM.getPixels(), pictureBM.getPixels(), pixelsSize));
#else
if (memcmp(goldenBM.getPixels(), pictureBM.getPixels(), pixelsSize)) {
numErrors++;
errors.appendf("For SkXfermode %d %s: SkPictureRecorder bitmap is wrong\n",
iMode, SkXfermode::ModeName(mode));
}
#endif
}
#if !FINEGRAIN
REPORTER_ASSERT_MESSAGE(reporter, 0 == numErrors, errors.c_str());
#endif
}
static void AssertCanvasStatesEqual(skiatest::Reporter* reporter, const TestData& d,
const SkCanvas* canvas1, const SkCanvas* canvas2,
CanvasTestStep* testStep) {
REPORTER_ASSERT_MESSAGE(reporter, canvas1->getDeviceSize() ==
canvas2->getDeviceSize(), testStep->assertMessage());
REPORTER_ASSERT_MESSAGE(reporter, canvas1->getSaveCount() ==
canvas2->getSaveCount(), testStep->assertMessage());
SkRect bounds1, bounds2;
REPORTER_ASSERT_MESSAGE(reporter,
canvas1->getClipBounds(&bounds1) == canvas2->getClipBounds(&bounds2),
testStep->assertMessage());
REPORTER_ASSERT_MESSAGE(reporter, bounds1 == bounds2,
testStep->assertMessage());
REPORTER_ASSERT_MESSAGE(reporter, canvas1->getDrawFilter() ==
canvas2->getDrawFilter(), testStep->assertMessage());
SkIRect deviceBounds1, deviceBounds2;
REPORTER_ASSERT_MESSAGE(reporter,
canvas1->getClipDeviceBounds(&deviceBounds1) ==
canvas2->getClipDeviceBounds(&deviceBounds2),
testStep->assertMessage());
REPORTER_ASSERT_MESSAGE(reporter, deviceBounds1 == deviceBounds2, testStep->assertMessage());
REPORTER_ASSERT_MESSAGE(reporter, canvas1->getTotalMatrix() ==
canvas2->getTotalMatrix(), testStep->assertMessage());
REPORTER_ASSERT_MESSAGE(reporter, equal_clips(*canvas1, *canvas2), testStep->assertMessage());
SkCanvas::LayerIter layerIter1(const_cast<SkCanvas*>(canvas1), false);
SkCanvas::LayerIter layerIter2(const_cast<SkCanvas*>(canvas2), false);
while (!layerIter1.done() && !layerIter2.done()) {
REPORTER_ASSERT_MESSAGE(reporter, layerIter1.matrix() ==
layerIter2.matrix(), testStep->assertMessage());
REPORTER_ASSERT_MESSAGE(reporter, layerIter1.clip() ==
layerIter2.clip(), testStep->assertMessage());
REPORTER_ASSERT_MESSAGE(reporter, layerIter1.paint() ==
layerIter2.paint(), testStep->assertMessage());
REPORTER_ASSERT_MESSAGE(reporter, layerIter1.x() ==
layerIter2.x(), testStep->assertMessage());
REPORTER_ASSERT_MESSAGE(reporter, layerIter1.y() ==
layerIter2.y(), testStep->assertMessage());
layerIter1.next();
layerIter2.next();
}
REPORTER_ASSERT_MESSAGE(reporter, layerIter1.done(),
testStep->assertMessage());
REPORTER_ASSERT_MESSAGE(reporter, layerIter2.done(),
testStep->assertMessage());
}
static void test_systemfonts(skiatest::Reporter* reporter, bool verbose) {
static const SkFontTableTag nameTag = SkSetFourByteTag('n','a','m','e');
sk_sp<SkFontMgr> fm(SkFontMgr::RefDefault());
int count = SkMin32(fm->countFamilies(), MAX_FAMILIES);
for (int i = 0; i < count; ++i) {
sk_sp<SkFontStyleSet> set(fm->createStyleSet(i));
for (int j = 0; j < set->count(); ++j) {
SkString sname;
SkFontStyle fs;
set->getStyle(j, &fs, &sname);
sk_sp<SkTypeface> typeface(set->createTypeface(j));
SkString familyName;
typeface->getFamilyName(&familyName);
if (verbose) {
SkDebugf("[%s]\n", familyName.c_str());
}
sk_sp<SkTypeface::LocalizedStrings> familyNamesIter(
typeface->createFamilyNameIterator());
SkTypeface::LocalizedString familyNameLocalized;
while (familyNamesIter->next(&familyNameLocalized)) {
if (verbose) {
SkDebugf("(%s) <%s>\n", familyNameLocalized.fString.c_str(),
familyNameLocalized.fLanguage.c_str());
}
}
size_t nameTableSize = typeface->getTableSize(nameTag);
if (0 == nameTableSize) {
continue;
}
SkAutoTMalloc<uint8_t> nameTableData(nameTableSize);
size_t copied = typeface->getTableData(nameTag, 0, nameTableSize, nameTableData.get());
if (copied != nameTableSize) {
continue;
}
SkOTTableName::Iterator::Record record;
SkOTTableName::Iterator familyNameIter(*((SkOTTableName*)nameTableData.get()),
SkOTTableName::Record::NameID::Predefined::FontFamilyName);
while (familyNameIter.next(record)) {
REPORTER_ASSERT_MESSAGE(reporter,
SkOTTableName::Record::NameID::Predefined::FontFamilyName == record.type,
"Requested family name, got something else."
);
if (verbose) {
SkDebugf("{%s} <%s>\n", record.name.c_str(), record.language.c_str());
}
}
SkOTTableName::Iterator styleNameIter(*((SkOTTableName*)nameTableData.get()),
SkOTTableName::Record::NameID::Predefined::FontSubfamilyName);
while (styleNameIter.next(record)) {
REPORTER_ASSERT_MESSAGE(reporter,
SkOTTableName::Record::NameID::Predefined::FontSubfamilyName == record.type,
"Requested subfamily name, got something else."
);
if (verbose) {
SkDebugf("{{%s}} <%s>\n", record.name.c_str(), record.language.c_str());
}
}
if (verbose) {
SkDebugf("\n");
}
}
}
}
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ReadWriteAlpha, reporter, ctxInfo) {
GrContext* context = ctxInfo.grContext();
unsigned char alphaData[X_SIZE * Y_SIZE];
static const int kClearValue = 0x2;
bool match;
static const size_t kRowBytes[] = {0, X_SIZE, X_SIZE + 1, 2 * X_SIZE - 1};
{
GrSurfaceDesc desc;
desc.fFlags = kNone_GrSurfaceFlags;
desc.fConfig = kAlpha_8_GrPixelConfig; // it is a single channel texture
desc.fWidth = X_SIZE;
desc.fHeight = Y_SIZE;
// We are initializing the texture with zeros here
memset(alphaData, 0, X_SIZE * Y_SIZE);
sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(context->resourceProvider(),
desc,
SkBudgeted::kNo,
alphaData, 0));
if (!proxy) {
ERRORF(reporter, "Could not create alpha texture.");
return;
}
sk_sp<GrSurfaceContext> sContext(context->contextPriv().makeWrappedSurfaceContext(
std::move(proxy), nullptr));
const SkImageInfo ii = SkImageInfo::MakeA8(X_SIZE, Y_SIZE);
sk_sp<SkSurface> surf(SkSurface::MakeRenderTarget(context, SkBudgeted::kNo, ii));
// create a distinctive texture
for (int y = 0; y < Y_SIZE; ++y) {
for (int x = 0; x < X_SIZE; ++x) {
alphaData[y * X_SIZE + x] = y*X_SIZE+x;
}
}
for (auto rowBytes : kRowBytes) {
// upload the texture (do per-rowbytes iteration because we may overwrite below).
bool result = sContext->writePixels(ii, alphaData, 0, 0, 0);
REPORTER_ASSERT_MESSAGE(reporter, result, "Initial A8 writePixels failed");
size_t nonZeroRowBytes = rowBytes ? rowBytes : X_SIZE;
std::unique_ptr<uint8_t[]> readback(new uint8_t[nonZeroRowBytes * Y_SIZE]);
// clear readback to something non-zero so we can detect readback failures
memset(readback.get(), kClearValue, nonZeroRowBytes * Y_SIZE);
// read the texture back
result = sContext->readPixels(ii, readback.get(), rowBytes, 0, 0);
REPORTER_ASSERT_MESSAGE(reporter, result, "Initial A8 readPixels failed");
// make sure the original & read back versions match
SkString msg;
msg.printf("rb:%d A8", SkToU32(rowBytes));
validate_alpha_data(reporter, X_SIZE, Y_SIZE, readback.get(), nonZeroRowBytes,
alphaData, msg);
// Now try writing to a single channel surface (if we could create one).
if (surf) {
SkCanvas* canvas = surf->getCanvas();
SkPaint paint;
const SkRect rect = SkRect::MakeLTRB(-10, -10, X_SIZE + 10, Y_SIZE + 10);
paint.setColor(SK_ColorWHITE);
canvas->drawRect(rect, paint);
memset(readback.get(), kClearValue, nonZeroRowBytes * Y_SIZE);
result = surf->readPixels(ii, readback.get(), nonZeroRowBytes, 0, 0);
REPORTER_ASSERT_MESSAGE(reporter, result, "A8 readPixels after clear failed");
match = true;
for (int y = 0; y < Y_SIZE && match; ++y) {
for (int x = 0; x < X_SIZE && match; ++x) {
uint8_t rbValue = readback.get()[y * nonZeroRowBytes + x];
if (0xFF != rbValue) {
ERRORF(reporter,
"Failed alpha readback after clear. Expected: 0xFF, Got: 0x%02x"
" at (%d,%d), rb:%d", rbValue, x, y, SkToU32(rowBytes));
match = false;
}
}
}
}
}
}
static const GrPixelConfig kRGBAConfigs[] {
kRGBA_8888_GrPixelConfig,
kBGRA_8888_GrPixelConfig,
kSRGBA_8888_GrPixelConfig
};
for (int y = 0; y < Y_SIZE; ++y) {
for (int x = 0; x < X_SIZE; ++x) {
alphaData[y * X_SIZE + x] = y*X_SIZE+x;
}
}
const SkImageInfo dstInfo = SkImageInfo::Make(X_SIZE, Y_SIZE,
kAlpha_8_SkColorType,
kPremul_SkAlphaType);
// Attempt to read back just alpha from a RGBA/BGRA texture. Once with a texture-only src and
// once with a render target.
for (auto config : kRGBAConfigs) {
for (int rt = 0; rt < 2; ++rt) {
GrSurfaceDesc desc;
desc.fFlags = rt ? kRenderTarget_GrSurfaceFlag : kNone_GrSurfaceFlags;
desc.fConfig = config;
desc.fWidth = X_SIZE;
desc.fHeight = Y_SIZE;
uint32_t rgbaData[X_SIZE * Y_SIZE];
// Make the alpha channel of the rgba texture come from alphaData.
for (int y = 0; y < Y_SIZE; ++y) {
for (int x = 0; x < X_SIZE; ++x) {
rgbaData[y * X_SIZE + x] = GrColorPackRGBA(6, 7, 8, alphaData[y * X_SIZE + x]);
}
}
sk_sp<GrTextureProxy> proxy =
GrSurfaceProxy::MakeDeferred(context->resourceProvider(), desc, SkBudgeted::kNo,
rgbaData, 0);
if (!proxy) {
// We always expect to be able to create a RGBA texture
if (!rt && kRGBA_8888_GrPixelConfig == desc.fConfig) {
ERRORF(reporter, "Failed to create RGBA texture.");
}
continue;
}
sk_sp<GrSurfaceContext> sContext = context->contextPriv().makeWrappedSurfaceContext(
std::move(proxy), nullptr);
for (auto rowBytes : kRowBytes) {
size_t nonZeroRowBytes = rowBytes ? rowBytes : X_SIZE;
std::unique_ptr<uint8_t[]> readback(new uint8_t[nonZeroRowBytes * Y_SIZE]);
// Clear so we don't accidentally see values from previous iteration.
memset(readback.get(), kClearValue, nonZeroRowBytes * Y_SIZE);
// read the texture back
bool result = sContext->readPixels(dstInfo, readback.get(), rowBytes, 0, 0);
REPORTER_ASSERT_MESSAGE(reporter, result, "8888 readPixels failed");
// make sure the original & read back versions match
SkString msg;
msg.printf("rt:%d, rb:%d 8888", rt, SkToU32(rowBytes));
validate_alpha_data(reporter, X_SIZE, Y_SIZE, readback.get(), nonZeroRowBytes,
alphaData, msg);
}
}
}
}
