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); }
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 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); }
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; } } }
static void show_stroke(SkCanvas* canvas, bool doAA, SkScalar strokeWidth, int n) { SkRandom rand; SkPaint paint; paint.setAntiAlias(doAA); paint.setStyle(SkPaint::kStroke_Style); paint.setStrokeWidth(strokeWidth); for (int i = 0; i < n; ++i) { SkRect r; SkPath p; r.setXYWH(rand.nextSScalar1() * W, rand.nextSScalar1() * H, rand.nextUScalar1() * W, rand.nextUScalar1() * H); paint.setColor(rand.nextU()); canvas->drawRect(r, paint); r.setXYWH(rand.nextSScalar1() * W, rand.nextSScalar1() * H, rand.nextUScalar1() * W, rand.nextUScalar1() * H); paint.setColor(rand.nextU()); p.addOval(r); canvas->drawPath(p, paint); const SkScalar minx = -SkIntToScalar(W)/4; const SkScalar maxx = 5*SkIntToScalar(W)/4; const SkScalar miny = -SkIntToScalar(H)/4; const SkScalar maxy = 5*SkIntToScalar(H)/4; paint.setColor(rand.nextU()); canvas->drawLine(randRange(rand, minx, maxx), randRange(rand, miny, maxy), randRange(rand, minx, maxx), randRange(rand, miny, maxy), paint); } }
DEF_TEST(Paint_cmap, reporter) { // need to implement charsToGlyphs on other backends (e.g. linux, win) // before we can run this tests everywhere return; static const int NGLYPHS = 64; SkUnichar src[NGLYPHS]; SkUnichar dst[NGLYPHS]; // used for utf8, utf16, utf32 storage static const struct { size_t (*fSeedTextProc)(const SkUnichar[], void* dst, int count); SkPaint::TextEncoding fEncoding; } gRec[] = { { uni_to_utf8, SkPaint::kUTF8_TextEncoding }, { uni_to_utf16, SkPaint::kUTF16_TextEncoding }, { uni_to_utf32, SkPaint::kUTF32_TextEncoding }, }; SkRandom rand; SkPaint paint; paint.setTypeface(SkTypeface::RefDefault())->unref(); SkTypeface* face = paint.getTypeface(); for (int i = 0; i < 1000; ++i) { // generate some random text for (int j = 0; j < NGLYPHS; ++j) { src[j] = ' ' + j; } // inject some random chars, to sometimes abort early src[rand.nextU() & 63] = rand.nextU() & 0xFFF; for (size_t k = 0; k < SK_ARRAY_COUNT(gRec); ++k) { paint.setTextEncoding(gRec[k].fEncoding); size_t len = gRec[k].fSeedTextProc(src, dst, NGLYPHS); uint16_t glyphs0[NGLYPHS], glyphs1[NGLYPHS]; bool contains = paint.containsText(dst, len); int nglyphs = paint.textToGlyphs(dst, len, glyphs0); int first = face->charsToGlyphs(dst, paint2encoding(paint), glyphs1, NGLYPHS); int index = find_first_zero(glyphs1, NGLYPHS); REPORTER_ASSERT(reporter, NGLYPHS == nglyphs); REPORTER_ASSERT(reporter, index == first); REPORTER_ASSERT(reporter, 0 == memcmp(glyphs0, glyphs1, NGLYPHS * sizeof(uint16_t))); if (contains) { REPORTER_ASSERT(reporter, NGLYPHS == first); } else { REPORTER_ASSERT(reporter, NGLYPHS > first); } } } }
static void test_pack8(skiatest::Reporter* reporter) { static const struct { const uint8_t* fSrc; int fCount; } gTests[] = { { gTest80, SK_ARRAY_COUNT(gTest80) }, { gTest81, SK_ARRAY_COUNT(gTest81) }, { gTest82, SK_ARRAY_COUNT(gTest82) }, { gTest83, SK_ARRAY_COUNT(gTest83) }, { gTest84, SK_ARRAY_COUNT(gTest84) } }; for (size_t i = 4; i < SK_ARRAY_COUNT(gTests); i++) { uint8_t dst[100]; size_t maxSize = SkPackBits::ComputeMaxSize8(gTests[i].fCount); size_t dstSize = SkPackBits::Pack8(gTests[i].fSrc, gTests[i].fCount, dst); REPORTER_ASSERT(reporter, dstSize <= maxSize); uint8_t src[100]; int srcCount = SkPackBits::Unpack8(dst, dstSize, src); bool match = gTests[i].fCount == srcCount && memcmp(gTests[i].fSrc, src, gTests[i].fCount * sizeof(uint8_t)) == 0; REPORTER_ASSERT(reporter, match); } for (size_t size = 1; size <= 512; size += 1) { for (int n = 100; n; n--) { uint8_t src[600], src2[600]; uint8_t dst[600]; rand_fill(src, size); size_t dstSize = SkPackBits::Pack8(src, size, dst); size_t maxSize = SkPackBits::ComputeMaxSize8(size); REPORTER_ASSERT(reporter, maxSize >= dstSize); size_t srcCount = SkPackBits::Unpack8(dst, dstSize, src2); REPORTER_ASSERT(reporter, size == srcCount); bool match = memcmp(src, src2, size * sizeof(uint8_t)) == 0; REPORTER_ASSERT(reporter, match); for (int j = 0; j < 100; j++) { size_t skip = gRand.nextU() % size; size_t write = gRand.nextU() % size; if (skip + write > size) { write = size - skip; } SkPackBits::Unpack8(src, skip, write, dst); bool match = memcmp(src, src2 + skip, write) == 0; REPORTER_ASSERT(reporter, match); } } } }
void onDraw(SkCanvas* canvas) override { // Draw a giant AA circle as the background. SkISize size = this->getISize(); SkScalar giantRadius = SkTMin(SkIntToScalar(size.fWidth), SkIntToScalar(size.fHeight)) / 2.f; SkPoint giantCenter = SkPoint::Make(SkIntToScalar(size.fWidth/2), SkIntToScalar(size.fHeight/2)); SkPaint giantPaint; giantPaint.setAntiAlias(true); giantPaint.setColor(0x80808080); canvas->drawCircle(giantCenter.fX, giantCenter.fY, giantRadius, giantPaint); SkRandom rand; canvas->translate(20 * SK_Scalar1, 20 * SK_Scalar1); int i; for (i = 0; i < fPaints.count(); ++i) { canvas->save(); // position the path, and make it at off-integer coords. canvas->translate(SK_Scalar1 * 200 * (i % 5) + SK_Scalar1 / 4, SK_Scalar1 * 200 * (i / 5) + 3 * SK_Scalar1 / 4); SkColor color = rand.nextU(); color |= 0xff000000; fPaints[i].setColor(color); canvas->drawCircle(SkIntToScalar(40), SkIntToScalar(40), SkIntToScalar(20), fPaints[i]); canvas->restore(); } for (int j = 0; j < fMatrices.count(); ++j, ++i) { canvas->save(); canvas->translate(SK_Scalar1 * 200 * (i % 5) + SK_Scalar1 / 4, SK_Scalar1 * 200 * (i / 5) + 3 * SK_Scalar1 / 4); canvas->concat(fMatrices[j]); SkPaint paint; paint.setAntiAlias(true); SkColor color = rand.nextU(); color |= 0xff000000; paint.setColor(color); canvas->drawCircle(SkIntToScalar(40), SkIntToScalar(40), SkIntToScalar(20), paint); canvas->restore(); } }
void onDraw(const int loops, SkCanvas* canvas) override { const char* text = "Hamburgefons"; size_t len = strlen(text); SkISize size = canvas->getDeviceSize(); SkRandom random; for (int i = 0; i < loops; ++i) { SkPaint paint; paint.setXfermode(fXfermode.get()); paint.setColor(random.nextU()); if (fAA) { // Draw text to exercise AA code paths. paint.setAntiAlias(true); paint.setTextSize(random.nextRangeScalar(12, 96)); SkScalar x = random.nextRangeScalar(0, (SkScalar)size.fWidth), y = random.nextRangeScalar(0, (SkScalar)size.fHeight); for (int j = 0; j < 1000; ++j) { canvas->drawText(text, len, x, y, paint); } } else { // Draw rects to exercise non-AA code paths. SkScalar w = random.nextRangeScalar(50, 100); SkScalar h = random.nextRangeScalar(50, 100); SkRect rect = SkRect::MakeXYWH( random.nextUScalar1() * (size.fWidth - w), random.nextUScalar1() * (size.fHeight - h), w, h ); for (int j = 0; j < 1000; ++j) { canvas->drawRect(rect, paint); } } } }
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 random_fill(SkRandom& rand, void* buffer, size_t size) { char* p = (char*)buffer; char* stop = p + size; while (p < stop) { *p++ = (char)(rand.nextU() >> 8); } }
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; } }
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(ColorFilter, reporter) { SkRandom rand; for (int mode = 0; mode <= SkXfermode::kLastMode; mode++) { SkColor color = rand.nextU(); // ensure we always get a filter, by avoiding the possibility of a // special case that would return NULL (if color's alpha is 0 or 0xFF) color = SkColorSetA(color, 0x7F); SkColorFilter* cf = SkColorFilter::CreateModeFilter(color, (SkXfermode::Mode)mode); // allow for no filter if we're in Dst mode (its a no op) if (SkXfermode::kDst_Mode == mode && NULL == cf) { continue; } SkAutoUnref aur(cf); REPORTER_ASSERT(reporter, cf); SkColor c = ~color; SkXfermode::Mode m = ILLEGAL_MODE; SkColor expectedColor = color; SkXfermode::Mode expectedMode = (SkXfermode::Mode)mode; // SkDebugf("--- mc [%d %x] ", mode, color); REPORTER_ASSERT(reporter, cf->asColorMode(&c, &m)); // handle special-case folding by the factory if (SkXfermode::kClear_Mode == mode) { if (c != expectedColor) { expectedColor = 0; } if (m != expectedMode) { expectedMode = SkXfermode::kSrc_Mode; } } // SkDebugf("--- got [%d %x] expected [%d %x]\n", m, c, expectedMode, expectedColor); REPORTER_ASSERT(reporter, c == expectedColor); REPORTER_ASSERT(reporter, m == expectedMode); { SkColorFilter* cf2 = reincarnate_colorfilter(cf); SkAutoUnref aur2(cf2); REPORTER_ASSERT(reporter, cf2); SkColor c2 = ~color; SkXfermode::Mode m2 = ILLEGAL_MODE; REPORTER_ASSERT(reporter, cf2->asColorMode(&c2, &m2)); REPORTER_ASSERT(reporter, c2 == expectedColor); REPORTER_ASSERT(reporter, m2 == expectedMode); } } test_composecolorfilter_limit(reporter); }
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; }
static void randN_proc(int array[N]) { SkRandom rand; int mod = N / 10; for (int i = 0; i < N; ++i) { array[i] = rand.nextU() % mod; } }
ComputeChecksumBench(void* param, ChecksumType type) : INHERITED(param), fType(type) { SkRandom rand; for (int i = 0; i < U32COUNT; ++i) { fData[i] = rand.nextU(); } fIsRendering = false; }
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)); } }
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); } }
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); }
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) { 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 { 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; } }
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); }
RectBench(void* param, int shift, int stroke = 0) : INHERITED(param), fShift(shift), fStroke(stroke) { SkRandom rand; const SkScalar offset = SK_Scalar1/3; for (int i = 0; i < N; i++) { int x = rand.nextU() % W; int y = rand.nextU() % H; int w = rand.nextU() % W; int h = rand.nextU() % H; w >>= shift; h >>= shift; x -= w/2; y -= h/2; fRects[i].set(SkIntToScalar(x), SkIntToScalar(y), SkIntToScalar(x+w), SkIntToScalar(y+h)); fRects[i].offset(offset, offset); fColors[i] = rand.nextU() | 0xFF808080; } }
static void test_memory_pool(skiatest::Reporter* reporter) { // prealloc and min alloc sizes for the pool static const size_t gSizes[][2] = { {0, 0}, {10 * sizeof(A), 20 * sizeof(A)}, {100 * sizeof(A), 100 * sizeof(A)}, {500 * sizeof(A), 500 * sizeof(A)}, {10000 * sizeof(A), 0}, {1, 100 * sizeof(A)}, }; // different percentages of creation vs deletion static const float gCreateFraction[] = {1.f, .95f, 0.75f, .5f}; // number of create/destroys per test static const int kNumIters = 20000; // check that all the values stored in A objects are correct after this // number of iterations static const int kCheckPeriod = 500; SkRandom r; for (size_t s = 0; s < SK_ARRAY_COUNT(gSizes); ++s) { A::SetAllocator(gSizes[s][0], gSizes[s][1]); for (size_t c = 0; c < SK_ARRAY_COUNT(gCreateFraction); ++c) { SkTDArray<Rec> instanceRecs; for (int i = 0; i < kNumIters; ++i) { float createOrDestroy = r.nextUScalar1(); if (createOrDestroy < gCreateFraction[c] || 0 == instanceRecs.count()) { Rec* rec = instanceRecs.append(); rec->fInstance = A::Create(&r); rec->fValue = static_cast<int>(r.nextU()); rec->fInstance->setValues(rec->fValue); } else { int d = r.nextRangeU(0, instanceRecs.count() - 1); Rec& rec = instanceRecs[d]; REPORTER_ASSERT(reporter, rec.fInstance->checkValues(rec.fValue)); delete rec.fInstance; instanceRecs.removeShuffle(d); } if (0 == i % kCheckPeriod) { for (int r = 0; r < instanceRecs.count(); ++r) { Rec& rec = instanceRecs[r]; REPORTER_ASSERT(reporter, rec.fInstance->checkValues(rec.fValue)); } } } for (int i = 0; i < instanceRecs.count(); ++i) { Rec& rec = instanceRecs[i]; REPORTER_ASSERT(reporter, rec.fInstance->checkValues(rec.fValue)); delete rec.fInstance; } #ifdef SK_ENABLE_INST_COUNT REPORTER_ASSERT(reporter, !A::GetInstanceCount()); #endif } } }
static void do_draw(SkCanvas* canvas) { SkPaint paint; SkRandom rand; for (int i = 0; i < 20; ++i) { paint.setColor(ToolUtils::color_to_565(rand.nextU() | (0xFF << 24))); canvas->drawRect({ 15, 15, 290, 40 }, paint); canvas->translate(0, 30); } }
static int rand_pts(SkRandom& rand, SkPoint pts[4]) { int n = rand.nextU() & 3; n += 1; for (int i = 0; i < n; ++i) { pts[i].fX = rand.nextSScalar1(); pts[i].fY = rand.nextSScalar1(); } return n; }
// Test that erase+getColor round trips with RGBA_F16 pixels. DEF_TEST(Bitmap_erase_f16_erase_getColor, r) { SkRandom random; SkPixmap pm; SkBitmap bm; bm.allocPixels(SkImageInfo::Make(1, 1, kRGBA_F16_SkColorType, kPremul_SkAlphaType)); REPORTER_ASSERT(r, bm.peekPixels(&pm)); for (unsigned i = 0; i < 0x100; ++i) { // Test all possible values of blue component. SkColor color1 = (SkColor)((random.nextU() & 0xFFFFFF00) | i); // Test all possible values of alpha component. SkColor color2 = (SkColor)((random.nextU() & 0x00FFFFFF) | (i << 24)); for (SkColor color : {color1, color2}) { pm.erase(color); if (SkColorGetA(color) != 0) { REPORTER_ASSERT(r, color == pm.getColor(0, 0)); } else { REPORTER_ASSERT(r, 0 == SkColorGetA(pm.getColor(0, 0))); } } } }