remove unused parts of SkTypes.h

Lots of completely unused bits and bobs removed.

I've decided SK_SUPPORT_UNITTEST and its single use are not
very compelling.

tests/CPlusPlusEleven was the only user of Sk32ToBool(),
and no longer generally needed.

Change-Id: I3ee75560f1e1e1cf5ad89ee7df8d7694b5dffdb3
Reviewed-on: https://skia-review.googlesource.com/133622
Commit-Queue: Mike Klein <mtklein@google.com>
Reviewed-by: Mike Klein <mtklein@google.com>

9 files changed, 5 insertions, 487 deletions

diff --git a/gn/tests.gni b/gn/tests.gni
index a2f52c9ab3..409d2317b4 100644
--- a/gn/tests.gni
+++ b/gn/tests.gni
@@ -45,7 +45,6 @@ tests_sources = [
   "$_tests/ColorSpaceTest.cpp",
   "$_tests/ColorTest.cpp",
   "$_tests/CopySurfaceTest.cpp",
-  "$_tests/CPlusPlusEleven.cpp",
   "$_tests/CTest.cpp",
   "$_tests/DashPathEffectTest.cpp",
   "$_tests/DataRefTest.cpp",
diff --git a/include/config/SkUserConfig.h b/include/config/SkUserConfig.h
index 055cd4d1d1..a6497ca0ed 100644
--- a/include/config/SkUserConfig.h
+++ b/include/config/SkUserConfig.h
@@ -100,14 +100,6 @@
  */
 //#define SK_MAX_SIZE_FOR_LCDTEXT     48
 
-/*  If SK_DEBUG is defined, then you can optionally define SK_SUPPORT_UNITTEST
-    which will run additional self-tests at startup. These can take a long time,
-    so this flag is optional.
- */
-#ifdef SK_DEBUG
-//#define SK_SUPPORT_UNITTEST
-#endif
-
 /*  Change the ordering to work in X windows.
  */
 #ifdef SK_SAMPLES_FOR_X
diff --git a/include/core/SkPostConfig.h b/include/core/SkPostConfig.h
index ccf6e8a2ed..b2aa0f402f 100644
--- a/include/core/SkPostConfig.h
+++ b/include/core/SkPostConfig.h
@@ -24,10 +24,6 @@
 #  error "must define either SK_DEBUG or SK_RELEASE"
 #endif
 
-#if defined(SK_SUPPORT_UNITTEST) && !defined(SK_DEBUG)
-#  error "can't have unittests without debug"
-#endif
-
 /**
  * Matrix calculations may be float or double.
  * The default is float, as that's what Chromium's using.
@@ -73,14 +69,6 @@
 #  endif
 #endif
 
-#if defined(_MSC_VER) && SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE2
-    #define SK_VECTORCALL __vectorcall
-#elif defined(SK_CPU_ARM32) && defined(SK_ARM_HAS_NEON)
-    #define SK_VECTORCALL __attribute__((pcs("aapcs-vfp")))
-#else
-    #define SK_VECTORCALL
-#endif
-
 #if !defined(SK_SUPPORT_GPU)
 #  define SK_SUPPORT_GPU 1
 #endif
@@ -204,44 +192,11 @@
 //////////////////////////////////////////////////////////////////////////////////////////////
 
 #if defined SK_DEBUG && defined SK_BUILD_FOR_WIN
-#  ifdef free
-#    undef free
-#  endif
-#  include <crtdbg.h>
-#  undef free
-#
-#  ifdef SK_DEBUGx
-#    if defined(SK_SIMULATE_FAILED_MALLOC) && defined(__cplusplus)
-       void * operator new(
-           size_t cb,
-           int nBlockUse,
-           const char * szFileName,
-           int nLine,
-           int foo
-           );
-       void * operator new[](
-           size_t cb,
-           int nBlockUse,
-           const char * szFileName,
-           int nLine,
-           int foo
-           );
-       void operator delete(
-           void *pUserData,
-           int, const char*, int, int
-           );
-       void operator delete(
-           void *pUserData
-           );
-       void operator delete[]( void * p );
-#      define DEBUG_CLIENTBLOCK   new( _CLIENT_BLOCK, __FILE__, __LINE__, 0)
-#    else
-#      define DEBUG_CLIENTBLOCK   new( _CLIENT_BLOCK, __FILE__, __LINE__)
-#    endif
-#    define new DEBUG_CLIENTBLOCK
-#  else
-#    define DEBUG_CLIENTBLOCK
-#  endif
+    #ifdef free
+        #undef free
+    #endif
+    #include <crtdbg.h>
+    #undef free
 #endif
 
 //////////////////////////////////////////////////////////////////////
@@ -326,16 +281,6 @@
 
 //////////////////////////////////////////////////////////////////////
 
-#ifndef SK_EGL
-#  if defined(SK_BUILD_FOR_ANDROID)
-#    define SK_EGL 1
-#  else
-#    define SK_EGL 0
-#  endif
-#endif
-
-//////////////////////////////////////////////////////////////////////
-
 #if !defined(SK_GAMMA_EXPONENT)
     #define SK_GAMMA_EXPONENT (0.0f)  // SRGB
 #endif
diff --git a/include/core/SkPreConfig.h b/include/core/SkPreConfig.h
index da91a17400..11d541d87c 100644
--- a/include/core/SkPreConfig.h
+++ b/include/core/SkPreConfig.h
@@ -225,48 +225,4 @@
     #endif
 #endif
 
-//////////////////////////////////////////////////////////////////////
-
-/**
- * Use SK_PURE_FUNC as an attribute to indicate that a function's
- * return value only depends on the value of its parameters. This
- * can help the compiler optimize out successive calls.
- *
- * Usage:
- *      void  function(int params)  SK_PURE_FUNC;
- */
-#if defined(__GNUC__)
-#  define  SK_PURE_FUNC  __attribute__((pure))
-#else
-#  define  SK_PURE_FUNC  /* nothing */
-#endif
-
-//////////////////////////////////////////////////////////////////////
-
-/**
- * SK_HAS_ATTRIBUTE(<name>) should return true iff the compiler
- * supports __attribute__((<name>)). Mostly important because
- * Clang doesn't support all of GCC attributes.
- */
-#if defined(__has_attribute)
-#   define SK_HAS_ATTRIBUTE(x) __has_attribute(x)
-#elif defined(__GNUC__)
-#   define SK_HAS_ATTRIBUTE(x) 1
-#else
-#   define SK_HAS_ATTRIBUTE(x) 0
-#endif
-
-/**
- * SK_ATTRIBUTE_OPTIMIZE_O1 can be used as a function attribute
- * to specify individual optimization level of -O1, if the compiler
- * supports it.
- *
- * NOTE: Clang/ARM (r161757) does not support the 'optimize' attribute.
- */
-#if SK_HAS_ATTRIBUTE(optimize)
-#   define SK_ATTRIBUTE_OPTIMIZE_O1 __attribute__((optimize("O1")))
-#else
-#   define SK_ATTRIBUTE_OPTIMIZE_O1 /* nothing */
-#endif
-
 #endif
diff --git a/include/core/SkTypes.h b/include/core/SkTypes.h
index 0185a6845d..06e101efbf 100644
--- a/include/core/SkTypes.h
+++ b/include/core/SkTypes.h
@@ -127,12 +127,6 @@ class SkString;
 ///////////////////////////////////////////////////////////////////////
 
 /**
- *  Fast type for signed 8 bits. Use for parameter passing and local variables,
- *  not for storage.
- */
-typedef int S8CPU;
-
-/**
  *  Fast type for unsigned 8 bits. Use for parameter passing and local
  *  variables, not for storage
  */
@@ -220,9 +214,6 @@ template <typename T, size_t N> char (&SkArrayCountHelper(T (&array)[N]))[N];
 #define SkAlign8(x)     (((x) + 7) >> 3 << 3)
 #define SkIsAlign8(x)   (0 == ((x) & 7))
 
-#define SkAlign16(x)     (((x) + 15) >> 4 << 4)
-#define SkIsAlign16(x)   (0 == ((x) & 15))
-
 #define SkAlignPtr(x)   (sizeof(void*) == 8 ?   SkAlign8(x) :   SkAlign4(x))
 #define SkIsAlignPtr(x) (sizeof(void*) == 8 ? SkIsAlign8(x) : SkIsAlign4(x))
 
@@ -241,18 +232,9 @@ typedef uint16_t SkGlyphID;
  *  Note that SK_MSecMax is about 25 days.
  */
 typedef uint32_t SkMSec;
-/** 1 second measured in milliseconds
-*/
-#define SK_MSec1 1000
 /** maximum representable milliseconds; 24d 20h 31m 23.647s.
 */
 #define SK_MSecMax 0x7FFFFFFF
-/** Returns a < b for milliseconds, correctly handling wrap-around from 0xFFFFFFFF to 0
-*/
-#define SkMSec_LT(a, b)     ((int32_t)(a) - (int32_t)(b) < 0)
-/** Returns a <= b for milliseconds, correctly handling wrap-around from 0xFFFFFFFF to 0
-*/
-#define SkMSec_LE(a, b)     ((int32_t)(a) - (int32_t)(b) <= 0)
 
 /** The generation IDs in Skia reserve 0 has an invalid marker.
  */
@@ -266,12 +248,6 @@ typedef uint32_t SkMSec;
 */
 #ifdef __cplusplus
 
-/** Faster than SkToBool for integral conditions. Returns 0 or 1
-*/
-static inline constexpr int Sk32ToBool(uint32_t n) {
-    return (n | (0-n)) >> 31;
-}
-
 /** Generic swap function. Classes with efficient swaps should specialize this function to take
     their fast path. This function is used by SkTSort. */
 template <typename T> static inline void SkTSwap(T& a, T& b) {
@@ -315,10 +291,6 @@ template <typename T> constexpr const T& SkTMax(const T& a, const T& b) {
     return (b < a) ? a : b;
 }
 
-static inline int32_t SkSign32(int32_t a) {
-    return (a >> 31) | ((unsigned) -a >> 31);
-}
-
 static inline int32_t SkFastMin32(int32_t value, int32_t max) {
     if (value > max) {
         value = max;
@@ -353,13 +325,6 @@ enum class SkBackingFit {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-/** Use to combine multiple bits in a bitmask in a type safe way.
- */
-template <typename T>
-T SkTBitOr(T a, T b) {
-    return (T)(a | b);
-}
-
 /**
  *  Use to cast a pointer to a different type, and maintaining strict-aliasing
  */
diff --git a/include/utils/SkParse.h b/include/utils/SkParse.h
index 411605f7a9..6260175ea5 100644
--- a/include/utils/SkParse.h
+++ b/include/utils/SkParse.h
@@ -27,10 +27,6 @@ public:
     static bool FindBool(const char str[], bool* value);
     // return the index of str in list[], or -1 if not found
     static int  FindList(const char str[], const char list[]);
-#ifdef SK_SUPPORT_UNITTEST
-    static void TestColor();
-    static void UnitTest();
-#endif
 };
 
 #endif
diff --git a/src/utils/SkParse.cpp b/src/utils/SkParse.cpp
index 90c9fffe41..a533447809 100644
--- a/src/utils/SkParse.cpp
+++ b/src/utils/SkParse.cpp
@@ -286,11 +286,3 @@ int SkParse::FindList(const char target[], const char list[])
     }
     return -1;
 }
-
-#ifdef SK_SUPPORT_UNITTEST
-void SkParse::UnitTest()
-{
-    // !!! additional parse tests go here
-    SkParse::TestColor();
-}
-#endif
diff --git a/src/utils/SkParseColor.cpp b/src/utils/SkParseColor.cpp
index eafdc4c3d1..4c9bd3d217 100644
--- a/src/utils/SkParseColor.cpp
+++ b/src/utils/SkParseColor.cpp
@@ -8,220 +8,6 @@
 
 #include "SkParse.h"
 
-#ifdef SK_DEBUG
-#include "SkString.h"
-
-#ifdef SK_SUPPORT_UNITTEST
-    // compress names 6 chars per long (packed 5 bits/char )
-        // note: little advantage to splitting chars across longs, since 3 longs at 2 unused bits each
-        // allow for one additional split char (vs. the 18 unsplit chars in the three longs)
-    // use extra two bits to represent:
-        // 00 : final 6 (or fewer) chars (if 'a' is 0x01, zero could have special meaning)
-        // 01 : not final 6 chars
-        // 10 : color
-        // 11 : unused, except as debugging sentinal? (could be -1 for easier test)
-    // !!! the bit to end the word (last) is at the low bit for binary search
-    // lookup first character in offset for quick start
-        // offset is 27-entry table of bytes(?) that trims linear search to at most 21 entries ('d')
-    // shift match into long; set bit 30 if it all doesn't fit
-    // while longs don't match, march forward
-        // if they do match, and bit 30 is set, advance match, clearing bit 30 if
-        // final chars, and advance to next test
-        // if they do match, and bit 30 is clear, get next long (color) and return it
-    // stop at lookup of first char + 1
-static const struct SkNameRGB {
-    const char* name;
-    int rgb;
-} colorNames[] = {
-    { "aliceblue",            0xF0F8FF },
-    { "antiquewhite",         0xFAEBD7 },
-    { "aqua",                 0x00FFFF },
-    { "aquamarine",           0x7FFFD4 },
-    { "azure",                0xF0FFFF },
-    { "beige",                0xF5F5DC },
-    { "bisque",               0xFFE4C4 },
-    { "black",                0x000000 },
-    { "blanchedalmond",       0xFFEBCD },
-    { "blue",                 0x0000FF },
-    { "blueviolet",           0x8A2BE2 },
-    { "brown",                0xA52A2A },
-    { "burlywood",            0xDEB887 },
-    { "cadetblue",            0x5F9EA0 },
-    { "chartreuse",           0x7FFF00 },
-    { "chocolate",            0xD2691E },
-    { "coral",                0xFF7F50 },
-    { "cornflowerblue",       0x6495ED },
-    { "cornsilk",             0xFFF8DC },
-    { "crimson",              0xDC143C },
-    { "cyan",                 0x00FFFF },
-    { "darkblue",             0x00008B },
-    { "darkcyan",             0x008B8B },
-    { "darkgoldenrod",        0xB8860B },
-    { "darkgray",             0xA9A9A9 },
-    { "darkgreen",            0x006400 },
-    { "darkkhaki",            0xBDB76B },
-    { "darkmagenta",          0x8B008B },
-    { "darkolivegreen",       0x556B2F },
-    { "darkorange",           0xFF8C00 },
-    { "darkorchid",           0x9932CC },
-    { "darkred",              0x8B0000 },
-    { "darksalmon",           0xE9967A },
-    { "darkseagreen",         0x8FBC8F },
-    { "darkslateblue",        0x483D8B },
-    { "darkslategray",        0x2F4F4F },
-    { "darkturquoise",        0x00CED1 },
-    { "darkviolet",           0x9400D3 },
-    { "deeppink",             0xFF1493 },
-    { "deepskyblue",          0x00BFFF },
-    { "dimgray",              0x696969 },
-    { "dodgerblue",           0x1E90FF },
-    { "firebrick",            0xB22222 },
-    { "floralwhite",          0xFFFAF0 },
-    { "forestgreen",          0x228B22 },
-    { "fuchsia",              0xFF00FF },
-    { "gainsboro",            0xDCDCDC },
-    { "ghostwhite",           0xF8F8FF },
-    { "gold",                 0xFFD700 },
-    { "goldenrod",            0xDAA520 },
-    { "gray",                 0x808080 },
-    { "green",                0x008000 },
-    { "greenyellow",          0xADFF2F },
-    { "honeydew",             0xF0FFF0 },
-    { "hotpink",              0xFF69B4 },
-    { "indianred",            0xCD5C5C },
-    { "indigo",               0x4B0082 },
-    { "ivory",                0xFFFFF0 },
-    { "khaki",                0xF0E68C },
-    { "lavender",             0xE6E6FA },
-    { "lavenderblush",        0xFFF0F5 },
-    { "lawngreen",            0x7CFC00 },
-    { "lemonchiffon",         0xFFFACD },
-    { "lightblue",            0xADD8E6 },
-    { "lightcoral",           0xF08080 },
-    { "lightcyan",            0xE0FFFF },
-    { "lightgoldenrodyellow", 0xFAFAD2 },
-    { "lightgreen",           0x90EE90 },
-    { "lightgrey",            0xD3D3D3 },
-    { "lightpink",            0xFFB6C1 },
-    { "lightsalmon",          0xFFA07A },
-    { "lightseagreen",        0x20B2AA },
-    { "lightskyblue",         0x87CEFA },
-    { "lightslategray",       0x778899 },
-    { "lightsteelblue",       0xB0C4DE },
-    { "lightyellow",          0xFFFFE0 },
-    { "lime",                 0x00FF00 },
-    { "limegreen",            0x32CD32 },
-    { "linen",                0xFAF0E6 },
-    { "magenta",              0xFF00FF },
-    { "maroon",               0x800000 },
-    { "mediumaquamarine",     0x66CDAA },
-    { "mediumblue",           0x0000CD },
-    { "mediumorchid",         0xBA55D3 },
-    { "mediumpurple",         0x9370DB },
-    { "mediumseagreen",       0x3CB371 },
-    { "mediumslateblue",      0x7B68EE },
-    { "mediumspringgreen",    0x00FA9A },
-    { "mediumturquoise",      0x48D1CC },
-    { "mediumvioletred",      0xC71585 },
-    { "midnightblue",         0x191970 },
-    { "mintcream",            0xF5FFFA },
-    { "mistyrose",            0xFFE4E1 },
-    { "moccasin",             0xFFE4B5 },
-    { "navajowhite",          0xFFDEAD },
-    { "navy",                 0x000080 },
-    { "oldlace",              0xFDF5E6 },
-    { "olive",                0x808000 },
-    { "olivedrab",            0x6B8E23 },
-    { "orange",               0xFFA500 },
-    { "orangered",            0xFF4500 },
-    { "orchid",               0xDA70D6 },
-    { "palegoldenrod",        0xEEE8AA },
-    { "palegreen",            0x98FB98 },
-    { "paleturquoise",        0xAFEEEE },
-    { "palevioletred",        0xDB7093 },
-    { "papayawhip",           0xFFEFD5 },
-    { "peachpuff",            0xFFDAB9 },
-    { "peru",                 0xCD853F },
-    { "pink",                 0xFFC0CB },
-    { "plum",                 0xDDA0DD },
-    { "powderblue",           0xB0E0E6 },
-    { "purple",               0x800080 },
-    { "red",                  0xFF0000 },
-    { "rosybrown",            0xBC8F8F },
-    { "royalblue",            0x4169E1 },
-    { "saddlebrown",          0x8B4513 },
-    { "salmon",               0xFA8072 },
-    { "sandybrown",           0xF4A460 },
-    { "seagreen",             0x2E8B57 },
-    { "seashell",             0xFFF5EE },
-    { "sienna",               0xA0522D },
-    { "silver",               0xC0C0C0 },
-    { "skyblue",              0x87CEEB },
-    { "slateblue",            0x6A5ACD },
-    { "slategray",            0x708090 },
-    { "snow",                 0xFFFAFA },
-    { "springgreen",          0x00FF7F },
-    { "steelblue",            0x4682B4 },
-    { "tan",                  0xD2B48C },
-    { "teal",                 0x008080 },
-    { "thistle",              0xD8BFD8 },
-    { "tomato",               0xFF6347 },
-    { "turquoise",            0x40E0D0 },
-    { "violet",               0xEE82EE },
-    { "wheat",                0xF5DEB3 },
-    { "white",                0xFFFFFF },
-    { "whitesmoke",           0xF5F5F5 },
-    { "yellow",               0xFFFF00 },
-    { "yellowgreen",          0x9ACD32 }
-};
-
-int colorNamesSize = SK_ARRAY_COUNT(colorNames);
-
-static void CreateTable() {
-    SkString comment;
-    size_t originalSize = 0;
-    int replacement = 0;
-    for (int index = 0; index < colorNamesSize; index++) {
-        SkNameRGB nameRGB =  colorNames[index];
-        const char* name = nameRGB.name;
-        size_t len = strlen(name);
-        originalSize += len + 9;
-        bool first = true;
-        bool last = false;
-        do {
-            int compressed = 0;
-            const char* start = name;
-            for (int chIndex = 0; chIndex < 6; chIndex++) {
-                compressed <<= 5;
-                compressed |= *name ? *name++ - 'a' + 1 : 0 ;
-            }
-            replacement += sizeof(int);
-            compressed <<= 1;
-            compressed |= 1;
-            if (first) {
-                compressed |= 0x80000000;
-                first = false;
-            }
-            if (len <= 6) { // last
-                compressed &= ~1;
-                last = true;
-            }
-            len -= 6;
-            SkDebugf("0x%08x, ", compressed);
-            comment.append(start, name - start);
-        } while (last == false);
-        replacement += sizeof(int);
-        SkDebugf("0x%08x, ", nameRGB.rgb);
-        SkDebugf("// %s\n", comment.c_str());
-        comment.reset();
-    }
-    SkDebugf("// original = %d : replacement = %d\n", originalSize, replacement);
-    SkASSERT(0); // always stop after creating table
-}
-#endif
-
-#endif
-
 static const unsigned int gColorNames[] = {
 0x85891945, 0x32a50000, 0x00f0f8ff, // aliceblue
 0x85d44c6b, 0x16e84d0a, 0x00faebd7, // antiquewhite
@@ -492,47 +278,3 @@ const char* SkParse::FindColor(const char* value, SkColor* colorPtr) {
     } else
         return FindNamedColor(value, strlen(value), colorPtr);
 }
-
-#ifdef SK_SUPPORT_UNITTEST
-void SkParse::TestColor() {
-    if (false)
-        CreateTable();  // regenerates data table in the output window
-    SkColor result;
-    int index;
-    for (index = 0; index < colorNamesSize; index++) {
-        result = SK_ColorBLACK;
-        SkNameRGB nameRGB = colorNames[index];
-        SkASSERT(FindColor(nameRGB.name, &result) != nullptr);
-        SkASSERT(result == (SkColor) (nameRGB.rgb | 0xFF000000));
-    }
-    for (index = 0; index < colorNamesSize; index++) {
-        result = SK_ColorBLACK;
-        SkNameRGB nameRGB = colorNames[index];
-        char bad[24];
-        size_t len = strlen(nameRGB.name);
-        memcpy(bad, nameRGB.name, len);
-        bad[len - 1] -= 1;
-        SkASSERT(FindColor(bad, &result) == nullptr);
-        bad[len - 1] += 2;
-        SkASSERT(FindColor(bad, &result) == nullptr);
-    }
-    result = SK_ColorBLACK;
-    SkASSERT(FindColor("lightGrey", &result));
-    SkASSERT(result == 0xffd3d3d3);
-//  SkASSERT(FindColor("12,34,56,78", &result));
-//  SkASSERT(result == ((12 << 24) | (34 << 16) | (56 << 8) | (78 << 0)));
-    result = SK_ColorBLACK;
-    SkASSERT(FindColor("#ABCdef", &result));
-    SkASSERT(result == 0XFFABCdef);
-    SkASSERT(FindColor("#12ABCdef", &result));
-    SkASSERT(result == 0X12ABCdef);
-    result = SK_ColorBLACK;
-    SkASSERT(FindColor("#123", &result));
-    SkASSERT(result == 0Xff112233);
-    SkASSERT(FindColor("#abcd", &result));
-    SkASSERT(result == 0Xaabbccdd);
-    result = SK_ColorBLACK;
-//  SkASSERT(FindColor("71,162,253", &result));
-//  SkASSERT(result == ((0xFF << 24) | (71 << 16) | (162 << 8) | (253 << 0)));
-}
-#endif
diff --git a/tests/CPlusPlusEleven.cpp b/tests/CPlusPlusEleven.cpp
deleted file mode 100644
index fb3e765f1c..0000000000
--- a/tests/CPlusPlusEleven.cpp
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * Copyright 2015 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#include "SkScopeExit.h"
-#include "SkTypes.h"
-#include "Test.h"
-
-#include <utility>
-
-namespace {
-class Moveable {
-public:
-    Moveable() {}
-    Moveable(Moveable&&) {}
-    Moveable& operator=(Moveable&&) { return *this; }
-private:
-    Moveable(const Moveable&);
-    Moveable& operator=(const Moveable&);
-};
-template <typename T> void deleter(T*) { }
-template <typename T> struct Deleter {
-    void operator()(T* t) { delete static_cast<const Moveable*>(t); }
-};
-} // namespace
-
-DEF_TEST(CPlusPlusEleven_RvalueAndMove, r) {
-    Moveable src1; Moveable dst1(std::move(src1));
-    Moveable src2, dst2; dst2 = std::move(src2);
-}
-
-DEF_TEST(CPlusPlusEleven_constexpr, r) {
-    static constexpr int x = Sk32ToBool(50);
-    REPORTER_ASSERT(r, x == 1);
-    static constexpr int y = SkTPin<int>(100, 0, 10);
-    REPORTER_ASSERT(r, y == 10);
-}
-
-namespace {
-struct MoveableCopyable {
-    bool fCopied;
-    MoveableCopyable() : fCopied(false) {}
-    MoveableCopyable(const MoveableCopyable &o) : fCopied(true) {}
-    MoveableCopyable(MoveableCopyable &&o) : fCopied(o.fCopied) {}
-};
-struct TestClass {
-    MoveableCopyable fFoo;
-};
-}  // namespace
-
-DEF_TEST(CPlusPlusEleven_default_move, r) {
-    TestClass a;
-    TestClass b(a);
-    TestClass c(std::move(a));
-    REPORTER_ASSERT(r, b.fFoo.fCopied);
-    REPORTER_ASSERT(r, !c.fFoo.fCopied);
-}
-
-DEF_TEST(SkAtScopeExit, r) {
-    int x = 5;
-    {
-        SK_AT_SCOPE_EXIT(x--);
-        REPORTER_ASSERT(r, x == 5);
-    }
-    REPORTER_ASSERT(r, x == 4);
-}