Programmatically apply new formatting to code

Run this:

for i in  **/*.cc **/*.c **/*.h **/*.hh; do
  clang-format < $i >| $i.new && mv $i.new $i
done

1 files changed, 60 insertions, 52 deletions

diff --git a/libtests/json.cc b/libtests/json.cc
index a8c72a3b..17a5d574 100644
--- a/libtests/json.cc
+++ b/libtests/json.cc
@@ -8,32 +8,34 @@
 #endif
 #include <cassert>
 
-static void check(JSON const& j, std::string const& exp)
+static void
+check(JSON const& j, std::string const& exp)
 {
-    if (exp != j.unparse())
-    {
+    if (exp != j.unparse()) {
         std::cout << "Got " << j.unparse() << "; wanted " << exp << "\n";
     }
 }
 
-static void test_main()
+static void
+test_main()
 {
     JSON jstr = JSON::makeString(
         "<1>\xcf\x80<2>\xf0\x9f\xa5\x94\\\"<3>\x03\t\b\r\n<4>");
-    check(jstr,
-          "\"<1>\xcf\x80<2>\xf0\x9f\xa5\x94\\\\\\\"<3>"
-          "\\u0003\\t\\b\\r\\n<4>\"");
+    check(
+        jstr,
+        "\"<1>\xcf\x80<2>\xf0\x9f\xa5\x94\\\\\\\"<3>"
+        "\\u0003\\t\\b\\r\\n<4>\"");
     JSON jnull = JSON::makeNull();
     check(jnull, "null");
     assert(jnull.isNull());
     std::string value;
-    assert(! jnull.getNumber(value));
+    assert(!jnull.getNumber(value));
     JSON jarr = JSON::makeArray();
     check(jarr, "[]");
     JSON jstr2 = JSON::makeString("a\tb");
     assert(jstr2.getString(value));
     assert(value == "a\tb");
-    assert(! jstr2.getNumber(value));
+    assert(!jstr2.getNumber(value));
     /* cSpell: ignore jbool xavalue dvalue xdvalue */
     JSON jint = JSON::makeInt(16059);
     JSON jdouble = JSON::makeReal(3.14159);
@@ -44,24 +46,24 @@ static void test_main()
     assert(jbool1.getBool(bvalue));
     assert(bvalue);
     assert(jbool2.getBool(bvalue));
-    assert(! bvalue);
+    assert(!bvalue);
     jarr.addArrayElement(jstr2);
     jarr.addArrayElement(jnull);
     jarr.addArrayElement(jint);
     jarr.addArrayElement(jdouble);
     jarr.addArrayElement(jexp);
-    check(jarr,
-          "[\n"
-          "  \"a\\tb\",\n"
-          "  null,\n"
-          "  16059,\n"
-          "  3.14159,\n"
-          "  2.1e5\n"
-          "]");
+    check(
+        jarr,
+        "[\n"
+        "  \"a\\tb\",\n"
+        "  null,\n"
+        "  16059,\n"
+        "  3.14159,\n"
+        "  2.1e5\n"
+        "]");
     std::vector<std::string> avalue;
-    assert(jarr.forEachArrayItem([&avalue](JSON j) {
-        avalue.push_back(j.unparse());
-    }));
+    assert(jarr.forEachArrayItem(
+        [&avalue](JSON j) { avalue.push_back(j.unparse()); }));
     std::vector<std::string> xavalue = {
         "\"a\\tb\"",
         "null",
@@ -79,37 +81,36 @@ static void test_main()
     jmap.addDictionaryMember("no", JSON::makeBool(true));
     jmap.addDictionaryMember("empty_dict", JSON::makeDictionary());
     jmap.addDictionaryMember("empty_list", JSON::makeArray());
-    jmap.addDictionaryMember("single", JSON::makeArray()).
-        addArrayElement(JSON::makeInt(12));
-    check(jmap,
-          "{\n"
-          "  \"a\": [\n"
-          "    \"a\\tb\",\n"
-          "    null,\n"
-          "    16059,\n"
-          "    3.14159,\n"
-          "    2.1e5\n"
-          "  ],\n"
-          "  \"b\": \"a\\tb\",\n"
-          "  \"c\\r\\nd\": null,\n"
-          "  \"empty_dict\": {},\n"
-          "  \"empty_list\": [],\n"
-          "  \"no\": true,\n"
-          "  \"single\": [\n"
-          "    12\n"
-          "  ],\n"
-          "  \"yes\": false\n"
-          "}");
+    jmap.addDictionaryMember("single", JSON::makeArray())
+        .addArrayElement(JSON::makeInt(12));
+    check(
+        jmap,
+        "{\n"
+        "  \"a\": [\n"
+        "    \"a\\tb\",\n"
+        "    null,\n"
+        "    16059,\n"
+        "    3.14159,\n"
+        "    2.1e5\n"
+        "  ],\n"
+        "  \"b\": \"a\\tb\",\n"
+        "  \"c\\r\\nd\": null,\n"
+        "  \"empty_dict\": {},\n"
+        "  \"empty_list\": [],\n"
+        "  \"no\": true,\n"
+        "  \"single\": [\n"
+        "    12\n"
+        "  ],\n"
+        "  \"yes\": false\n"
+        "}");
     check(QPDFObjectHandle::newReal("0.12").getJSON(), "0.12");
     check(QPDFObjectHandle::newReal(".34").getJSON(), "0.34");
     check(QPDFObjectHandle::newReal("-0.56").getJSON(), "-0.56");
     check(QPDFObjectHandle::newReal("-.78").getJSON(), "-0.78");
     JSON jmap2 = JSON::parse(R"({"a": 1, "b": "two", "c": [true]})");
     std::map<std::string, std::string> dvalue;
-    assert(jmap2.forEachDictItem([&dvalue]
-                                 (std::string const& k, JSON j) {
-        dvalue[k] = j.unparse();
-    }));
+    assert(jmap2.forEachDictItem(
+        [&dvalue](std::string const& k, JSON j) { dvalue[k] = j.unparse(); }));
     std::map<std::string, std::string> xdvalue = {
         {"a", "1"},
         {"b", "\"two\""},
@@ -118,21 +119,27 @@ static void test_main()
     assert(dvalue == xdvalue);
 }
 
-static void check_schema(JSON& obj, JSON& schema, unsigned long flags,
-                         bool exp, std::string const& description)
+static void
+check_schema(
+    JSON& obj,
+    JSON& schema,
+    unsigned long flags,
+    bool exp,
+    std::string const& description)
 {
     std::list<std::string> errors;
     std::cout << "--- " << description << std::endl;
     assert(exp == obj.checkSchema(schema, flags, errors));
     for (std::list<std::string>::iterator iter = errors.begin();
-         iter != errors.end(); ++iter)
-    {
+         iter != errors.end();
+         ++iter) {
         std::cout << *iter << std::endl;
     }
     std::cout << "---" << std::endl;
 }
 
-static void test_schema()
+static void
+test_schema()
 {
     /* cSpell: ignore ptional ebra */
     JSON schema = JSON::parse(R"(
@@ -249,7 +256,8 @@ static void test_schema()
     check_schema(good, schema, JSON::f_optional, true, "pass");
 }
 
-int main()
+int
+main()
 {
     test_main();
     test_schema();