| /* |
| * Copyright 2014 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include "Test.h" |
| #include "SkCanvas.h" |
| #include "SkDebugCanvas.h" |
| #include "SkPicture.h" |
| #include "SkPictureFlat.h" |
| #include "SkPictureRecord.h" |
| |
| // This test exercises the Matrix/Clip State collapsing system. It generates |
| // example skps and the compares the actual stored operations to the expected |
| // operations. The test works by emitting canvas operations at three levels: |
| // overall structure, bodies that draw something and model/clip state changes. |
| // |
| // Structure methods only directly emit save and restores but call the |
| // ModelClip and Body helper methods to fill in the structure. Since they only |
| // emit saves and restores the operations emitted by the structure methods will |
| // be completely removed by the matrix/clip collapse. Note: every save in |
| // a structure method is followed by a call to a ModelClip helper. |
| // |
| // Body methods only directly emit draw ops and saveLayer/restore pairs but call |
| // the ModelClip helper methods. Since the body methods emit the ops that cannot |
| // be collapsed (i.e., draw ops, saveLayer/restore) they also generate the |
| // expected result information. Note: every saveLayer in a body method is |
| // followed by a call to a ModelClip helper. |
| // |
| // The ModelClip methods output matrix and clip ops in various orders and |
| // combinations. They contribute to the expected result by outputting the |
| // expected matrix & clip ops. Note that, currently, the entire clip stack |
| // is output for each MC state so the clip operations accumulate down the |
| // save/restore stack. |
| |
| // TODOs: |
| // check on clip offsets |
| // - not sure if this is possible. The desire is to verify that the clip |
| // operations' offsets point to the correct follow-on operations. This |
| // could be difficult since there is no good way to communicate the |
| // offset stored in the SkPicture to the debugger's clip objects |
| // add comparison of rendered before & after images? |
| // - not sure if this would be useful since it somewhat duplicates the |
| // correctness test of running render_pictures in record mode and |
| // rendering before and after images. Additionally the matrix/clip collapse |
| // is sure to cause some small differences so an automated test might |
| // yield too many false positives. |
| // run the matrix/clip collapse system on the 10K skp set |
| // - this should give us warm fuzzies that the matrix clip collapse |
| // system is ready for prime time |
| // bench the recording times with/without matrix/clip collapsing |
| |
| #ifdef SK_COLLAPSE_MATRIX_CLIP_STATE |
| |
| // Enable/disable debugging helper code |
| //#define TEST_COLLAPSE_MATRIX_CLIP_STATE 1 |
| |
| // Extract the command ops from the input SkPicture |
| static void gets_ops(SkPicture& input, SkTDArray<DrawType>* ops) { |
| SkDebugCanvas debugCanvas(input.width(), input.height()); |
| debugCanvas.setBounds(input.width(), input.height()); |
| input.draw(&debugCanvas); |
| |
| ops->setCount(debugCanvas.getSize()); |
| for (int i = 0; i < debugCanvas.getSize(); ++i) { |
| (*ops)[i] = debugCanvas.getDrawCommandAt(i)->getType(); |
| } |
| } |
| |
| enum ClipType { |
| kNone_ClipType, |
| kRect_ClipType, |
| kRRect_ClipType, |
| kPath_ClipType, |
| kRegion_ClipType, |
| |
| kLast_ClipType = kRRect_ClipType |
| }; |
| |
| static const int kClipTypeCount = kLast_ClipType + 1; |
| |
| enum MatType { |
| kNone_MatType, |
| kTranslate_MatType, |
| kScale_MatType, |
| kSkew_MatType, |
| kRotate_MatType, |
| kConcat_MatType, |
| kSetMatrix_MatType, |
| |
| kLast_MatType = kScale_MatType |
| }; |
| |
| static const int kMatTypeCount = kLast_MatType + 1; |
| |
| // TODO: implement the rest of the draw ops |
| enum DrawOpType { |
| kNone_DrawOpType, |
| #if 0 |
| kBitmap_DrawOpType, |
| kBitmapMatrix_DrawOpType, |
| kBitmapNone_DrawOpType, |
| kBitmapRectToRect_DrawOpType, |
| #endif |
| kClear_DrawOpType, |
| #if 0 |
| kData_DrawOpType, |
| #endif |
| kOval_DrawOpType, |
| #if 0 |
| kPaint_DrawOpType, |
| kPath_DrawOpType, |
| kPicture_DrawOpType, |
| kPoints_DrawOpType, |
| kPosText_DrawOpType, |
| kPosTextTopBottom_DrawOpType, |
| kPosTextH_DrawOpType, |
| kPosTextHTopBottom_DrawOpType, |
| #endif |
| kRect_DrawOpType, |
| kRRect_DrawOpType, |
| #if 0 |
| kSprite_DrawOpType, |
| kText_DrawOpType, |
| kTextOnPath_DrawOpType, |
| kTextTopBottom_DrawOpType, |
| kDrawVertices_DrawOpType, |
| #endif |
| |
| kLastNonSaveLayer_DrawOpType = kRect_DrawOpType, |
| |
| // saveLayer's have to handled apart from the other draw operations |
| // since they also alter the save/restore structure. |
| kSaveLayer_DrawOpType, |
| }; |
| |
| static const int kNonSaveLayerDrawOpTypeCount = kLastNonSaveLayer_DrawOpType + 1; |
| |
| typedef void (*PFEmitMC)(SkCanvas* canvas, MatType mat, ClipType clip, |
| DrawOpType draw, SkTDArray<DrawType>* expected, |
| int accumulatedClips); |
| typedef void (*PFEmitBody)(SkCanvas* canvas, PFEmitMC emitMC, MatType mat, |
| ClipType clip, DrawOpType draw, |
| SkTDArray<DrawType>* expected, int accumulatedClips); |
| typedef void (*PFEmitStruct)(SkCanvas* canvas, PFEmitMC emitMC, MatType mat, |
| ClipType clip, PFEmitBody emitBody, DrawOpType draw, |
| SkTDArray<DrawType>* expected); |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| // TODO: expand the testing to include the different ops & AA types! |
| static void emit_clip(SkCanvas* canvas, ClipType clip) { |
| switch (clip) { |
| case kNone_ClipType: |
| break; |
| case kRect_ClipType: { |
| SkRect r = SkRect::MakeLTRB(10, 10, 90, 90); |
| canvas->clipRect(r, SkRegion::kIntersect_Op, true); |
| break; |
| } |
| case kRRect_ClipType: { |
| SkRect r = SkRect::MakeLTRB(10, 10, 90, 90); |
| SkRRect rr; |
| rr.setRectXY(r, 10, 10); |
| canvas->clipRRect(rr, SkRegion::kIntersect_Op, true); |
| break; |
| } |
| case kPath_ClipType: { |
| SkPath p; |
| p.moveTo(5.0f, 5.0f); |
| p.lineTo(50.0f, 50.0f); |
| p.lineTo(100.0f, 5.0f); |
| p.close(); |
| canvas->clipPath(p, SkRegion::kIntersect_Op, true); |
| break; |
| } |
| case kRegion_ClipType: { |
| SkIRect rects[2] = { |
| { 1, 1, 55, 55 }, |
| { 45, 45, 99, 99 }, |
| }; |
| SkRegion r; |
| r.setRects(rects, 2); |
| canvas->clipRegion(r, SkRegion::kIntersect_Op); |
| break; |
| } |
| default: |
| SkASSERT(0); |
| } |
| } |
| |
| static void add_clip(ClipType clip, MatType mat, SkTDArray<DrawType>* expected) { |
| if (nullptr == expected) { |
| // expected is nullptr if this clip will be fused into later clips |
| return; |
| } |
| |
| switch (clip) { |
| case kNone_ClipType: |
| break; |
| case kRect_ClipType: |
| *expected->append() = CONCAT; |
| *expected->append() = CLIP_RECT; |
| break; |
| case kRRect_ClipType: |
| *expected->append() = CONCAT; |
| *expected->append() = CLIP_RRECT; |
| break; |
| case kPath_ClipType: |
| *expected->append() = CONCAT; |
| *expected->append() = CLIP_PATH; |
| break; |
| case kRegion_ClipType: |
| *expected->append() = CONCAT; |
| *expected->append() = CLIP_REGION; |
| break; |
| default: |
| SkASSERT(0); |
| } |
| } |
| |
| static void emit_mat(SkCanvas* canvas, MatType mat) { |
| switch (mat) { |
| case kNone_MatType: |
| break; |
| case kTranslate_MatType: |
| canvas->translate(5.0f, 5.0f); |
| break; |
| case kScale_MatType: |
| canvas->scale(1.1f, 1.1f); |
| break; |
| case kSkew_MatType: |
| canvas->skew(1.1f, 1.1f); |
| break; |
| case kRotate_MatType: |
| canvas->rotate(1.0f); |
| break; |
| case kConcat_MatType: { |
| SkMatrix m; |
| m.setTranslate(1.0f, 1.0f); |
| canvas->concat(m); |
| break; |
| } |
| case kSetMatrix_MatType: { |
| SkMatrix m; |
| m.setTranslate(1.0f, 1.0f); |
| canvas->setMatrix(m); |
| break; |
| } |
| default: |
| SkASSERT(0); |
| } |
| } |
| |
| static void add_mat(MatType mat, SkTDArray<DrawType>* expected) { |
| if (nullptr == expected) { |
| // expected is nullptr if this matrix call will be fused into later ones |
| return; |
| } |
| |
| switch (mat) { |
| case kNone_MatType: |
| break; |
| case kTranslate_MatType: // fall thru |
| case kScale_MatType: // fall thru |
| case kSkew_MatType: // fall thru |
| case kRotate_MatType: // fall thru |
| case kConcat_MatType: // fall thru |
| case kSetMatrix_MatType: |
| // TODO: this system currently converts a setMatrix to concat. If we wanted to |
| // really preserve the setMatrix semantics we should keep it a setMatrix. I'm |
| // not sure if this is a good idea though since this would keep things like pinch |
| // zoom from working. |
| *expected->append() = CONCAT; |
| break; |
| default: |
| SkASSERT(0); |
| } |
| } |
| |
| static void emit_draw(SkCanvas* canvas, DrawOpType draw, SkTDArray<DrawType>* expected) { |
| switch (draw) { |
| case kNone_DrawOpType: |
| break; |
| case kClear_DrawOpType: |
| canvas->clear(SK_ColorRED); |
| *expected->append() = DRAW_CLEAR; |
| break; |
| case kOval_DrawOpType: { |
| SkRect r = SkRect::MakeLTRB(10, 10, 90, 90); |
| SkPaint p; |
| canvas->drawOval(r, p); |
| *expected->append() = DRAW_OVAL; |
| break; |
| } |
| case kRect_DrawOpType: { |
| SkRect r = SkRect::MakeLTRB(10, 10, 90, 90); |
| SkPaint p; |
| canvas->drawRect(r, p); |
| *expected->append() = DRAW_RECT; |
| break; |
| } |
| case kRRect_DrawOpType: { |
| SkRect r = SkRect::MakeLTRB(10.0f, 10.0f, 90.0f, 90.0f); |
| SkRRect rr; |
| rr.setRectXY(r, 5.0f, 5.0f); |
| SkPaint p; |
| canvas->drawRRect(rr, p); |
| *expected->append() = DRAW_RRECT; |
| break; |
| } |
| default: |
| SkASSERT(0); |
| } |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| // Emit: |
| // clip |
| // matrix |
| // Simple case - the clip isn't effect by the matrix |
| static void emit_clip_and_mat(SkCanvas* canvas, MatType mat, ClipType clip, |
| DrawOpType draw, SkTDArray<DrawType>* expected, |
| int accumulatedClips) { |
| emit_clip(canvas, clip); |
| emit_mat(canvas, mat); |
| |
| if (kNone_DrawOpType == draw) { |
| return; |
| } |
| |
| for (int i = 0; i < accumulatedClips; ++i) { |
| add_clip(clip, mat, expected); |
| } |
| add_mat(mat, expected); |
| } |
| |
| // Emit: |
| // matrix |
| // clip |
| // Emitting the matrix first is more challenging since the matrix has to be |
| // pushed across (i.e., applied to) the clip. |
| static void emit_mat_and_clip(SkCanvas* canvas, MatType mat, ClipType clip, |
| DrawOpType draw, SkTDArray<DrawType>* expected, |
| int accumulatedClips) { |
| emit_mat(canvas, mat); |
| emit_clip(canvas, clip); |
| |
| if (kNone_DrawOpType == draw) { |
| return; |
| } |
| |
| // the matrix & clip order will be reversed once collapsed! |
| for (int i = 0; i < accumulatedClips; ++i) { |
| add_clip(clip, mat, expected); |
| } |
| add_mat(mat, expected); |
| } |
| |
| // Emit: |
| // matrix |
| // clip |
| // matrix |
| // clip |
| // This tests that the matrices and clips coalesce when collapsed |
| static void emit_double_mat_and_clip(SkCanvas* canvas, MatType mat, ClipType clip, |
| DrawOpType draw, SkTDArray<DrawType>* expected, |
| int accumulatedClips) { |
| emit_mat(canvas, mat); |
| emit_clip(canvas, clip); |
| emit_mat(canvas, mat); |
| emit_clip(canvas, clip); |
| |
| if (kNone_DrawOpType == draw) { |
| return; |
| } |
| |
| for (int i = 0; i < accumulatedClips; ++i) { |
| add_clip(clip, mat, expected); |
| add_clip(clip, mat, expected); |
| } |
| add_mat(mat, expected); |
| } |
| |
| // Emit: |
| // matrix |
| // clip |
| // clip |
| // This tests accumulation of clips in same transform state. It also tests pushing |
| // of the matrix across both the clips. |
| static void emit_mat_clip_clip(SkCanvas* canvas, MatType mat, ClipType clip, |
| DrawOpType draw, SkTDArray<DrawType>* expected, |
| int accumulatedClips) { |
| emit_mat(canvas, mat); |
| emit_clip(canvas, clip); |
| emit_clip(canvas, clip); |
| |
| if (kNone_DrawOpType == draw) { |
| return; |
| } |
| |
| for (int i = 0; i < accumulatedClips; ++i) { |
| add_clip(clip, mat, expected); |
| add_clip(clip, mat, expected); |
| } |
| add_mat(mat, expected); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| // Emit: |
| // matrix & clip calls |
| // draw op |
| static void emit_body0(SkCanvas* canvas, PFEmitMC emitMC, MatType mat, |
| ClipType clip, DrawOpType draw, |
| SkTDArray<DrawType>* expected, int accumulatedClips) { |
| bool needsSaveRestore = kNone_DrawOpType != draw && |
| (kNone_MatType != mat || kNone_ClipType != clip); |
| |
| if (needsSaveRestore) { |
| *expected->append() = SAVE; |
| } |
| (*emitMC)(canvas, mat, clip, draw, expected, accumulatedClips+1); |
| emit_draw(canvas, draw, expected); |
| if (needsSaveRestore) { |
| *expected->append() = RESTORE; |
| } |
| } |
| |
| // Emit: |
| // matrix & clip calls |
| // draw op |
| // matrix & clip calls |
| // draw op |
| static void emit_body1(SkCanvas* canvas, PFEmitMC emitMC, MatType mat, |
| ClipType clip, DrawOpType draw, |
| SkTDArray<DrawType>* expected, int accumulatedClips) { |
| bool needsSaveRestore = kNone_DrawOpType != draw && |
| (kNone_MatType != mat || kNone_ClipType != clip); |
| |
| if (needsSaveRestore) { |
| *expected->append() = SAVE; |
| } |
| (*emitMC)(canvas, mat, clip, draw, expected, accumulatedClips+1); |
| emit_draw(canvas, draw, expected); |
| if (needsSaveRestore) { |
| *expected->append() = RESTORE; |
| *expected->append() = SAVE; |
| } |
| (*emitMC)(canvas, mat, clip, draw, expected, accumulatedClips+2); |
| emit_draw(canvas, draw, expected); |
| if (needsSaveRestore) { |
| *expected->append() = RESTORE; |
| } |
| } |
| |
| // Emit: |
| // matrix & clip calls |
| // SaveLayer |
| // matrix & clip calls |
| // draw op |
| // Restore |
| static void emit_body2(SkCanvas* canvas, PFEmitMC emitMC, MatType mat, |
| ClipType clip, DrawOpType draw, |
| SkTDArray<DrawType>* expected, int accumulatedClips) { |
| bool needsSaveRestore = kNone_DrawOpType != draw && |
| (kNone_MatType != mat || kNone_ClipType != clip); |
| |
| if (kNone_MatType != mat || kNone_ClipType != clip) { |
| *expected->append() = SAVE; |
| } |
| (*emitMC)(canvas, mat, clip, kSaveLayer_DrawOpType, expected, accumulatedClips+1); |
| *expected->append() = SAVE_LAYER; |
| // TODO: widen testing to exercise saveLayer's parameters |
| canvas->saveLayer(nullptr, nullptr); |
| if (needsSaveRestore) { |
| *expected->append() = SAVE; |
| } |
| (*emitMC)(canvas, mat, clip, draw, expected, 1); |
| emit_draw(canvas, draw, expected); |
| if (needsSaveRestore) { |
| *expected->append() = RESTORE; |
| } |
| canvas->restore(); |
| *expected->append() = RESTORE; |
| if (kNone_MatType != mat || kNone_ClipType != clip) { |
| *expected->append() = RESTORE; |
| } |
| } |
| |
| // Emit: |
| // matrix & clip calls |
| // SaveLayer |
| // matrix & clip calls |
| // SaveLayer |
| // matrix & clip calls |
| // draw op |
| // Restore |
| // matrix & clip calls (will be ignored) |
| // Restore |
| static void emit_body3(SkCanvas* canvas, PFEmitMC emitMC, MatType mat, |
| ClipType clip, DrawOpType draw, |
| SkTDArray<DrawType>* expected, int accumulatedClips) { |
| bool needsSaveRestore = kNone_DrawOpType != draw && |
| (kNone_MatType != mat || kNone_ClipType != clip); |
| |
| if (kNone_MatType != mat || kNone_ClipType != clip) { |
| *expected->append() = SAVE; |
| } |
| (*emitMC)(canvas, mat, clip, kSaveLayer_DrawOpType, expected, accumulatedClips+1); |
| *expected->append() = SAVE_LAYER; |
| // TODO: widen testing to exercise saveLayer's parameters |
| canvas->saveLayer(nullptr, nullptr); |
| (*emitMC)(canvas, mat, clip, kSaveLayer_DrawOpType, expected, 1); |
| if (kNone_MatType != mat || kNone_ClipType != clip) { |
| *expected->append() = SAVE; |
| } |
| *expected->append() = SAVE_LAYER; |
| // TODO: widen testing to exercise saveLayer's parameters |
| canvas->saveLayer(nullptr, nullptr); |
| if (needsSaveRestore) { |
| *expected->append() = SAVE; |
| } |
| (*emitMC)(canvas, mat, clip, draw, expected, 1); |
| emit_draw(canvas, draw, expected); |
| if (needsSaveRestore) { |
| *expected->append() = RESTORE; |
| } |
| canvas->restore(); // for saveLayer |
| *expected->append() = RESTORE; // for saveLayer |
| if (kNone_MatType != mat || kNone_ClipType != clip) { |
| *expected->append() = RESTORE; |
| } |
| canvas->restore(); |
| // required to match forced SAVE_LAYER |
| *expected->append() = RESTORE; |
| if (kNone_MatType != mat || kNone_ClipType != clip) { |
| *expected->append() = RESTORE; |
| } |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| // Emit: |
| // Save |
| // some body |
| // Restore |
| // Note: the outer save/restore are provided by beginRecording/endRecording |
| static void emit_struct0(SkCanvas* canvas, |
| PFEmitMC emitMC, MatType mat, ClipType clip, |
| PFEmitBody emitBody, DrawOpType draw, |
| SkTDArray<DrawType>* expected) { |
| (*emitBody)(canvas, emitMC, mat, clip, draw, expected, 0); |
| } |
| |
| // Emit: |
| // Save |
| // matrix & clip calls |
| // Save |
| // some body |
| // Restore |
| // matrix & clip calls (will be ignored) |
| // Restore |
| // Note: the outer save/restore are provided by beginRecording/endRecording |
| static void emit_struct1(SkCanvas* canvas, |
| PFEmitMC emitMC, MatType mat, ClipType clip, |
| PFEmitBody emitBody, DrawOpType draw, |
| SkTDArray<DrawType>* expected) { |
| (*emitMC)(canvas, mat, clip, draw, nullptr, 0); // these get fused into later ops |
| canvas->save(); |
| (*emitBody)(canvas, emitMC, mat, clip, draw, expected, 1); |
| canvas->restore(); |
| (*emitMC)(canvas, mat, clip, draw, nullptr, 0); // these will get removed |
| } |
| |
| // Emit: |
| // Save |
| // matrix & clip calls |
| // Save |
| // some body |
| // Restore |
| // Save |
| // some body |
| // Restore |
| // matrix & clip calls (will be ignored) |
| // Restore |
| // Note: the outer save/restore are provided by beginRecording/endRecording |
| static void emit_struct2(SkCanvas* canvas, |
| PFEmitMC emitMC, MatType mat, ClipType clip, |
| PFEmitBody emitBody, DrawOpType draw, |
| SkTDArray<DrawType>* expected) { |
| (*emitMC)(canvas, mat, clip, draw, nullptr, 1); // these will get fused into later ops |
| canvas->save(); |
| (*emitBody)(canvas, emitMC, mat, clip, draw, expected, 1); |
| canvas->restore(); |
| canvas->save(); |
| (*emitBody)(canvas, emitMC, mat, clip, draw, expected, 1); |
| canvas->restore(); |
| (*emitMC)(canvas, mat, clip, draw, nullptr, 1); // these will get removed |
| } |
| |
| // Emit: |
| // Save |
| // matrix & clip calls |
| // Save |
| // some body |
| // Restore |
| // Save |
| // matrix & clip calls |
| // Save |
| // some body |
| // Restore |
| // Restore |
| // matrix & clip calls (will be ignored) |
| // Restore |
| // Note: the outer save/restore are provided by beginRecording/endRecording |
| static void emit_struct3(SkCanvas* canvas, |
| PFEmitMC emitMC, MatType mat, ClipType clip, |
| PFEmitBody emitBody, DrawOpType draw, |
| SkTDArray<DrawType>* expected) { |
| (*emitMC)(canvas, mat, clip, draw, nullptr, 0); // these will get fused into later ops |
| canvas->save(); |
| (*emitBody)(canvas, emitMC, mat, clip, draw, expected, 1); |
| canvas->restore(); |
| canvas->save(); |
| (*emitMC)(canvas, mat, clip, draw, nullptr, 1); // these will get fused into later ops |
| canvas->save(); |
| (*emitBody)(canvas, emitMC, mat, clip, draw, expected, 2); |
| canvas->restore(); |
| canvas->restore(); |
| (*emitMC)(canvas, mat, clip, draw, nullptr, 0); // these will get removed |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| #ifdef SK_COLLAPSE_MATRIX_CLIP_STATE |
| static void print(const SkTDArray<DrawType>& expected, const SkTDArray<DrawType>& actual) { |
| SkDebugf("\n\nexpected %d --- actual %d\n", expected.count(), actual.count()); |
| int max = SkMax32(expected.count(), actual.count()); |
| |
| for (int i = 0; i < max; ++i) { |
| if (i < expected.count()) { |
| SkDebugf("%16s, ", SkDrawCommand::GetCommandString(expected[i])); |
| } else { |
| SkDebugf("%16s, ", " "); |
| } |
| |
| if (i < actual.count()) { |
| SkDebugf("%s\n", SkDrawCommand::GetCommandString(actual[i])); |
| } else { |
| SkDebugf("\n"); |
| } |
| } |
| SkDebugf("\n\n"); |
| SkASSERT(0); |
| } |
| #endif |
| |
| static void test_collapse(skiatest::Reporter* reporter) { |
| PFEmitStruct gStructure[] = { emit_struct0, emit_struct1, emit_struct2, emit_struct3 }; |
| PFEmitBody gBody[] = { emit_body0, emit_body1, emit_body2, emit_body3 }; |
| PFEmitMC gMCs[] = { emit_clip_and_mat, emit_mat_and_clip, |
| emit_double_mat_and_clip, emit_mat_clip_clip }; |
| |
| for (size_t i = 0; i < SK_ARRAY_COUNT(gStructure); ++i) { |
| for (size_t j = 0; j < SK_ARRAY_COUNT(gBody); ++j) { |
| for (size_t k = 0; k < SK_ARRAY_COUNT(gMCs); ++k) { |
| for (int l = 0; l < kMatTypeCount; ++l) { |
| for (int m = 0; m < kClipTypeCount; ++m) { |
| for (int n = 0; n < kNonSaveLayerDrawOpTypeCount; ++n) { |
| #ifdef TEST_COLLAPSE_MATRIX_CLIP_STATE |
| static int testID = -1; |
| ++testID; |
| if (testID < -1) { |
| continue; |
| } |
| SkDebugf("test: %d\n", testID); |
| #endif |
| |
| SkTDArray<DrawType> expected, actual; |
| |
| SkPicture picture; |
| |
| // Note: beginRecording/endRecording add a save/restore pair |
| SkCanvas* canvas = picture.beginRecording(100, 100); |
| (*gStructure[i])(canvas, |
| gMCs[k], |
| (MatType) l, |
| (ClipType) m, |
| gBody[j], |
| (DrawOpType) n, |
| &expected); |
| picture.endRecording(); |
| |
| gets_ops(picture, &actual); |
| |
| REPORTER_ASSERT(reporter, expected.count() == actual.count()); |
| |
| if (expected.count() != actual.count()) { |
| #ifdef TEST_COLLAPSE_MATRIX_CLIP_STATE |
| print(expected, actual); |
| #endif |
| continue; |
| } |
| |
| for (int i = 0; i < expected.count(); ++i) { |
| REPORTER_ASSERT(reporter, expected[i] == actual[i]); |
| #ifdef TEST_COLLAPSE_MATRIX_CLIP_STATE |
| if (expected[i] != actual[i]) { |
| print(expected, actual); |
| } |
| #endif |
| break; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| DEF_TEST(MatrixClipCollapse, reporter) { |
| test_collapse(reporter); |
| } |
| |
| #endif |
