HTDrawable(SkRandom& rand) { fR = SkRect::MakeXYWH(rand.nextRangeF(0, 640), rand.nextRangeF(0, 480), rand.nextRangeF(20, 200), rand.nextRangeF(20, 200)); fColor = rand_opaque_color(rand.nextU()); fInterp = nullptr; fTime = 0; }
DEF_TEST(PathOpsAngleFindCrossEpsilon, reporter) { if (gDisableAngleTests) { return; } SkRandom ran; int maxEpsilon = 0; for (int index = 0; index < 10000000; ++index) { SkDLine line = {{{0, 0}, {ran.nextRangeF(0.0001f, 1000), ran.nextRangeF(0.0001f, 1000)}}}; for (int inner = 0; inner < 10; ++inner) { float t = ran.nextRangeF(0.0001f, 1); SkDPoint dPt = line.ptAtT(t); SkPoint pt = dPt.asSkPoint(); float xs[3] = { prev(pt.fX), pt.fX, next(pt.fX) }; float ys[3] = { prev(pt.fY), pt.fY, next(pt.fY) }; for (int xIdx = 0; xIdx < 3; ++xIdx) { for (int yIdx = 0; yIdx < 3; ++yIdx) { SkPoint test = { xs[xIdx], ys[yIdx] }; float p1 = SkDoubleToScalar(line[1].fX * test.fY); float p2 = SkDoubleToScalar(line[1].fY * test.fX); int p1Bits = SkFloatAs2sCompliment(p1); int p2Bits = SkFloatAs2sCompliment(p2); int epsilon = SkTAbs(p1Bits - p2Bits); if (maxEpsilon < epsilon) { SkDebugf("line={{0, 0}, {%1.7g, %1.7g}} t=%1.7g pt={%1.7g, %1.7g}" " epsilon=%d\n", line[1].fX, line[1].fY, t, test.fX, test.fY, epsilon); maxEpsilon = epsilon; } } } } } }
virtual void onDraw(SkCanvas* canvas) { SkPaint paint; this->setupPaint(&paint); paint.setAntiAlias(true); SkRandom rand; for (int i = 0; i < SkBENCHLOOP(3); i++) { SkRect r = SkRect::MakeWH(rand.nextUScalar1() * 400, rand.nextUScalar1() * 400); r.offset(fRadius, fRadius); if (fRadius > 0) { SkMorphologyImageFilter* mf = NULL; switch (fStyle) { case kDilate_MT: mf = new SkDilateImageFilter(SkScalarFloorToInt(fRadius), SkScalarFloorToInt(fRadius)); break; case kErode_MT: mf = new SkErodeImageFilter(SkScalarFloorToInt(fRadius), SkScalarFloorToInt(fRadius)); break; } paint.setImageFilter(mf)->unref(); } canvas->drawOval(r, paint); } }
static SkIRect rand_rect(SkRandom& rand, int n) { int x = rand.nextS() % n; int y = rand.nextS() % n; int w = rand.nextU() % n; int h = rand.nextU() % n; return SkIRect::MakeXYWH(x, y, w, h); }
DEF_TEST(SkFloatToHalf_finite_ftz, r) { #if 0 for (uint64_t bits = 0; bits <= 0xffffffff; bits++) { #else SkRandom rand; for (int i = 0; i < 1000000; i++) { uint32_t bits = rand.nextU(); #endif float f; memcpy(&f, &bits, 4); uint16_t expected = SkFloatToHalf(f); if (!is_finite(expected)) { // _finite_ftz() only works for values that can be represented as a finite half float. continue; } uint16_t alternate = expected; if (is_denorm(expected)) { // _finite_ftz() may flush denorms to zero, and happens to keep the sign bit. alternate = signbit(f) ? 0x8000 : 0x0000; } uint16_t actual = SkFloatToHalf_finite_ftz(Sk4f{f})[0]; // _finite_ftz() may truncate instead of rounding, so it may be one too small. REPORTER_ASSERT(r, actual == expected || actual == expected - 1 || actual == alternate || actual == alternate - 1); } }
ComputeChecksumBench(void* param, ChecksumType type) : INHERITED(param), fType(type) { SkRandom rand; for (int i = 0; i < U32COUNT; ++i) { fData[i] = rand.nextU(); } fIsRendering = false; }
// 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; } } }
DEF_TEST(Sort, reporter) { /** An array of random numbers to be sorted. */ int randomArray[500]; /** The reference sort of the random numbers. */ int sortedArray[SK_ARRAY_COUNT(randomArray)]; /** The random numbers are copied into this array, sorted by an SkSort, then this array is compared against the reference sort. */ int workingArray[SK_ARRAY_COUNT(randomArray)]; SkRandom rand; for (int i = 0; i < 10000; i++) { int count = rand.nextRangeU(1, SK_ARRAY_COUNT(randomArray)); rand_array(rand, randomArray, count); // Use qsort as the reference sort. memcpy(sortedArray, randomArray, sizeof(randomArray)); qsort(sortedArray, count, sizeof(sortedArray[0]), compare_int); memcpy(workingArray, randomArray, sizeof(randomArray)); SkTHeapSort<int>(workingArray, count); check_sort(reporter, "Heap", workingArray, sortedArray, count); memcpy(workingArray, randomArray, sizeof(randomArray)); SkTQSort<int>(workingArray, workingArray + count - 1); check_sort(reporter, "Quick", workingArray, sortedArray, count); } }
void onDraw(int loops, SkCanvas* canvas) override { SkPaint paint; this->setupPaint(&paint); paint.setAntiAlias(true); SkRandom rand; for (int i = 0; i < loops; i++) { SkRect r = SkRect::MakeWH(rand.nextUScalar1() * 400, rand.nextUScalar1() * 400); r.offset(fRadius, fRadius); if (fRadius > 0) { sk_sp<SkImageFilter> mf; switch (fStyle) { case kDilate_MT: mf = SkDilateImageFilter::Make(SkScalarFloorToInt(fRadius), SkScalarFloorToInt(fRadius), nullptr); break; case kErode_MT: mf = SkErodeImageFilter::Make(SkScalarFloorToInt(fRadius), SkScalarFloorToInt(fRadius), nullptr); break; } paint.setImageFilter(std::move(mf)); } canvas->drawOval(r, paint); } }
static void test_buffer(skiatest::Reporter* reporter) { SkRandom rand; SkAutoMalloc am(MAX_SIZE * 2); char* storage = (char*)am.get(); char* storage2 = storage + MAX_SIZE; random_fill(rand, storage, MAX_SIZE); for (int sizeTimes = 0; sizeTimes < 100; sizeTimes++) { int size = rand.nextU() % MAX_SIZE; if (size == 0) { size = MAX_SIZE; } for (int times = 0; times < 100; times++) { int bufferSize = 1 + (rand.nextU() & 0xFFFF); SkMemoryStream mstream(storage, size); SkBufferStream bstream(&mstream, bufferSize); int bytesRead = 0; while (bytesRead < size) { int s = 17 + (rand.nextU() & 0xFFFF); int ss = bstream.read(storage2, s); REPORTER_ASSERT(reporter, ss > 0 && ss <= s); REPORTER_ASSERT(reporter, bytesRead + ss <= size); REPORTER_ASSERT(reporter, memcmp(storage + bytesRead, storage2, ss) == 0); bytesRead += ss; } REPORTER_ASSERT(reporter, bytesRead == size); } } }
static sk_sp<SkImage> make_atlas(int atlasSize, int cellSize) { SkImageInfo info = SkImageInfo::MakeN32Premul(atlasSize, atlasSize); auto surface(SkSurface::MakeRaster(info)); SkCanvas* canvas = surface->getCanvas(); SkPaint paint; SkRandom rand; const SkScalar half = cellSize * SK_ScalarHalf; const char* s = "01234567890!@#$%^&*=+<>?abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; SkFont font(nullptr, 28); int i = 0; for (int y = 0; y < atlasSize; y += cellSize) { for (int x = 0; x < atlasSize; x += cellSize) { paint.setColor(rand.nextU()); paint.setAlpha(0xFF); int index = i % strlen(s); SkTextUtils::Draw(canvas, &s[index], 1, SkTextEncoding::kUTF8, x + half, y + half + half/2, font, paint, SkTextUtils::kCenter_Align); i += 1; } } return surface->makeImageSnapshot(); }
static void test_peephole(skiatest::Reporter* reporter) { SkRandom rand; for (int j = 0; j < 100; j++) { SkRandom rand2(rand.getSeed()); // remember the seed SkPicture picture; SkCanvas* canvas = picture.beginRecording(100, 100); for (int i = 0; i < 1000; ++i) { rand_op(canvas, rand); } picture.endRecording(); } { SkPicture picture; SkCanvas* canvas = picture.beginRecording(100, 100); SkRect rect = SkRect::MakeWH(50, 50); for (int i = 0; i < 100; ++i) { canvas->save(); } while (canvas->getSaveCount() > 1) { canvas->clipRect(rect); canvas->restore(); } picture.endRecording(); } }
VertBench() { const SkScalar dx = SkIntToScalar(W) / COL; const SkScalar dy = SkIntToScalar(H) / COL; SkPoint* pts = fPts; uint16_t* idx = fIdx; SkScalar yy = 0; for (int y = 0; y <= ROW; y++) { SkScalar xx = 0; for (int x = 0; x <= COL; ++x) { pts->set(xx, yy); pts += 1; xx += dx; if (x < COL && y < ROW) { load_2_tris(idx, x, y, COL + 1); for (int i = 0; i < 6; i++) { SkASSERT(idx[i] < PTS); } idx += 6; } } yy += dy; } SkASSERT(PTS == pts - fPts); SkASSERT(IDX == idx - fIdx); SkRandom rand; for (int i = 0; i < PTS; ++i) { fColors[i] = rand.nextU() | (0xFF << 24); } fName.set("verts"); }
static void call_draw(SkCanvas* canvas) { SkPaint paint; uint16_t text[32]; SkRandom rand; paint.setAntiAlias(true); paint.setTextEncoding(SkPaint::kUTF16_TextEncoding); for (int j = 0; j < SK_ARRAY_COUNT(text); j++) text[j] = (uint16_t)((rand.nextU() & 0xFF) + 32); SkScalar x = SkIntToScalar(10); SkScalar y = SkIntToScalar(20); canvas->drawColor(SK_ColorWHITE); for (int i = 9; i < 36; i++) { SkPaint::FontMetrics m; paint.setTextSize(SkIntToScalar(i)); paint.getFontMetrics(&m); canvas->drawText(text, sizeof(text), x, y, paint); y += m.fDescent - m.fAscent; } }
void onDraw(const int loops, SkCanvas*) override { SkRandom r; enum { kMaxObjects = 4 * (1 << 10), }; A* objects[kMaxObjects]; // We delete if a random [-1, 1] fixed pt is < the thresh. Otherwise, // we allocate. We start allocate-biased and ping-pong to delete-biased SkFixed delThresh = -SK_FixedHalf; const int kSwitchThreshPeriod = loops / (2 * kMaxObjects); int s = 0; int count = 0; for (int i = 0; i < loops; i++, ++s) { if (kSwitchThreshPeriod == s) { delThresh = -delThresh; s = 0; } SkFixed del = r.nextSFixed1(); if (count && (kMaxObjects == count || del < delThresh)) { delete objects[count-1]; --count; } else { objects[count] = new A; ++count; } } for (int i = 0; i < count; ++i) { delete objects[i]; } }
const GrFragmentProcessor* SkModeColorFilter::asFragmentProcessor(GrContext*) const { if (SkXfermode::kDst_Mode == fMode) { return nullptr; } SkAutoTUnref<const GrFragmentProcessor> constFP( GrConstColorProcessor::Create(SkColorToPremulGrColor(fColor), GrConstColorProcessor::kIgnore_InputMode)); const GrFragmentProcessor* fp = GrXfermodeFragmentProcessor::CreateFromSrcProcessor(constFP, fMode); if (!fp) { return nullptr; } #ifdef SK_DEBUG // With a solid color input this should always be able to compute the blended color // (at least for coeff modes) if (fMode <= SkXfermode::kLastCoeffMode) { static SkRandom gRand; GrInvariantOutput io(GrPremulColor(gRand.nextU()), kRGBA_GrColorComponentFlags, false); fp->computeInvariantOutput(&io); SkASSERT(io.validFlags() == kRGBA_GrColorComponentFlags); } #endif return fp; }
void onDraw(SkCanvas* canvas) override { SkPath path; SkRandom rand; int scale = 300; for (int i = 0; i < 4; ++i) { // get the random values deterministically SkScalar randoms[12]; for (int index = 0; index < (int) SK_ARRAY_COUNT(randoms); ++index) { randoms[index] = rand.nextUScalar1(); } path.lineTo(randoms[0] * scale, randoms[1] * scale); path.quadTo(randoms[2] * scale, randoms[3] * scale, randoms[4] * scale, randoms[5] * scale); path.cubicTo(randoms[6] * scale, randoms[7] * scale, randoms[8] * scale, randoms[9] * scale, randoms[10] * scale, randoms[11] * scale); } path.setFillType(SkPath::kEvenOdd_FillType); path.offset(SkIntToScalar(20), SkIntToScalar(20)); test_hittest(canvas, path); canvas->translate(SkIntToScalar(scale), 0); path.setFillType(SkPath::kWinding_FillType); test_hittest(canvas, path); }
virtual void onDraw(int loops, SkCanvas* canvas) { const SkIPoint dim = this->getSize(); SkRandom rand; SkPaint paint(fPaint); this->setupPaint(&paint); // explicitly need these paint.setAlpha(fPaint.getAlpha()); paint.setAntiAlias(kBW != fFQ); paint.setLCDRenderText(kLCD == fFQ); const SkScalar x0 = SkIntToScalar(-10); const SkScalar y0 = SkIntToScalar(-10); paint.setTextSize(SkIntToScalar(12)); for (int i = 0; i < loops; i++) { SkScalar x = x0 + rand.nextUScalar1() * dim.fX; SkScalar y = y0 + rand.nextUScalar1() * dim.fY; canvas->drawString(fText, x, y, paint); } paint.setTextSize(SkIntToScalar(48)); for (int i = 0; i < loops / 4 ; i++) { SkScalar x = x0 + rand.nextUScalar1() * dim.fX; SkScalar y = y0 + rand.nextUScalar1() * dim.fY; canvas->drawString(fText, x, y, paint); } }
virtual void onDraw(SkCanvas* canvas) { this->makePaths(); SkPaint paint; paint.setAntiAlias(true); SkRandom rand; canvas->translate(20 * SK_Scalar1, 20 * SK_Scalar1); // As we've added more paths this has gotten pretty big. Scale the whole thing down. canvas->scale(2 * SK_Scalar1 / 3, 2 * SK_Scalar1 / 3); for (int i = 0; i < fPaths.count(); ++i) { canvas->save(); // position the path, and make it at off-integer coords. canvas->translate(SK_Scalar1 * 200 * (i % 5) + SK_Scalar1 / 10, SK_Scalar1 * 200 * (i / 5) + 9 * SK_Scalar1 / 10); SkColor color = rand.nextU(); color |= 0xff000000; paint.setColor(color); #if 0 // This hitting on 32bit Linux builds for some paths. Temporarily disabling while it is // debugged. SkASSERT(fPaths[i].isConvex()); #endif canvas->drawPath(fPaths[i], paint); canvas->restore(); } }
virtual void onDrawContent(SkCanvas* canvas) { SkScalar blurRadius = SampleCode::GetAnimSinScalar(100 * SK_Scalar1, 4 * SK_Scalar1, 5 * SK_Scalar1); SkScalar circleRadius = 3 * SK_Scalar1 + SampleCode::GetAnimSinScalar(150 * SK_Scalar1, 25 * SK_Scalar1, 3 * SK_Scalar1); static const SkBlurMaskFilter::BlurStyle gStyles[] = { SkBlurMaskFilter::kNormal_BlurStyle, SkBlurMaskFilter::kInner_BlurStyle, SkBlurMaskFilter::kSolid_BlurStyle, SkBlurMaskFilter::kOuter_BlurStyle, }; SkRandom random; for (size_t i = 0; i < SK_ARRAY_COUNT(gStyles); ++i) { SkMaskFilter* mf = SkBlurMaskFilter::Create(blurRadius, gStyles[i], SkBlurMaskFilter::kHighQuality_BlurFlag); SkPaint paint; SkSafeUnref(paint.setMaskFilter(mf)); paint.setColor(random.nextU() | 0xff000000); canvas->drawCircle(200 * SK_Scalar1 + 400 * (i % 2) * SK_Scalar1, 200 * SK_Scalar1 + i / 2 * 400 * SK_Scalar1, circleRadius, paint); } this->inval(NULL); }
static void rand_irect(SkIRect* r, int N, SkRandom& rand) { r->setXYWH(0, 0, rand.nextU() % N, rand.nextU() % N); int dx = rand.nextU() % (2*N); int dy = rand.nextU() % (2*N); // use int dx,dy to make the subtract be signed r->offset(N - dx, N - dy); }
PathEffectView() { SkRandom rand; int steps = 20; SkScalar dist = SkIntToScalar(400); SkScalar x = SkIntToScalar(20); SkScalar y = SkIntToScalar(50); fPath.moveTo(x, y); for (int i = 0; i < steps; i++) { x += dist/steps; SkScalar tmpY = y + SkIntToScalar(rand.nextS() % 25); if (i == steps/2) { fPath.moveTo(x, tmpY); } else { fPath.lineTo(x, tmpY); } } { SkRect oval; oval.set(SkIntToScalar(20), SkIntToScalar(30), SkIntToScalar(100), SkIntToScalar(60)); oval.offset(x, 0); fPath.addRoundRect(oval, SkIntToScalar(8), SkIntToScalar(8)); } fClickPt.set(SkIntToScalar(200), SkIntToScalar(200)); }
void test_sampleLocations(skiatest::Reporter* reporter, TestSampleLocationsInterface* testInterface, GrContext* ctx) { SkRandom rand; SkAutoTUnref<GrRenderTarget> bottomUps[numTestPatterns]; SkAutoTUnref<GrRenderTarget> topDowns[numTestPatterns]; for (int i = 0; i < numTestPatterns; ++i) { int numSamples = (int)kTestPatterns[i].size(); GrAlwaysAssert(numSamples > 1 && SkIsPow2(numSamples)); bottomUps[i].reset(create_render_target(ctx, kBottomLeft_GrSurfaceOrigin, rand.nextRangeU(1 + numSamples / 2, numSamples))); topDowns[i].reset(create_render_target(ctx, kTopLeft_GrSurfaceOrigin, rand.nextRangeU(1 + numSamples / 2, numSamples))); } // Ensure all sample locations get queried and/or cached properly. GrStencilSettings dummyStencil; for (int repeat = 0; repeat < 2; ++repeat) { for (int i = 0; i < numTestPatterns; ++i) { testInterface->overrideSamplePattern(kTestPatterns[i]); assert_equal(reporter, kTestPatterns[i], topDowns[i]->renderTargetPriv().getMultisampleSpecs(dummyStencil), false); assert_equal(reporter, kTestPatterns[i], bottomUps[i]->renderTargetPriv().getMultisampleSpecs(dummyStencil), true); } } }
void onDraw(SkCanvas* canvas) override { canvas->translate(20, 20); SkRect r = SkRect::MakeWH(1000, 1000); SkPaint paint; paint.setAntiAlias(true); paint.setStyle(SkPaint::kStroke_Style); paint.setStrokeWidth(15); const SkScalar inset = paint.getStrokeWidth() + 4; const SkScalar sweepAngle = 345; SkRandom rand; SkScalar sign = 1; while (r.width() > paint.getStrokeWidth() * 3) { paint.setColor(sk_tool_utils::color_to_565(rand.nextU() | (0xFF << 24))); SkScalar startAngle = rand.nextUScalar1() * 360; SkScalar speed = SkScalarSqrt(16 / r.width()) * 0.5f; startAngle += fRotate * 360 * speed * sign; SkPath path; path.addArc(r, startAngle, sweepAngle); canvas->drawPath(path, paint); r.inset(inset, inset); sign = -sign; } }
SkIRect randrect(SkRandom& rand) { int x = rand.nextU() % W; int y = rand.nextU() % H; int w = rand.nextU() % W; int h = rand.nextU() % H; return SkIRect::MakeXYWH(x, y, w >> 1, h >> 1); }
virtual void onDraw(SkCanvas* canvas) { const SkIPoint dim = this->getSize(); SkRandom rand; SkPaint paint(fPaint); this->setupPaint(&paint); // explicitly need these paint.setColor(fPaint.getColor()); paint.setAntiAlias(kBW != fFQ); paint.setLCDRenderText(kLCD == fFQ); const SkScalar x0 = SkIntToScalar(-10); const SkScalar y0 = SkIntToScalar(-10); if (fDoPos) { // realistically, the matrix is often at least translated, so we // do that since it exercises different code in drawPosText. canvas->translate(SK_Scalar1, SK_Scalar1); } for (int i = 0; i < N; i++) { if (fDoPos) { canvas->drawPosText(fText.c_str(), fText.size(), fPos, paint); } else { SkScalar x = x0 + rand.nextUScalar1() * dim.fX; SkScalar y = y0 + rand.nextUScalar1() * dim.fY; canvas->drawText(fText.c_str(), fText.size(), x, y, paint); } } }
DEF_TEST(Color4f_colorfilter, reporter) { struct { SkColorFilter* (*fFact)(); bool fSupports4f; const char* fName; } recs[] = { { make_mode_cf, true, "mode" }, { make_mx_cf, true, "matrix" }, { make_compose_cf, true, "compose" }, }; // prepare the src const int N = 100; SkPMColor src4b[N]; SkPM4f src4f[N]; SkRandom rand; for (int i = 0; i < N; ++i) { src4b[i] = SkPreMultiplyColor(rand.nextU()); src4f[i] = SkPM4f::FromPMColor(src4b[i]); } // confirm that our srcs are (nearly) equal REPORTER_ASSERT(reporter, compare_spans(src4f, src4b, N)); for (const auto& rec : recs) { SkAutoTUnref<SkColorFilter> filter(rec.fFact()); SkPMColor dst4b[N]; filter->filterSpan(src4b, N, dst4b); SkPM4f dst4f[N]; filter->filterSpan4f(src4f, N, dst4f); REPORTER_ASSERT(reporter, compare_spans(dst4f, dst4b, N)); } }
virtual void onDrawContent(SkCanvas* canvas) { const char* str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; SkPaint paint; SkScalar x = SkIntToScalar(10); SkScalar y = SkIntToScalar(20); paint.setFlags(0x105); paint.setARGB(fByte, 0xFF, 0xFF, 0xFF); paint.setMaskFilter(SkBlurMaskFilter::Create(SkIntToScalar(3), SkBlurMaskFilter::kNormal_BlurStyle)); paint.getMaskFilter()->unref(); SkRandom rand; for (int ps = 6; ps <= 35; ps++) { paint.setColor(rand.nextU() | (0xFF << 24)); paint.setTextSize(SkIntToScalar(ps)); paint.setTextSize(SkIntToScalar(24)); canvas->drawText(str, strlen(str), x, y, paint); y += paint.getFontMetrics(NULL); } if (false) { // avoid bit rot, suppress warning check_for_nonwhite(canvas->getDevice()->accessBitmap(false), fByte); SkDebugf("------ byte %x\n", fByte); } if (false) { fByte += 1; fByte &= 0xFF; this->inval(NULL); } }
void onDraw(SkCanvas* canvas) override { const int sigmaCount = SK_ARRAY_COUNT(kBlurSigmas); const int testStringCount = SK_ARRAY_COUNT(kTestStrings); SkScalar dx = WIDTH / sigmaCount; SkScalar dy = HEIGHT / sigmaCount; const SkScalar textSize = 12; for (int x = 0; x < sigmaCount; x++) { SkScalar sigmaX = kBlurSigmas[x]; for (int y = 0; y < sigmaCount; y++) { SkScalar sigmaY = kBlurSigmas[y]; SkPaint paint; paint.setImageFilter(SkBlurImageFilter::Create(sigmaX, sigmaY))->unref(); canvas->saveLayer(nullptr, &paint); SkRandom rand; SkPaint textPaint; textPaint.setAntiAlias(false); textPaint.setColor(sk_tool_utils::color_to_565(rand.nextBits(24) | 0xFF000000)); sk_tool_utils::set_portable_typeface(&textPaint); textPaint.setTextSize(textSize); for (int i = 0; i < testStringCount; i++) { canvas->drawText(kTestStrings[i], strlen(kTestStrings[i]), SkIntToScalar(x * dx), SkIntToScalar(y * dy + textSize * i + textSize), textPaint); } canvas->restore(); } } }
DEF_TEST(Checksum, r) { // Algorithms to test. They're currently all uint32_t(const uint32_t*, size_t). typedef uint32_t(*algorithmProc)(const uint32_t*, size_t); const algorithmProc kAlgorithms[] = { &SkChecksum::Compute, &murmur_noseed }; // Put 128 random bytes into two identical buffers. Any multiple of 4 will do. const size_t kBytes = SkAlign4(128); SkRandom rand; uint32_t data[kBytes/4], tweaked[kBytes/4]; for (size_t i = 0; i < SK_ARRAY_COUNT(tweaked); ++i) { data[i] = tweaked[i] = rand.nextU(); } // Test each algorithm. for (size_t i = 0; i < SK_ARRAY_COUNT(kAlgorithms); ++i) { const algorithmProc algorithm = kAlgorithms[i]; // Hash of nullptr is always 0. ASSERT(algorithm(nullptr, 0) == 0); const uint32_t hash = algorithm(data, kBytes); // Should be deterministic. ASSERT(hash == algorithm(data, kBytes)); // Changing any single element should change the hash. for (size_t j = 0; j < SK_ARRAY_COUNT(tweaked); ++j) { const uint32_t saved = tweaked[j]; tweaked[j] = rand.nextU(); const uint32_t tweakedHash = algorithm(tweaked, kBytes); ASSERT(tweakedHash != hash); ASSERT(tweakedHash == algorithm(tweaked, kBytes)); tweaked[j] = saved; } } }