SkPDF/Tests: imporve test coverage.

tests/PDFPrimitivesTest.cpp

 /*
  * Copyright 2010 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "Resources.h"
 #include "SkBitmap.h"
 #include "SkCanvas.h"
@@ skipping 316 matching lines @@
     sk_sp<SkPDFArray> referencedArray(new SkPDFArray);
     SkPDFObjNumMap catalog;
     catalog.addObject(referencedArray.get());
     REPORTER_ASSERT(reporter, catalog.getObjectNumber(
                             referencedArray.get()) == 1);
     dict->insertObjRef("n1", std::move(referencedArray));
     SkString result = emit_to_string(*dict, &catalog);
     assert_eq(reporter, result, "<</Type /DType\n/n1 1 0 R>>");
 }
 
-DEF_TEST(PDFPrimitives, reporter) {
+DEF_TEST(SkPDF_Primitives, reporter) {
     TestPDFUnion(reporter);
     TestPDFArray(reporter);
     TestPDFDict(reporter);
     TestPDFStream(reporter);
     TestObjectNumberMap(reporter);
     TestObjectRef(reporter);
     test_issue1083();
 }
 
 namespace {
@@ skipping 34 matching lines @@
 void DummyImageFilter::toString(SkString* str) const {
     str->appendf("DummyImageFilter: (");
     str->append(")");
 }
 #endif
 
 };
 
 // Check that PDF rendering of image filters successfully falls back to
 // CPU rasterization.
-DEF_TEST(PDFImageFilter, reporter) {
+DEF_TEST(SkPDF_ImageFilter, reporter) {
+    REQUIRE_PDF_DOCUMENT(SkPDF_ImageFilter, reporter);
     SkDynamicMemoryWStream stream;
     sk_sp<SkDocument> doc(SkDocument::MakePDF(&stream));
     SkCanvas* canvas = doc->beginPage(100.0f, 100.0f);
 
     sk_sp<DummyImageFilter> filter(DummyImageFilter::Make());
 
     // Filter just created; should be unvisited.
     REPORTER_ASSERT(reporter, !filter->visited());
     SkPaint paint;
     paint.setImageFilter(filter.get());
     canvas->drawRect(SkRect::MakeWH(100, 100), paint);
     doc->close();
 
     // Filter was used in rendering; should be visited.
     REPORTER_ASSERT(reporter, filter->visited());
 }
 
 // Check that PDF rendering of image filters successfully falls back to
 // CPU rasterization.
-DEF_TEST(PDFFontCanEmbedTypeface, reporter) {
+DEF_TEST(SkPDF_FontCanEmbedTypeface, reporter) {
     SkPDFCanon canon;
 
     const char resource[] = "fonts/Roboto2-Regular_NoEmbed.ttf";
     sk_sp<SkTypeface> noEmbedTypeface(MakeResourceAsTypeface(resource));
     if (noEmbedTypeface) {
         REPORTER_ASSERT(reporter,
                         !SkPDFFont::CanEmbedTypeface(noEmbedTypeface.get(), &canon));
     }
     sk_sp<SkTypeface> portableTypeface(
             sk_tool_utils::create_portable_typeface(NULL, SkFontStyle()));
@@ skipping 23 matching lines @@
         ERRORF(reporter, "unscannable result: %s", floatString);
         return;
     }
     if (std::isfinite(inputFloat) && roundTripFloat != inputFloat) {
         ERRORF(reporter, "roundTripFloat (%.9g) != inputFloat (%.9g)",
                roundTripFloat, inputFloat);
     }
 }
 
 // Test SkPDFUtils::AppendScalar for accuracy.
-DEF_TEST(PDFPrimitives_Scalar, reporter) {
+DEF_TEST(SkPDF_Primitives_Scalar, reporter) {
     SkRandom random(0x5EED);
     int iterationCount = 512;
     while (iterationCount-- > 0) {
         union { uint32_t u; float f; };
         u = random.nextU();
         static_assert(sizeof(float) == sizeof(uint32_t), "");
         check_pdf_scalar_serialization(reporter, f);
     }
     float alwaysCheck[] = {
         0.0f, -0.0f, 1.0f, -1.0f, SK_ScalarPI, 0.1f, FLT_MIN, FLT_MAX,
         -FLT_MIN, -FLT_MAX, FLT_MIN / 16.0f, -FLT_MIN / 16.0f,
         SK_FloatNaN, SK_FloatInfinity, SK_FloatNegativeInfinity,
         -FLT_MIN / 8388608.0
     };
     for (float inputFloat: alwaysCheck) {
         check_pdf_scalar_serialization(reporter, inputFloat);
     }
 }
 
 // Test SkPDFUtils:: for accuracy.
-DEF_TEST(PDFPrimitives_Color, reporter) {
+DEF_TEST(SkPDF_Primitives_Color, reporter) {
     char buffer[5];
     for (int i = 0; i < 256; ++i) {
         size_t len = SkPDFUtils::ColorToDecimal(i, buffer);
         REPORTER_ASSERT(reporter, len == strlen(buffer));
         float f;
         REPORTER_ASSERT(reporter, 1 == sscanf(buffer, "%f", &f));
         int roundTrip = (int)(0.5 + f * 255);
         REPORTER_ASSERT(reporter, roundTrip == i);
     }
 }