Use DEFINE_TESTCLASS_SHORT macro in tests.

tests/MathTest.cpp

-
 /*
  * Copyright 2011 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 "TestClassDef.h"
+#include "SkColorPriv.h"
+#include "SkEndian.h"
 #include "SkFloatBits.h"
 #include "SkFloatingPoint.h"
 #include "SkMathPriv.h"
 #include "SkPoint.h"
 #include "SkRandom.h"
-#include "SkColorPriv.h"
 
 static void test_clz(skiatest::Reporter* reporter) {
     REPORTER_ASSERT(reporter, 32 == SkCLZ(0));
     REPORTER_ASSERT(reporter, 31 == SkCLZ(1));
     REPORTER_ASSERT(reporter, 1 == SkCLZ(1 << 30));
     REPORTER_ASSERT(reporter, 0 == SkCLZ(~0U));
 
     SkRandom rand;
     for (int i = 0; i < 1000; ++i) {
         uint32_t mask = rand.nextU();
@@ skipping 398 matching lines @@
         REPORTER_ASSERT(reporter, SkCopySign32(-ix, -ix) == -ix);
 
         SkScalar sx = rand.nextSScalar1();
         REPORTER_ASSERT(reporter, SkScalarCopySign(sx, sx) == sx);
         REPORTER_ASSERT(reporter, SkScalarCopySign(sx, -sx) == -sx);
         REPORTER_ASSERT(reporter, SkScalarCopySign(-sx, sx) == sx);
         REPORTER_ASSERT(reporter, SkScalarCopySign(-sx, -sx) == -sx);
     }
 }
 
-static void TestMath(skiatest::Reporter* reporter) {
+DEF_TEST(Math, reporter) {
     int         i;
     int32_t     x;
     SkRandom    rand;
 
     // these should assert
 #if 0
     SkToS8(128);
     SkToS8(-129);
     SkToU8(256);
     SkToU8(-5);
@@ skipping 195 matching lines @@
 
     if (false) test_floor(reporter);
 
     // disable for now
     if (false) test_blend31();  // avoid bit rot, suppress warning
 
     test_muldivround(reporter);
     test_clz(reporter);
 }
 
-#include "TestClassDef.h"
-DEFINE_TESTCLASS("Math", MathTestClass, TestMath)
-
-///////////////////////////////////////////////////////////////////////////////
-
-#include "SkEndian.h"
-
 template <typename T> struct PairRec {
     T   fYin;
     T   fYang;
 };
 
-static void TestEndian(skiatest::Reporter* reporter) {
+DEF_TEST(TestEndian, reporter) {
     static const PairRec<uint16_t> g16[] = {
         { 0x0,      0x0     },
         { 0xFFFF,   0xFFFF  },
         { 0x1122,   0x2211  },
     };
     static const PairRec<uint32_t> g32[] = {
         { 0x0,          0x0         },
         { 0xFFFFFFFF,   0xFFFFFFFF  },
         { 0x11223344,   0x44332211  },
     };
@@ skipping 11 matching lines @@
         REPORTER_ASSERT(reporter, g16[i].fYang == SkEndianSwap16(g16[i].fYin));
     }
     for (size_t i = 0; i < SK_ARRAY_COUNT(g32); ++i) {
         REPORTER_ASSERT(reporter, g32[i].fYang == SkEndianSwap32(g32[i].fYin));
     }
     for (size_t i = 0; i < SK_ARRAY_COUNT(g64); ++i) {
         REPORTER_ASSERT(reporter, g64[i].fYang == SkEndianSwap64(g64[i].fYin));
     }
 }
 
-DEFINE_TESTCLASS("Endian", EndianTestClass, TestEndian)
-
 template <typename T>
 static void test_divmod(skiatest::Reporter* r) {
     const struct {
         T numer;
         T denom;
     } kEdgeCases[] = {
         {(T)17, (T)17},
         {(T)17, (T)4},
         {(T)0,  (T)17},
         // For unsigned T these negatives are just some large numbers.  Doesn't hurt to test them.
@@ skipping 50 matching lines @@
     test_divmod<int16_t>(r);
 }
 
 DEF_TEST(divmod_s32, r) {
     test_divmod<int32_t>(r);
 }
 
 DEF_TEST(divmod_s64, r) {
     test_divmod<int64_t>(r);
 }