SkPDF: fix scalar serialization

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"
 #include "SkData.h"
 #include "SkDocument.h"
 #include "SkDeflate.h"
 #include "SkImageEncoder.h"
 #include "SkMatrix.h"
 #include "SkPDFCanon.h"
 #include "SkPDFDevice.h"
 #include "SkPDFFont.h"
 #include "SkPDFStream.h"
 #include "SkPDFTypes.h"
+#include "SkPDFUtils.h"
 #include "SkReadBuffer.h"
 #include "SkScalar.h"
 #include "SkStream.h"
 #include "SkTypes.h"
 #include "Test.h"
 #include "sk_tool_utils.h"
 
 #define DUMMY_TEXT "DCT compessed stream."
 
 namespace {
@@ skipping 303 matching lines @@
     dict->insertString("n6", "A String");
     ASSERT_EMIT_EQ(reporter, *dict, "<</n1 24\n/n2 99\n/n3 0.5\n/n4 /AName\n"
                    "/n5 /AnotherName\n/n6 (A String)>>");
 
     dict->insertString("n7", SkString("Another String"));
     ASSERT_EMIT_EQ(reporter, *dict, "<</n1 24\n/n2 99\n/n3 0.5\n/n4 /AName\n"
                    "/n5 /AnotherName\n/n6 (A String)\n/n7 (Another String)>>");
 
     dict.reset(new SkPDFDict("DType"));
     ASSERT_EMIT_EQ(reporter, *dict, "<</Type /DType>>");
-    
+
     SkAutoTUnref<SkPDFArray> referencedArray(new SkPDFArray);
     Catalog catalog;
     catalog.numbers.addObject(referencedArray.get());
     REPORTER_ASSERT(reporter, catalog.numbers.getObjectNumber(
                             referencedArray.get()) == 1);
     dict->insertObjRef("n1", referencedArray.detach());
     SkString result = emit_to_string(*dict, &catalog);
     ASSERT_EQ(reporter, result, "<</Type /DType\n/n1 1 0 R>>");
 }
 
@@ skipping 73 matching lines @@
     SkAutoTUnref<SkTypeface> noEmbedTypeface(GetResourceAsTypeface(resource));
     if (noEmbedTypeface) {
         REPORTER_ASSERT(reporter,
                         !SkPDFFont::CanEmbedTypeface(noEmbedTypeface, &canon));
     }
     SkAutoTUnref<SkTypeface> portableTypeface(
             sk_tool_utils::create_portable_typeface(NULL, SkTypeface::kNormal));
     REPORTER_ASSERT(reporter,
                     SkPDFFont::CanEmbedTypeface(portableTypeface, &canon));
 }
+
+
+// test to see that all finite scalars round trip via scanf().
+static void check_pdf_scalar_serialization(skiatest::Reporter* reporter,
+                                           float inputFloat) {
+    SkDynamicMemoryWStream buffer;
+    SkPDFUtils::AppendScalar(inputFloat, &buffer);
+    char floatString[2048];
+    if (buffer.bytesWritten() >= sizeof(floatString)) {
+        ERRORF(reporter, "absurdly long output.");
+        return;
+    }
+    buffer.copyTo(floatString);
+    floatString[buffer.bytesWritten()] = '\0';
+    if (reporter->verbose()) {
+        SkDebugf("%.9g = \"%s\"\n", inputFloat, floatString);
+    }
+    float roundTripFloat;
+    if (1 != sscanf(floatString, "%f", &roundTripFloat)) {
+        ERRORF(reporter, "unscannable result");
+        return;
+    }
+    if (isfinite(inputFloat)) {
+        REPORTER_ASSERT(reporter, roundTripFloat == inputFloat);
+    }
+}
+
+// Test SkPDFUtils::AppendScalar for accuracy.
+DEF_TEST(PDFPrimitives_Scalar, reporter) {
+    const int kRandomSeed = 0xBEEF;
+    int iterationCount = 500;
+    SkRandom random(kRandomSeed);
+    while (iterationCount-- > 0) {
+        union {
+            float inputFloat;
+            uint32_t u;
+        };
+        static_assert(sizeof(float) == sizeof(uint32_t), "");
+        u = random.nextU();  // Pick any random float.
+        check_pdf_scalar_serialization(reporter, inputFloat);
+    }
+    float alwaysCheck[] = { 0.0f, -0.0f, 1.0f, -1.0f, FLT_MIN, FLT_MAX,
+                            -FLT_MIN, -FLT_MAX, SK_FloatInfinity,
+                            SK_FloatNegativeInfinity, SK_FloatNaN, SK_ScalarPI,
+                            static_cast<float>(1.0 / 10.0)};
+    for (float inputFloat: alwaysCheck) {
+        check_pdf_scalar_serialization(reporter, inputFloat);
+    }
+}