Subzero: Use a "known" version of clang-format.

crosstest/test_cast_main.cpp

Index: crosstest/test_cast_main.cpp
diff --git a/crosstest/test_cast_main.cpp b/crosstest/test_cast_main.cpp
index fd50011aff1b34d1f42e8b96e82bc2e6846f9c02..dbd93aa61471e9f8ede34c46d58080ee80592b6f 100644
--- a/crosstest/test_cast_main.cpp
+++ b/crosstest/test_cast_main.cpp
@@ -115,66 +115,62 @@ int main(int argc, char **argv) {
   size_t Passes = 0;
   size_t Failures = 0;
 
-  volatile bool ValsUi1[] = { false, true };
+  volatile bool ValsUi1[] = {false, true};
   static const size_t NumValsUi1 = sizeof(ValsUi1) / sizeof(*ValsUi1);
-  volatile uint8_t ValsUi8[] = { 0, 1, 0x7e, 0x7f, 0x80, 0x81, 0xfe, 0xff };
+  volatile uint8_t ValsUi8[] = {0, 1, 0x7e, 0x7f, 0x80, 0x81, 0xfe, 0xff};
   static const size_t NumValsUi8 = sizeof(ValsUi8) / sizeof(*ValsUi8);
 
-  volatile myint8_t ValsSi8[] = { 0, 1, 0x7e, 0x7f, 0x80, 0x81, 0xfe, 0xff };
+  volatile myint8_t ValsSi8[] = {0, 1, 0x7e, 0x7f, 0x80, 0x81, 0xfe, 0xff};
   static const size_t NumValsSi8 = sizeof(ValsSi8) / sizeof(*ValsSi8);
 
-  volatile uint16_t ValsUi16[] = { 0,      1,      0x7e,   0x7f,   0x80,
-                                   0x81,   0xfe,   0xff,   0x7ffe, 0x7fff,
-                                   0x8000, 0x8001, 0xfffe, 0xffff };
+  volatile uint16_t ValsUi16[] = {0,      1,      0x7e,   0x7f,   0x80,
+                                  0x81,   0xfe,   0xff,   0x7ffe, 0x7fff,
+                                  0x8000, 0x8001, 0xfffe, 0xffff};
   static const size_t NumValsUi16 = sizeof(ValsUi16) / sizeof(*ValsUi16);
 
-  volatile int16_t ValsSi16[] = { 0,      1,      0x7e,   0x7f,   0x80,
-                                  0x81,   0xfe,   0xff,   0x7ffe, 0x7fff,
-                                  0x8000, 0x8001, 0xfffe, 0xffff };
+  volatile int16_t ValsSi16[] = {0,      1,      0x7e,   0x7f,   0x80,
+                                 0x81,   0xfe,   0xff,   0x7ffe, 0x7fff,
+                                 0x8000, 0x8001, 0xfffe, 0xffff};
   static const size_t NumValsSi16 = sizeof(ValsSi16) / sizeof(*ValsSi16);
 
-  volatile size_t ValsUi32[] = {
-    0,          1,          0x7e,       0x7f,       0x80,
-    0x81,       0xfe,       0xff,       0x7ffe,     0x7fff,
-    0x8000,     0x8001,     0xfffe,     0xffff,     0x7ffffffe,
-    0x7fffffff, 0x80000000, 0x80000001, 0xfffffffe, 0xffffffff
-  };
+  volatile size_t ValsUi32[] = {0,          1,          0x7e,       0x7f,
+                                0x80,       0x81,       0xfe,       0xff,
+                                0x7ffe,     0x7fff,     0x8000,     0x8001,
+                                0xfffe,     0xffff,     0x7ffffffe, 0x7fffffff,
+                                0x80000000, 0x80000001, 0xfffffffe, 0xffffffff};
   static const size_t NumValsUi32 = sizeof(ValsUi32) / sizeof(*ValsUi32);
 
-  volatile size_t ValsSi32[] = {
-    0,          1,          0x7e,       0x7f,       0x80,
-    0x81,       0xfe,       0xff,       0x7ffe,     0x7fff,
-    0x8000,     0x8001,     0xfffe,     0xffff,     0x7ffffffe,
-    0x7fffffff, 0x80000000, 0x80000001, 0xfffffffe, 0xffffffff
-  };
+  volatile size_t ValsSi32[] = {0,          1,          0x7e,       0x7f,
+                                0x80,       0x81,       0xfe,       0xff,
+                                0x7ffe,     0x7fff,     0x8000,     0x8001,
+                                0xfffe,     0xffff,     0x7ffffffe, 0x7fffffff,
+                                0x80000000, 0x80000001, 0xfffffffe, 0xffffffff};
   static const size_t NumValsSi32 = sizeof(ValsSi32) / sizeof(*ValsSi32);
 
   volatile uint64_t ValsUi64[] = {
-    0,                     1,                     0x7e,
-    0x7f,                  0x80,                  0x81,
-    0xfe,                  0xff,                  0x7ffe,
-    0x7fff,                0x8000,                0x8001,
-    0xfffe,                0xffff,                0x7ffffffe,
-    0x7fffffff,            0x80000000,            0x80000001,
-    0xfffffffe,            0xffffffff,            0x100000000ull,
-    0x100000001ull,        0x7ffffffffffffffeull, 0x7fffffffffffffffull,
-    0x8000000000000000ull, 0x8000000000000001ull, 0xfffffffffffffffeull,
-    0xffffffffffffffffull
-  };
+      0,                     1,                     0x7e,
+      0x7f,                  0x80,                  0x81,
+      0xfe,                  0xff,                  0x7ffe,
+      0x7fff,                0x8000,                0x8001,
+      0xfffe,                0xffff,                0x7ffffffe,
+      0x7fffffff,            0x80000000,            0x80000001,
+      0xfffffffe,            0xffffffff,            0x100000000ull,
+      0x100000001ull,        0x7ffffffffffffffeull, 0x7fffffffffffffffull,
+      0x8000000000000000ull, 0x8000000000000001ull, 0xfffffffffffffffeull,
+      0xffffffffffffffffull};
   static const size_t NumValsUi64 = sizeof(ValsUi64) / sizeof(*ValsUi64);
 
   volatile int64_t ValsSi64[] = {
-    0,                    1,                    0x7e,
-    0x7f,                 0x80,                 0x81,
-    0xfe,                 0xff,                 0x7ffe,
-    0x7fff,               0x8000,               0x8001,
-    0xfffe,               0xffff,               0x7ffffffe,
-    0x7fffffff,           0x80000000,           0x80000001,
-    0xfffffffe,           0xffffffff,           0x100000000ll,
-    0x100000001ll,        0x7ffffffffffffffell, 0x7fffffffffffffffll,
-    0x8000000000000000ll, 0x8000000000000001ll, 0xfffffffffffffffell,
-    0xffffffffffffffffll
-  };
+      0,                    1,                    0x7e,
+      0x7f,                 0x80,                 0x81,
+      0xfe,                 0xff,                 0x7ffe,
+      0x7fff,               0x8000,               0x8001,
+      0xfffe,               0xffff,               0x7ffffffe,
+      0x7fffffff,           0x80000000,           0x80000001,
+      0xfffffffe,           0xffffffff,           0x100000000ll,
+      0x100000001ll,        0x7ffffffffffffffell, 0x7fffffffffffffffll,
+      0x8000000000000000ll, 0x8000000000000001ll, 0xfffffffffffffffell,
+      0xffffffffffffffffll};
   static const size_t NumValsSi64 = sizeof(ValsSi64) / sizeof(*ValsSi64);
 
   static const double NegInf = -1.0 / 0.0;