Ensure all image filter tests have "ImageFilter" somewhere in the name.

tests/ImageFilterTest.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmap.h"
 #include "SkBitmapDevice.h"
 #include "SkBlurImageFilter.h"
@@ skipping 643 matching lines @@
                                                                              widthHeight),
                                                   0,
                                                   &props,
                                                   SkGpuDevice::kUninit_InitContents));
     SkImageFilter::DeviceProxy proxy(device.get());
 
     (*test)(&proxy, reporter, context);
 }
 #endif
 
-DEF_TEST(TestNegativeBlurSigma, reporter) {
+DEF_TEST(ImageFilterNegativeBlurSigma, reporter) {
     run_raster_test(reporter, 100, test_negative_blur_sigma);
 }
 
 #if SK_SUPPORT_GPU
-DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(TestNegativeBlurSigma_Gpu, reporter, ctxInfo) {
+DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(ImageFilterNegativeBlurSigma_Gpu, reporter, ctxInfo) {
     run_gpu_test(reporter, ctxInfo.fGrContext, 100, test_negative_blur_sigma);
 }
 #endif
 
 static void test_zero_blur_sigma(SkImageFilter::Proxy* proxy,
                                  skiatest::Reporter* reporter,
                                  GrContext* context) {
     // Check that SkBlurImageFilter with a zero sigma and a non-zero srcOffset works correctly.
     SkImageFilter::CropRect cropRect(SkRect::Make(SkIRect::MakeXYWH(5, 0, 5, 10)));
     sk_sp<SkImageFilter> input(SkOffsetImageFilter::Make(0, 0, nullptr, &cropRect));
@@ skipping 20 matching lines @@
         for (int x = 0; x < resultBM.width(); x++) {
             bool diff = *resultBM.getAddr32(x, y) != SK_ColorGREEN;
             REPORTER_ASSERT(reporter, !diff);
             if (diff) {
                 break;
             }
         }
     }
 }
 
-DEF_TEST(TestZeroBlurSigma, reporter) {
+DEF_TEST(ImageFilterZeroBlurSigma, reporter) {
     run_raster_test(reporter, 100, test_zero_blur_sigma);
 }
 
 #if SK_SUPPORT_GPU
-DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(TestZeroBlurSigma_Gpu, reporter, ctxInfo) {
+DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(ImageFilterZeroBlurSigma_Gpu, reporter, ctxInfo) {
     run_gpu_test(reporter, ctxInfo.fGrContext, 100, test_zero_blur_sigma);
 }
 #endif
 
 
 // Tests that, even when an upstream filter has returned null (due to failure or clipping), a
 // downstream filter that affects transparent black still does so even with a nullptr input.
 static void test_fail_affects_transparent_black(SkImageFilter::Proxy* proxy,
                                                 skiatest::Reporter* reporter,
                                                 GrContext* context) {
@@ skipping 565 matching lines @@
     canvas->drawBitmap(bitmap, 0, 0, &paint);
 }
 
 DEF_TEST(HugeBlurImageFilter, reporter) {
     SkBitmap temp;
     temp.allocN32Pixels(100, 100);
     SkCanvas canvas(temp);
     test_huge_blur(&canvas, reporter);
 }
 
-DEF_TEST(MatrixConvolutionSanityTest, reporter) {
+DEF_TEST(ImageFilterMatrixConvolutionSanityTest, reporter) {
     SkScalar kernel[1] = { 0 };
     SkScalar gain = SK_Scalar1, bias = 0;
     SkIPoint kernelOffset = SkIPoint::Make(1, 1);
 
     // Check that an enormous (non-allocatable) kernel gives a nullptr filter.
     sk_sp<SkImageFilter> conv(SkMatrixConvolutionImageFilter::Make(
         SkISize::Make(1<<30, 1<<30),
         kernel,
         gain,
         bias,
@@ skipping 230 matching lines @@
 
     sk_sp<SkSpecialImage> resultImg(filter->filterImage(srcImg.get(), ctx, &offset));
     REPORTER_ASSERT(reporter, resultImg);
 
     REPORTER_ASSERT(reporter, offset.fX == 0);
     REPORTER_ASSERT(reporter, offset.fY == 0);
     REPORTER_ASSERT(reporter, resultImg->width() == 20);
     REPORTER_ASSERT(reporter, resultImg->height() == 30);
 }
 
-DEF_TEST(PartialCropRect, reporter) {
+DEF_TEST(ImageFilterPartialCropRect, reporter) {
     run_raster_test(reporter, 100, test_partial_crop_rect);
 }
 
 #if SK_SUPPORT_GPU
-DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(PartialCropRect_Gpu, reporter, ctxInfo) {
+DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(ImageFilterPartialCropRect_Gpu, reporter, ctxInfo) {
     run_gpu_test(reporter, ctxInfo.fGrContext, 100, test_partial_crop_rect);
 }
 #endif
 
 DEF_TEST(ImageFilterCanComputeFastBounds, reporter) {
 
     {
         SkPoint3 location = SkPoint3::Make(0, 0, SK_Scalar1);
         sk_sp<SkImageFilter> lighting(SkLightingImageFilter::MakePointLitDiffuse(location,
                                                                                  SK_ColorGREEN,
@@ skipping 113 matching lines @@
         return;
     }
 
     SkPaint paint;
     paint.setImageFilter(std::move(blur));
 
     // This should not crash (http://crbug.com/570479).
     canvas->drawRect(SkRect::MakeIWH(largeW, largeH), paint);
 }
 
-DEF_TEST(BlurLargeImage, reporter) {
+DEF_TEST(ImageFilterBlurLargeImage, reporter) {
     auto surface(SkSurface::MakeRaster(SkImageInfo::MakeN32Premul(100, 100)));
     test_large_blur_input(reporter, surface->getCanvas());
 }
 
 #if SK_SUPPORT_GPU
 
-DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(HugeBlurImageFilter_Gpu, reporter, ctxInfo) {
+DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(ImageFilterHugeBlur_Gpu, reporter, ctxInfo) {
     const SkSurfaceProps props(SkSurfaceProps::kLegacyFontHost_InitType);
 
     sk_sp<SkGpuDevice> device(SkGpuDevice::Create(ctxInfo.fGrContext,
                                                   SkBudgeted::kNo,
                                                   SkImageInfo::MakeN32Premul(100, 100),
                                                   0,
                                                   &props,
                                                   SkGpuDevice::kUninit_InitContents));
     SkCanvas canvas(device.get());
 
     test_huge_blur(&canvas, reporter);
 }
 
 DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(XfermodeImageFilterCroppedInput_Gpu, reporter, ctxInfo) {
     const SkSurfaceProps props(SkSurfaceProps::kLegacyFontHost_InitType);
 
     sk_sp<SkGpuDevice> device(SkGpuDevice::Create(ctxInfo.fGrContext,
                                                   SkBudgeted::kNo,
                                                   SkImageInfo::MakeN32Premul(1, 1),
                                                   0,
                                                   &props,
                                                   SkGpuDevice::kUninit_InitContents));
     SkCanvas canvas(device.get());
 
     test_xfermode_cropped_input(&canvas, reporter);
 }
 
-DEF_GPUTEST_FOR_ALL_GL_CONTEXTS(BlurLargeImage_Gpu, reporter, ctxInfo) {
+DEF_GPUTEST_FOR_ALL_GL_CONTEXTS(ImageFilterBlurLargeImage_Gpu, reporter, ctxInfo) {
     auto surface(SkSurface::MakeRenderTarget(ctxInfo.fGrContext, SkBudgeted::kYes,
                                              SkImageInfo::MakeN32Premul(100, 100)));
     test_large_blur_input(reporter, surface->getCanvas());
 }
 #endif