diff --git a/src/jsontestrunner/main.cpp b/src/jsontestrunner/main.cpp
index 81805c2..18e6ef1 100644
--- a/src/jsontestrunner/main.cpp
+++ b/src/jsontestrunner/main.cpp
@@ -6,296 +6,266 @@
 /* This executable is used for testing parser/writer using real JSON files.
  */
 
-
 #include <json/json.h>
 #include <algorithm> // sort
 #include <stdio.h>
 
-#if defined(_MSC_VER)  &&  _MSC_VER >= 1310
-# pragma warning( disable: 4996 )     // disable fopen deprecation warning
+#if defined(_MSC_VER) && _MSC_VER >= 1310
+#pragma warning(disable : 4996) // disable fopen deprecation warning
 #endif
 
-static std::string 
-normalizeFloatingPointStr( double value )
-{
-    char buffer[32];
+static std::string normalizeFloatingPointStr(double value) {
+  char buffer[32];
 #if defined(_MSC_VER) && defined(__STDC_SECURE_LIB__)
-    sprintf_s( buffer, sizeof(buffer), "%.16g", value );
+  sprintf_s(buffer, sizeof(buffer), "%.16g", value);
 #else
-    snprintf( buffer, sizeof(buffer), "%.16g", value );
+  snprintf(buffer, sizeof(buffer), "%.16g", value);
 #endif
-    buffer[sizeof(buffer)-1] = 0;
-    std::string s( buffer );
-    std::string::size_type index = s.find_last_of( "eE" );
-    if ( index != std::string::npos )
+  buffer[sizeof(buffer) - 1] = 0;
+  std::string s(buffer);
+  std::string::size_type index = s.find_last_of("eE");
+  if (index != std::string::npos) {
+    std::string::size_type hasSign =
+        (s[index + 1] == '+' || s[index + 1] == '-') ? 1 : 0;
+    std::string::size_type exponentStartIndex = index + 1 + hasSign;
+    std::string normalized = s.substr(0, exponentStartIndex);
+    std::string::size_type indexDigit =
+        s.find_first_not_of('0', exponentStartIndex);
+    std::string exponent = "0";
+    if (indexDigit !=
+        std::string::npos) // There is an exponent different from 0
     {
-        std::string::size_type hasSign = (s[index+1] == '+' || s[index+1] == '-') ? 1 : 0;
-        std::string::size_type exponentStartIndex = index + 1 + hasSign;
-        std::string normalized = s.substr( 0, exponentStartIndex );
-        std::string::size_type indexDigit = s.find_first_not_of( '0', exponentStartIndex );
-        std::string exponent = "0";
-        if ( indexDigit != std::string::npos ) // There is an exponent different from 0
-        {
-            exponent = s.substr( indexDigit );
-        }
-        return normalized + exponent;
+      exponent = s.substr(indexDigit);
     }
-    return s;
+    return normalized + exponent;
+  }
+  return s;
 }
 
-
-static std::string
-readInputTestFile( const char *path )
-{
-   FILE *file = fopen( path, "rb" );
-   if ( !file )
-      return std::string("");
-   fseek( file, 0, SEEK_END );
-   long size = ftell( file );
-   fseek( file, 0, SEEK_SET );
-   std::string text;
-   char *buffer = new char[size+1];
-   buffer[size] = 0;
-   if ( fread( buffer, 1, size, file ) == (unsigned long)size )
-      text = buffer;
-   fclose( file );
-   delete[] buffer;
-   return text;
+static std::string readInputTestFile(const char *path) {
+  FILE *file = fopen(path, "rb");
+  if (!file)
+    return std::string("");
+  fseek(file, 0, SEEK_END);
+  long size = ftell(file);
+  fseek(file, 0, SEEK_SET);
+  std::string text;
+  char *buffer = new char[size + 1];
+  buffer[size] = 0;
+  if (fread(buffer, 1, size, file) == (unsigned long)size)
+    text = buffer;
+  fclose(file);
+  delete[] buffer;
+  return text;
 }
 
 static void
-printValueTree( FILE *fout, Json::Value &value, const std::string &path = "." )
-{
-   switch ( value.type() )
-   {
-   case Json::nullValue:
-      fprintf( fout, "%s=null\n", path.c_str() );
-      break;
-   case Json::intValue:
-      fprintf( fout, "%s=%s\n", path.c_str(), Json::valueToString( value.asLargestInt() ).c_str() );
-      break;
-   case Json::uintValue:
-      fprintf( fout, "%s=%s\n", path.c_str(), Json::valueToString( value.asLargestUInt() ).c_str() );
-      break;
-   case Json::realValue:
-       fprintf( fout, "%s=%s\n", path.c_str(), normalizeFloatingPointStr(value.asDouble()).c_str() );
-      break;
-   case Json::stringValue:
-      fprintf( fout, "%s=\"%s\"\n", path.c_str(), value.asString().c_str() );
-      break;
-   case Json::booleanValue:
-      fprintf( fout, "%s=%s\n", path.c_str(), value.asBool() ? "true" : "false" );
-      break;
-   case Json::arrayValue:
-      {
-         fprintf( fout, "%s=[]\n", path.c_str() );
-         int size = value.size();
-         for ( int index =0; index < size; ++index )
-         {
-            static char buffer[16];
+printValueTree(FILE *fout, Json::Value &value, const std::string &path = ".") {
+  switch (value.type()) {
+  case Json::nullValue:
+    fprintf(fout, "%s=null\n", path.c_str());
+    break;
+  case Json::intValue:
+    fprintf(fout,
+            "%s=%s\n",
+            path.c_str(),
+            Json::valueToString(value.asLargestInt()).c_str());
+    break;
+  case Json::uintValue:
+    fprintf(fout,
+            "%s=%s\n",
+            path.c_str(),
+            Json::valueToString(value.asLargestUInt()).c_str());
+    break;
+  case Json::realValue:
+    fprintf(fout,
+            "%s=%s\n",
+            path.c_str(),
+            normalizeFloatingPointStr(value.asDouble()).c_str());
+    break;
+  case Json::stringValue:
+    fprintf(fout, "%s=\"%s\"\n", path.c_str(), value.asString().c_str());
+    break;
+  case Json::booleanValue:
+    fprintf(fout, "%s=%s\n", path.c_str(), value.asBool() ? "true" : "false");
+    break;
+  case Json::arrayValue: {
+    fprintf(fout, "%s=[]\n", path.c_str());
+    int size = value.size();
+    for (int index = 0; index < size; ++index) {
+      static char buffer[16];
 #if defined(_MSC_VER) && defined(__STDC_SECURE_LIB__)
-            sprintf_s( buffer, sizeof(buffer), "[%d]", index );
+      sprintf_s(buffer, sizeof(buffer), "[%d]", index);
 #else
-            snprintf( buffer, sizeof(buffer), "[%d]", index );
+      snprintf(buffer, sizeof(buffer), "[%d]", index);
 #endif
-            printValueTree( fout, value[index], path + buffer );
-         }
-      }
-      break;
-   case Json::objectValue:
-      {
-         fprintf( fout, "%s={}\n", path.c_str() );
-         Json::Value::Members members( value.getMemberNames() );
-         std::sort( members.begin(), members.end() );
-         std::string suffix = *(path.end()-1) == '.' ? "" : ".";
-         for ( Json::Value::Members::iterator it = members.begin(); 
-               it != members.end(); 
-               ++it )
-         {
-            const std::string &name = *it;
-            printValueTree( fout, value[name], path + suffix + name );
-         }
-      }
-      break;
-   default:
-      break;
-   }
+      printValueTree(fout, value[index], path + buffer);
+    }
+  } break;
+  case Json::objectValue: {
+    fprintf(fout, "%s={}\n", path.c_str());
+    Json::Value::Members members(value.getMemberNames());
+    std::sort(members.begin(), members.end());
+    std::string suffix = *(path.end() - 1) == '.' ? "" : ".";
+    for (Json::Value::Members::iterator it = members.begin();
+         it != members.end();
+         ++it) {
+      const std::string &name = *it;
+      printValueTree(fout, value[name], path + suffix + name);
+    }
+  } break;
+  default:
+    break;
+  }
 }
 
+static int parseAndSaveValueTree(const std::string &input,
+                                 const std::string &actual,
+                                 const std::string &kind,
+                                 Json::Value &root,
+                                 const Json::Features &features,
+                                 bool parseOnly) {
+  Json::Reader reader(features);
+  bool parsingSuccessful = reader.parse(input, root);
+  if (!parsingSuccessful) {
+    printf("Failed to parse %s file: \n%s\n",
+           kind.c_str(),
+           reader.getFormattedErrorMessages().c_str());
+    return 1;
+  }
 
-static int
-parseAndSaveValueTree( const std::string &input, 
-                       const std::string &actual,
-                       const std::string &kind,
-                       Json::Value &root,
-                       const Json::Features &features,
-                       bool parseOnly )
-{
-   Json::Reader reader( features );
-   bool parsingSuccessful = reader.parse( input, root );
-   if ( !parsingSuccessful )
-   {
-      printf( "Failed to parse %s file: \n%s\n", 
-              kind.c_str(),
-              reader.getFormattedErrorMessages().c_str() );
-      return 1;
-   }
-
-   if ( !parseOnly )
-   {
-      FILE *factual = fopen( actual.c_str(), "wt" );
-      if ( !factual )
-      {
-         printf( "Failed to create %s actual file.\n", kind.c_str() );
-         return 2;
-      }
-      printValueTree( factual, root );
-      fclose( factual );
-   }
-   return 0;
-}
-
-
-static int
-rewriteValueTree( const std::string &rewritePath, 
-                  const Json::Value &root, 
-                  std::string &rewrite )
-{
-   //Json::FastWriter writer;
-   //writer.enableYAMLCompatibility();
-   Json::StyledWriter writer;
-   rewrite = writer.write( root );
-   FILE *fout = fopen( rewritePath.c_str(), "wt" );
-   if ( !fout )
-   {
-      printf( "Failed to create rewrite file: %s\n", rewritePath.c_str() );
+  if (!parseOnly) {
+    FILE *factual = fopen(actual.c_str(), "wt");
+    if (!factual) {
+      printf("Failed to create %s actual file.\n", kind.c_str());
       return 2;
-   }
-   fprintf( fout, "%s\n", rewrite.c_str() );
-   fclose( fout );
-   return 0;
+    }
+    printValueTree(factual, root);
+    fclose(factual);
+  }
+  return 0;
 }
 
-
-static std::string
-removeSuffix( const std::string &path, 
-              const std::string &extension )
-{
-   if ( extension.length() >= path.length() )
-      return std::string("");
-   std::string suffix = path.substr( path.length() - extension.length() );
-   if ( suffix != extension )
-      return std::string("");
-   return path.substr( 0, path.length() - extension.length() );
+static int rewriteValueTree(const std::string &rewritePath,
+                            const Json::Value &root,
+                            std::string &rewrite) {
+  // Json::FastWriter writer;
+  // writer.enableYAMLCompatibility();
+  Json::StyledWriter writer;
+  rewrite = writer.write(root);
+  FILE *fout = fopen(rewritePath.c_str(), "wt");
+  if (!fout) {
+    printf("Failed to create rewrite file: %s\n", rewritePath.c_str());
+    return 2;
+  }
+  fprintf(fout, "%s\n", rewrite.c_str());
+  fclose(fout);
+  return 0;
 }
 
+static std::string removeSuffix(const std::string &path,
+                                const std::string &extension) {
+  if (extension.length() >= path.length())
+    return std::string("");
+  std::string suffix = path.substr(path.length() - extension.length());
+  if (suffix != extension)
+    return std::string("");
+  return path.substr(0, path.length() - extension.length());
+}
 
-static void
-printConfig()
-{
-   // Print the configuration used to compile JsonCpp
+static void printConfig() {
+// Print the configuration used to compile JsonCpp
 #if defined(JSON_NO_INT64)
-   printf( "JSON_NO_INT64=1\n" );
+  printf("JSON_NO_INT64=1\n");
 #else
-   printf( "JSON_NO_INT64=0\n" );
+  printf("JSON_NO_INT64=0\n");
 #endif
 }
 
-
-static int 
-printUsage( const char *argv[] )
-{
-   printf( "Usage: %s [--strict] input-json-file", argv[0] );
-   return 3;
+static int printUsage(const char *argv[]) {
+  printf("Usage: %s [--strict] input-json-file", argv[0]);
+  return 3;
 }
 
+int parseCommandLine(int argc,
+                     const char *argv[],
+                     Json::Features &features,
+                     std::string &path,
+                     bool &parseOnly) {
+  parseOnly = false;
+  if (argc < 2) {
+    return printUsage(argv);
+  }
 
-int
-parseCommandLine( int argc, const char *argv[], 
-                  Json::Features &features, std::string &path,
-                  bool &parseOnly )
-{
-   parseOnly = false;
-   if ( argc < 2 )
-   {
-      return printUsage( argv );
-   }
+  int index = 1;
+  if (std::string(argv[1]) == "--json-checker") {
+    features = Json::Features::strictMode();
+    parseOnly = true;
+    ++index;
+  }
 
-   int index = 1;
-   if ( std::string(argv[1]) == "--json-checker" )
-   {
-      features = Json::Features::strictMode();
-      parseOnly = true;
-      ++index;
-   }
+  if (std::string(argv[1]) == "--json-config") {
+    printConfig();
+    return 3;
+  }
 
-   if ( std::string(argv[1]) == "--json-config" )
-   {
-      printConfig();
+  if (index == argc || index + 1 < argc) {
+    return printUsage(argv);
+  }
+
+  path = argv[index];
+  return 0;
+}
+
+int main(int argc, const char *argv[]) {
+  std::string path;
+  Json::Features features;
+  bool parseOnly;
+  int exitCode = parseCommandLine(argc, argv, features, path, parseOnly);
+  if (exitCode != 0) {
+    return exitCode;
+  }
+
+  try {
+    std::string input = readInputTestFile(path.c_str());
+    if (input.empty()) {
+      printf("Failed to read input or empty input: %s\n", path.c_str());
       return 3;
-   }
+    }
 
-   if ( index == argc  ||  index + 1 < argc )
-   {
-      return printUsage( argv );
-   }
+    std::string basePath = removeSuffix(argv[1], ".json");
+    if (!parseOnly && basePath.empty()) {
+      printf("Bad input path. Path does not end with '.expected':\n%s\n",
+             path.c_str());
+      return 3;
+    }
 
-   path = argv[index];
-   return 0;
-}
+    std::string actualPath = basePath + ".actual";
+    std::string rewritePath = basePath + ".rewrite";
+    std::string rewriteActualPath = basePath + ".actual-rewrite";
 
-
-int main( int argc, const char *argv[] )
-{
-   std::string path;
-   Json::Features features;
-   bool parseOnly;
-   int exitCode = parseCommandLine( argc, argv, features, path, parseOnly );
-   if ( exitCode != 0 )
-   {
-      return exitCode;
-   }
-
-   try
-   {
-      std::string input = readInputTestFile( path.c_str() );
-      if ( input.empty() )
-      {
-         printf( "Failed to read input or empty input: %s\n", path.c_str() );
-         return 3;
+    Json::Value root;
+    exitCode = parseAndSaveValueTree(
+        input, actualPath, "input", root, features, parseOnly);
+    if (exitCode == 0 && !parseOnly) {
+      std::string rewrite;
+      exitCode = rewriteValueTree(rewritePath, root, rewrite);
+      if (exitCode == 0) {
+        Json::Value rewriteRoot;
+        exitCode = parseAndSaveValueTree(rewrite,
+                                         rewriteActualPath,
+                                         "rewrite",
+                                         rewriteRoot,
+                                         features,
+                                         parseOnly);
       }
+    }
+  }
+  catch (const std::exception &e) {
+    printf("Unhandled exception:\n%s\n", e.what());
+    exitCode = 1;
+  }
 
-      std::string basePath = removeSuffix( argv[1], ".json" );
-      if ( !parseOnly  &&  basePath.empty() )
-      {
-         printf( "Bad input path. Path does not end with '.expected':\n%s\n", path.c_str() );
-         return 3;
-      }
-
-      std::string actualPath = basePath + ".actual";
-      std::string rewritePath = basePath + ".rewrite";
-      std::string rewriteActualPath = basePath + ".actual-rewrite";
-
-      Json::Value root;
-      exitCode = parseAndSaveValueTree( input, actualPath, "input", root, features, parseOnly );
-      if ( exitCode == 0  &&  !parseOnly )
-      {
-         std::string rewrite;
-         exitCode = rewriteValueTree( rewritePath, root, rewrite );
-         if ( exitCode == 0 )
-         {
-            Json::Value rewriteRoot;
-            exitCode = parseAndSaveValueTree( rewrite, rewriteActualPath, 
-               "rewrite", rewriteRoot, features, parseOnly );
-         }
-      }
-   }
-   catch ( const std::exception &e )
-   {
-      printf( "Unhandled exception:\n%s\n", e.what() );
-      exitCode = 1;
-   }
-
-   return exitCode;
+  return exitCode;
 }
 // vim: et ts=4 sts=4 sw=4 tw=0
diff --git a/src/lib_json/json_batchallocator.h b/src/lib_json/json_batchallocator.h
index 92f1843..7e7ad82 100644
--- a/src/lib_json/json_batchallocator.h
+++ b/src/lib_json/json_batchallocator.h
@@ -4,12 +4,12 @@
 // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
 
 #ifndef JSONCPP_BATCHALLOCATOR_H_INCLUDED
-# define JSONCPP_BATCHALLOCATOR_H_INCLUDED
+#define JSONCPP_BATCHALLOCATOR_H_INCLUDED
 
-# include <stdlib.h>
-# include <assert.h>
+#include <stdlib.h>
+#include <assert.h>
 
-# ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
+#ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
 
 namespace Json {
 
@@ -18,111 +18,108 @@
  * This memory allocator allocates memory for a batch of object (specified by
  * the page size, the number of object in each page).
  *
- * It does not allow the destruction of a single object. All the allocated objects
- * can be destroyed at once. The memory can be either released or reused for future
+ * It does not allow the destruction of a single object. All the allocated
+ *objects
+ * can be destroyed at once. The memory can be either released or reused for
+ *future
  * allocation.
- * 
- * The in-place new operator must be used to construct the object using the pointer
+ *
+ * The in-place new operator must be used to construct the object using the
+ *pointer
  * returned by allocate.
  */
-template<typename AllocatedType
-        ,const unsigned int objectPerAllocation>
-class BatchAllocator
-{
+template <typename AllocatedType, const unsigned int objectPerAllocation>
+class BatchAllocator {
 public:
-   BatchAllocator( unsigned int objectsPerPage = 255 )
-      : freeHead_( 0 )
-      , objectsPerPage_( objectsPerPage )
-   {
-//      printf( "Size: %d => %s\n", sizeof(AllocatedType), typeid(AllocatedType).name() );
-      assert( sizeof(AllocatedType) * objectPerAllocation >= sizeof(AllocatedType *) ); // We must be able to store a slist in the object free space.
-      assert( objectsPerPage >= 16 );
-      batches_ = allocateBatch( 0 );   // allocated a dummy page
-      currentBatch_ = batches_;
-   }
+  BatchAllocator(unsigned int objectsPerPage = 255)
+      : freeHead_(0), objectsPerPage_(objectsPerPage) {
+    //      printf( "Size: %d => %s\n", sizeof(AllocatedType),
+    // typeid(AllocatedType).name() );
+    assert(sizeof(AllocatedType) * objectPerAllocation >=
+           sizeof(AllocatedType *)); // We must be able to store a slist in the
+                                     // object free space.
+    assert(objectsPerPage >= 16);
+    batches_ = allocateBatch(0); // allocated a dummy page
+    currentBatch_ = batches_;
+  }
 
-   ~BatchAllocator()
-   {
-      for ( BatchInfo *batch = batches_; batch;  )
+  ~BatchAllocator() {
+    for (BatchInfo *batch = batches_; batch;) {
+      BatchInfo *nextBatch = batch->next_;
+      free(batch);
+      batch = nextBatch;
+    }
+  }
+
+  /// allocate space for an array of objectPerAllocation object.
+  /// @warning it is the responsability of the caller to call objects
+  /// constructors.
+  AllocatedType *allocate() {
+    if (freeHead_) // returns node from free list.
+    {
+      AllocatedType *object = freeHead_;
+      freeHead_ = *(AllocatedType **)object;
+      return object;
+    }
+    if (currentBatch_->used_ == currentBatch_->end_) {
+      currentBatch_ = currentBatch_->next_;
+      while (currentBatch_ && currentBatch_->used_ == currentBatch_->end_)
+        currentBatch_ = currentBatch_->next_;
+
+      if (!currentBatch_) // no free batch found, allocate a new one
       {
-         BatchInfo *nextBatch = batch->next_;
-         free( batch );
-         batch = nextBatch;
+        currentBatch_ = allocateBatch(objectsPerPage_);
+        currentBatch_->next_ = batches_; // insert at the head of the list
+        batches_ = currentBatch_;
       }
-   }
+    }
+    AllocatedType *allocated = currentBatch_->used_;
+    currentBatch_->used_ += objectPerAllocation;
+    return allocated;
+  }
 
-   /// allocate space for an array of objectPerAllocation object.
-   /// @warning it is the responsability of the caller to call objects constructors.
-   AllocatedType *allocate()
-   {
-      if ( freeHead_ ) // returns node from free list.
-      {
-         AllocatedType *object = freeHead_;
-         freeHead_ = *(AllocatedType **)object;
-         return object;
-      }
-      if ( currentBatch_->used_ == currentBatch_->end_ )
-      {
-         currentBatch_ = currentBatch_->next_;
-         while ( currentBatch_  &&  currentBatch_->used_ == currentBatch_->end_ )
-            currentBatch_ = currentBatch_->next_;
-
-         if ( !currentBatch_  ) // no free batch found, allocate a new one
-         { 
-            currentBatch_ = allocateBatch( objectsPerPage_ );
-            currentBatch_->next_ = batches_; // insert at the head of the list
-            batches_ = currentBatch_;
-         }
-      }
-      AllocatedType *allocated = currentBatch_->used_;
-      currentBatch_->used_ += objectPerAllocation;
-      return allocated;
-   }
-
-   /// Release the object.
-   /// @warning it is the responsability of the caller to actually destruct the object.
-   void release( AllocatedType *object )
-   {
-      assert( object != 0 );
-      *(AllocatedType **)object = freeHead_;
-      freeHead_ = object;
-   }
+  /// Release the object.
+  /// @warning it is the responsability of the caller to actually destruct the
+  /// object.
+  void release(AllocatedType *object) {
+    assert(object != 0);
+    *(AllocatedType **)object = freeHead_;
+    freeHead_ = object;
+  }
 
 private:
-   struct BatchInfo
-   {
-      BatchInfo *next_;
-      AllocatedType *used_;
-      AllocatedType *end_;
-      AllocatedType buffer_[objectPerAllocation];
-   };
+  struct BatchInfo {
+    BatchInfo *next_;
+    AllocatedType *used_;
+    AllocatedType *end_;
+    AllocatedType buffer_[objectPerAllocation];
+  };
 
-   // disabled copy constructor and assignement operator.
-   BatchAllocator( const BatchAllocator & );
-   void operator =( const BatchAllocator &);
+  // disabled copy constructor and assignement operator.
+  BatchAllocator(const BatchAllocator &);
+  void operator=(const BatchAllocator &);
 
-   static BatchInfo *allocateBatch( unsigned int objectsPerPage )
-   {
-      const unsigned int mallocSize = sizeof(BatchInfo) - sizeof(AllocatedType)* objectPerAllocation
-                                + sizeof(AllocatedType) * objectPerAllocation * objectsPerPage;
-      BatchInfo *batch = static_cast<BatchInfo*>( malloc( mallocSize ) );
-      batch->next_ = 0;
-      batch->used_ = batch->buffer_;
-      batch->end_ = batch->buffer_ + objectsPerPage;
-      return batch;
-   }
+  static BatchInfo *allocateBatch(unsigned int objectsPerPage) {
+    const unsigned int mallocSize =
+        sizeof(BatchInfo) - sizeof(AllocatedType) * objectPerAllocation +
+        sizeof(AllocatedType) * objectPerAllocation * objectsPerPage;
+    BatchInfo *batch = static_cast<BatchInfo *>(malloc(mallocSize));
+    batch->next_ = 0;
+    batch->used_ = batch->buffer_;
+    batch->end_ = batch->buffer_ + objectsPerPage;
+    return batch;
+  }
 
-   BatchInfo *batches_;
-   BatchInfo *currentBatch_;
-   /// Head of a single linked list within the allocated space of freeed object
-   AllocatedType *freeHead_;
-   unsigned int objectsPerPage_;
+  BatchInfo *batches_;
+  BatchInfo *currentBatch_;
+  /// Head of a single linked list within the allocated space of freeed object
+  AllocatedType *freeHead_;
+  unsigned int objectsPerPage_;
 };
 
-
 } // namespace Json
 
-# endif // ifndef JSONCPP_DOC_INCLUDE_IMPLEMENTATION
+#endif // ifndef JSONCPP_DOC_INCLUDE_IMPLEMENTATION
 
 #endif // JSONCPP_BATCHALLOCATOR_H_INCLUDED
 // vim: et ts=3 sts=3 sw=3 tw=0
diff --git a/src/lib_json/json_reader.cpp b/src/lib_json/json_reader.cpp
index 8fd2f4c..3d0d328 100644
--- a/src/lib_json/json_reader.cpp
+++ b/src/lib_json/json_reader.cpp
@@ -4,10 +4,10 @@
 // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
 
 #if !defined(JSON_IS_AMALGAMATION)
-# include <json/assertions.h>
-# include <json/reader.h>
-# include <json/value.h>
-# include "json_tool.h"
+#include <json/assertions.h>
+#include <json/reader.h>
+#include <json/value.h>
+#include "json_tool.h"
 #endif // if !defined(JSON_IS_AMALGAMATION)
 #include <utility>
 #include <cstdio>
@@ -15,8 +15,9 @@
 #include <cstring>
 #include <istream>
 
-#if defined(_MSC_VER)  &&  _MSC_VER >= 1400 // VC++ 8.0
-#pragma warning( disable : 4996 )   // disable warning about strdup being deprecated.
+#if defined(_MSC_VER) && _MSC_VER >= 1400 // VC++ 8.0
+#pragma warning(disable                                                        \
+                : 4996) // disable warning about strdup being deprecated.
 #endif
 
 namespace Json {
@@ -25,997 +26,816 @@
 // ////////////////////////////////
 
 Features::Features()
-   : allowComments_( true )
-   , strictRoot_( false )
-   , allowDroppedNullPlaceholders_ ( false )
-   , allowNumericKeys_ ( false )
-{
-}
+    : allowComments_(true), strictRoot_(false),
+      allowDroppedNullPlaceholders_(false), allowNumericKeys_(false) {}
 
+Features Features::all() { return Features(); }
 
-Features 
-Features::all()
-{
-   return Features();
-}
-
-
-Features 
-Features::strictMode()
-{
-   Features features;
-   features.allowComments_ = false;
-   features.strictRoot_ = true;
-   features.allowDroppedNullPlaceholders_ = false;
-   features.allowNumericKeys_ = false;
-   return features;
+Features Features::strictMode() {
+  Features features;
+  features.allowComments_ = false;
+  features.strictRoot_ = true;
+  features.allowDroppedNullPlaceholders_ = false;
+  features.allowNumericKeys_ = false;
+  return features;
 }
 
 // Implementation of class Reader
 // ////////////////////////////////
 
-
-static inline bool 
-in( Reader::Char c, Reader::Char c1, Reader::Char c2, Reader::Char c3, Reader::Char c4 )
-{
-   return c == c1  ||  c == c2  ||  c == c3  ||  c == c4;
+static inline bool in(Reader::Char c,
+                      Reader::Char c1,
+                      Reader::Char c2,
+                      Reader::Char c3,
+                      Reader::Char c4) {
+  return c == c1 || c == c2 || c == c3 || c == c4;
 }
 
-static inline bool 
-in( Reader::Char c, Reader::Char c1, Reader::Char c2, Reader::Char c3, Reader::Char c4, Reader::Char c5 )
-{
-   return c == c1  ||  c == c2  ||  c == c3  ||  c == c4  ||  c == c5;
+static inline bool in(Reader::Char c,
+                      Reader::Char c1,
+                      Reader::Char c2,
+                      Reader::Char c3,
+                      Reader::Char c4,
+                      Reader::Char c5) {
+  return c == c1 || c == c2 || c == c3 || c == c4 || c == c5;
 }
 
-
-static bool 
-containsNewLine( Reader::Location begin, 
-                 Reader::Location end )
-{
-   for ( ;begin < end; ++begin )
-      if ( *begin == '\n'  ||  *begin == '\r' )
-         return true;
-   return false;
+static bool containsNewLine(Reader::Location begin, Reader::Location end) {
+  for (; begin < end; ++begin)
+    if (*begin == '\n' || *begin == '\r')
+      return true;
+  return false;
 }
 
-
 // Class Reader
 // //////////////////////////////////////////////////////////////////
 
 Reader::Reader()
-    : errors_(),
-      document_(),
-      begin_(),
-      end_(),
-      current_(),
-      lastValueEnd_(),
-      lastValue_(),
-      commentsBefore_(),
-      features_( Features::all() ),
-      collectComments_()
-{
+    : errors_(), document_(), begin_(), end_(), current_(), lastValueEnd_(),
+      lastValue_(), commentsBefore_(), features_(Features::all()),
+      collectComments_() {}
+
+Reader::Reader(const Features &features)
+    : errors_(), document_(), begin_(), end_(), current_(), lastValueEnd_(),
+      lastValue_(), commentsBefore_(), features_(features), collectComments_() {
 }
 
-
-Reader::Reader( const Features &features )
-    : errors_(),
-      document_(),
-      begin_(),
-      end_(),
-      current_(),
-      lastValueEnd_(),
-      lastValue_(),
-      commentsBefore_(),
-      features_( features ),
-      collectComments_()
-{
-}
-
-
 bool
-Reader::parse( const std::string &document, 
-               Value &root,
-               bool collectComments )
-{
-   document_ = document;
-   const char *begin = document_.c_str();
-   const char *end = begin + document_.length();
-   return parse( begin, end, root, collectComments );
+Reader::parse(const std::string &document, Value &root, bool collectComments) {
+  document_ = document;
+  const char *begin = document_.c_str();
+  const char *end = begin + document_.length();
+  return parse(begin, end, root, collectComments);
 }
 
+bool Reader::parse(std::istream &sin, Value &root, bool collectComments) {
+  // std::istream_iterator<char> begin(sin);
+  // std::istream_iterator<char> end;
+  // Those would allow streamed input from a file, if parse() were a
+  // template function.
 
-bool
-Reader::parse( std::istream& sin,
-               Value &root,
-               bool collectComments )
-{
-   //std::istream_iterator<char> begin(sin);
-   //std::istream_iterator<char> end;
-   // Those would allow streamed input from a file, if parse() were a
-   // template function.
-
-   // Since std::string is reference-counted, this at least does not
-   // create an extra copy.
-   std::string doc;
-   std::getline(sin, doc, (char)EOF);
-   return parse( doc, root, collectComments );
+  // Since std::string is reference-counted, this at least does not
+  // create an extra copy.
+  std::string doc;
+  std::getline(sin, doc, (char)EOF);
+  return parse(doc, root, collectComments);
 }
 
-bool 
-Reader::parse( const char *beginDoc, const char *endDoc, 
-               Value &root,
-               bool collectComments )
-{
-   if ( !features_.allowComments_ )
-   {
-      collectComments = false;
-   }
+bool Reader::parse(const char *beginDoc,
+                   const char *endDoc,
+                   Value &root,
+                   bool collectComments) {
+  if (!features_.allowComments_) {
+    collectComments = false;
+  }
 
-   begin_ = beginDoc;
-   end_ = endDoc;
-   collectComments_ = collectComments;
-   current_ = begin_;
-   lastValueEnd_ = 0;
-   lastValue_ = 0;
-   commentsBefore_ = "";
-   errors_.clear();
-   while ( !nodes_.empty() )
-      nodes_.pop();
-   nodes_.push( &root );
-   
-   bool successful = readValue();
-   Token token;
-   skipCommentTokens( token );
-   if ( collectComments_  &&  !commentsBefore_.empty() )
-      root.setComment( commentsBefore_, commentAfter );
-   if ( features_.strictRoot_ )
-   {
-      if ( !root.isArray()  &&  !root.isObject() )
-      {
-         // Set error location to start of doc, ideally should be first token found in doc
-         token.type_ = tokenError;
-         token.start_ = beginDoc;
-         token.end_ = endDoc;
-         addError( "A valid JSON document must be either an array or an object value.",
-                   token );
-         return false;
-      }
-   }
-   return successful;
-}
+  begin_ = beginDoc;
+  end_ = endDoc;
+  collectComments_ = collectComments;
+  current_ = begin_;
+  lastValueEnd_ = 0;
+  lastValue_ = 0;
+  commentsBefore_ = "";
+  errors_.clear();
+  while (!nodes_.empty())
+    nodes_.pop();
+  nodes_.push(&root);
 
-
-bool
-Reader::readValue()
-{
-   Token token;
-   skipCommentTokens( token );
-   bool successful = true;
-
-   if ( collectComments_  &&  !commentsBefore_.empty() )
-   {
-      // Remove newline characters at the end of the comments
-      size_t lastNonNewline = commentsBefore_.find_last_not_of("\r\n");
-      if (lastNonNewline != std::string::npos)
-      {
-         commentsBefore_.erase(lastNonNewline+1);
-      }
-      else
-      {
-         commentsBefore_.clear();
-      }
-
-      currentValue().setComment( commentsBefore_, commentBefore );
-      commentsBefore_ = "";
-   }
-
-
-   switch ( token.type_ )
-   {
-   case tokenObjectBegin:
-      successful = readObject( token );
-      currentValue().setOffsetLimit(current_ - begin_);
-      break;
-   case tokenArrayBegin:
-      successful = readArray( token );
-      currentValue().setOffsetLimit(current_ - begin_);
-      break;
-   case tokenNumber:
-      successful = decodeNumber( token );
-      break;
-   case tokenString:
-      successful = decodeString( token );
-      break;
-   case tokenTrue:
-      currentValue() = true;
-      currentValue().setOffsetStart(token.start_ - begin_);
-      currentValue().setOffsetLimit(token.end_ - begin_);
-      break;
-   case tokenFalse:
-      currentValue() = false;
-      currentValue().setOffsetStart(token.start_ - begin_);
-      currentValue().setOffsetLimit(token.end_ - begin_);
-      break;
-   case tokenNull:
-      currentValue() = Value();
-      currentValue().setOffsetStart(token.start_ - begin_);
-      currentValue().setOffsetLimit(token.end_ - begin_);
-      break;
-   case tokenArraySeparator:
-      if ( features_.allowDroppedNullPlaceholders_ )
-      {
-         // "Un-read" the current token and mark the current value as a null
-         // token.
-         current_--;
-         currentValue() = Value();
-         currentValue().setOffsetStart(current_ - begin_ - 1);
-         currentValue().setOffsetLimit(current_ - begin_);
-         break;
-      }
-      // Else, fall through...
-   default:
-      currentValue().setOffsetStart(token.start_ - begin_);
-      currentValue().setOffsetLimit(token.end_ - begin_);
-      return addError( "Syntax error: value, object or array expected.", token );
-   }
-
-   if ( collectComments_ )
-   {
-      lastValueEnd_ = current_;
-      lastValue_ = &currentValue();
-   }
-
-   return successful;
-}
-
-
-void 
-Reader::skipCommentTokens( Token &token )
-{
-   if ( features_.allowComments_ )
-   {
-      do
-      {
-         readToken( token );
-      }
-      while ( token.type_ == tokenComment );
-   }
-   else
-   {
-      readToken( token );
-   }
-}
-
-
-bool 
-Reader::expectToken( TokenType type, Token &token, const char *message )
-{
-   readToken( token );
-   if ( token.type_ != type )
-      return addError( message, token );
-   return true;
-}
-
-
-bool 
-Reader::readToken( Token &token )
-{
-   skipSpaces();
-   token.start_ = current_;
-   Char c = getNextChar();
-   bool ok = true;
-   switch ( c )
-   {
-   case '{':
-      token.type_ = tokenObjectBegin;
-      break;
-   case '}':
-      token.type_ = tokenObjectEnd;
-      break;
-   case '[':
-      token.type_ = tokenArrayBegin;
-      break;
-   case ']':
-      token.type_ = tokenArrayEnd;
-      break;
-   case '"':
-      token.type_ = tokenString;
-      ok = readString();
-      break;
-   case '/':
-      token.type_ = tokenComment;
-      ok = readComment();
-      break;
-   case '0':
-   case '1':
-   case '2':
-   case '3':
-   case '4':
-   case '5':
-   case '6':
-   case '7':
-   case '8':
-   case '9':
-   case '-':
-      token.type_ = tokenNumber;
-      readNumber();
-      break;
-   case 't':
-      token.type_ = tokenTrue;
-      ok = match( "rue", 3 );
-      break;
-   case 'f':
-      token.type_ = tokenFalse;
-      ok = match( "alse", 4 );
-      break;
-   case 'n':
-      token.type_ = tokenNull;
-      ok = match( "ull", 3 );
-      break;
-   case ',':
-      token.type_ = tokenArraySeparator;
-      break;
-   case ':':
-      token.type_ = tokenMemberSeparator;
-      break;
-   case 0:
-      token.type_ = tokenEndOfStream;
-      break;
-   default:
-      ok = false;
-      break;
-   }
-   if ( !ok )
+  bool successful = readValue();
+  Token token;
+  skipCommentTokens(token);
+  if (collectComments_ && !commentsBefore_.empty())
+    root.setComment(commentsBefore_, commentAfter);
+  if (features_.strictRoot_) {
+    if (!root.isArray() && !root.isObject()) {
+      // Set error location to start of doc, ideally should be first token found
+      // in doc
       token.type_ = tokenError;
-   token.end_ = current_;
-   return true;
-}
-
-
-void 
-Reader::skipSpaces()
-{
-   while ( current_ != end_ )
-   {
-      Char c = *current_;
-      if ( c == ' '  ||  c == '\t'  ||  c == '\r'  ||  c == '\n' )
-         ++current_;
-      else
-         break;
-   }
-}
-
-
-bool 
-Reader::match( Location pattern, 
-               int patternLength )
-{
-   if ( end_ - current_ < patternLength )
+      token.start_ = beginDoc;
+      token.end_ = endDoc;
+      addError(
+          "A valid JSON document must be either an array or an object value.",
+          token);
       return false;
-   int index = patternLength;
-   while ( index-- )
-      if ( current_[index] != pattern[index] )
-         return false;
-   current_ += patternLength;
-   return true;
+    }
+  }
+  return successful;
 }
 
+bool Reader::readValue() {
+  Token token;
+  skipCommentTokens(token);
+  bool successful = true;
 
-bool
-Reader::readComment()
-{
-   Location commentBegin = current_ - 1;
-   Char c = getNextChar();
-   bool successful = false;
-   if ( c == '*' )
-      successful = readCStyleComment();
-   else if ( c == '/' )
-      successful = readCppStyleComment();
-   if ( !successful )
-      return false;
+  if (collectComments_ && !commentsBefore_.empty()) {
+    // Remove newline characters at the end of the comments
+    size_t lastNonNewline = commentsBefore_.find_last_not_of("\r\n");
+    if (lastNonNewline != std::string::npos) {
+      commentsBefore_.erase(lastNonNewline + 1);
+    } else {
+      commentsBefore_.clear();
+    }
 
-   if ( collectComments_ )
-   {
-      CommentPlacement placement = commentBefore;
-      if ( lastValueEnd_  &&  !containsNewLine( lastValueEnd_, commentBegin ) )
-      {
-         if ( c != '*'  ||  !containsNewLine( commentBegin, current_ ) )
-            placement = commentAfterOnSameLine;
-      }
+    currentValue().setComment(commentsBefore_, commentBefore);
+    commentsBefore_ = "";
+  }
 
-      addComment( commentBegin, current_, placement );
-   }
-   return true;
+  switch (token.type_) {
+  case tokenObjectBegin:
+    successful = readObject(token);
+    currentValue().setOffsetLimit(current_ - begin_);
+    break;
+  case tokenArrayBegin:
+    successful = readArray(token);
+    currentValue().setOffsetLimit(current_ - begin_);
+    break;
+  case tokenNumber:
+    successful = decodeNumber(token);
+    break;
+  case tokenString:
+    successful = decodeString(token);
+    break;
+  case tokenTrue:
+    currentValue() = true;
+    currentValue().setOffsetStart(token.start_ - begin_);
+    currentValue().setOffsetLimit(token.end_ - begin_);
+    break;
+  case tokenFalse:
+    currentValue() = false;
+    currentValue().setOffsetStart(token.start_ - begin_);
+    currentValue().setOffsetLimit(token.end_ - begin_);
+    break;
+  case tokenNull:
+    currentValue() = Value();
+    currentValue().setOffsetStart(token.start_ - begin_);
+    currentValue().setOffsetLimit(token.end_ - begin_);
+    break;
+  case tokenArraySeparator:
+    if (features_.allowDroppedNullPlaceholders_) {
+      // "Un-read" the current token and mark the current value as a null
+      // token.
+      current_--;
+      currentValue() = Value();
+      currentValue().setOffsetStart(current_ - begin_ - 1);
+      currentValue().setOffsetLimit(current_ - begin_);
+      break;
+    }
+  // Else, fall through...
+  default:
+    currentValue().setOffsetStart(token.start_ - begin_);
+    currentValue().setOffsetLimit(token.end_ - begin_);
+    return addError("Syntax error: value, object or array expected.", token);
+  }
+
+  if (collectComments_) {
+    lastValueEnd_ = current_;
+    lastValue_ = &currentValue();
+  }
+
+  return successful;
 }
 
-
-void 
-Reader::addComment( Location begin, 
-                    Location end, 
-                    CommentPlacement placement )
-{
-   assert( collectComments_ );
-   if ( placement == commentAfterOnSameLine )
-   {
-      assert( lastValue_ != 0 );
-      lastValue_->setComment( std::string( begin, end ), placement );
-   }
-   else
-   {
-      if ( !commentsBefore_.empty() )
-         commentsBefore_ += "\n";
-      commentsBefore_ += std::string( begin, end );
-   }
+void Reader::skipCommentTokens(Token &token) {
+  if (features_.allowComments_) {
+    do {
+      readToken(token);
+    } while (token.type_ == tokenComment);
+  } else {
+    readToken(token);
+  }
 }
 
-
-bool 
-Reader::readCStyleComment()
-{
-   while ( current_ != end_ )
-   {
-      Char c = getNextChar();
-      if ( c == '*'  &&  *current_ == '/' )
-         break;
-   }
-   return getNextChar() == '/';
+bool Reader::expectToken(TokenType type, Token &token, const char *message) {
+  readToken(token);
+  if (token.type_ != type)
+    return addError(message, token);
+  return true;
 }
 
-
-bool 
-Reader::readCppStyleComment()
-{
-   while ( current_ != end_ )
-   {
-      Char c = getNextChar();
-      if (  c == '\r'  ||  c == '\n' )
-         break;
-   }
-   return true;
+bool Reader::readToken(Token &token) {
+  skipSpaces();
+  token.start_ = current_;
+  Char c = getNextChar();
+  bool ok = true;
+  switch (c) {
+  case '{':
+    token.type_ = tokenObjectBegin;
+    break;
+  case '}':
+    token.type_ = tokenObjectEnd;
+    break;
+  case '[':
+    token.type_ = tokenArrayBegin;
+    break;
+  case ']':
+    token.type_ = tokenArrayEnd;
+    break;
+  case '"':
+    token.type_ = tokenString;
+    ok = readString();
+    break;
+  case '/':
+    token.type_ = tokenComment;
+    ok = readComment();
+    break;
+  case '0':
+  case '1':
+  case '2':
+  case '3':
+  case '4':
+  case '5':
+  case '6':
+  case '7':
+  case '8':
+  case '9':
+  case '-':
+    token.type_ = tokenNumber;
+    readNumber();
+    break;
+  case 't':
+    token.type_ = tokenTrue;
+    ok = match("rue", 3);
+    break;
+  case 'f':
+    token.type_ = tokenFalse;
+    ok = match("alse", 4);
+    break;
+  case 'n':
+    token.type_ = tokenNull;
+    ok = match("ull", 3);
+    break;
+  case ',':
+    token.type_ = tokenArraySeparator;
+    break;
+  case ':':
+    token.type_ = tokenMemberSeparator;
+    break;
+  case 0:
+    token.type_ = tokenEndOfStream;
+    break;
+  default:
+    ok = false;
+    break;
+  }
+  if (!ok)
+    token.type_ = tokenError;
+  token.end_ = current_;
+  return true;
 }
 
-
-void 
-Reader::readNumber()
-{
-   while ( current_ != end_ )
-   {
-      if ( !(*current_ >= '0'  &&  *current_ <= '9')  &&
-           !in( *current_, '.', 'e', 'E', '+', '-' ) )
-         break;
+void Reader::skipSpaces() {
+  while (current_ != end_) {
+    Char c = *current_;
+    if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
       ++current_;
-   }
+    else
+      break;
+  }
 }
 
-bool
-Reader::readString()
-{
-   Char c = 0;
-   while ( current_ != end_ )
-   {
-      c = getNextChar();
-      if ( c == '\\' )
-         getNextChar();
-      else if ( c == '"' )
-         break;
-   }
-   return c == '"';
+bool Reader::match(Location pattern, int patternLength) {
+  if (end_ - current_ < patternLength)
+    return false;
+  int index = patternLength;
+  while (index--)
+    if (current_[index] != pattern[index])
+      return false;
+  current_ += patternLength;
+  return true;
 }
 
+bool Reader::readComment() {
+  Location commentBegin = current_ - 1;
+  Char c = getNextChar();
+  bool successful = false;
+  if (c == '*')
+    successful = readCStyleComment();
+  else if (c == '/')
+    successful = readCppStyleComment();
+  if (!successful)
+    return false;
 
-bool 
-Reader::readObject( Token &tokenStart )
-{
-   Token tokenName;
-   std::string name;
-   currentValue() = Value( objectValue );
-   currentValue().setOffsetStart(tokenStart.start_ - begin_);
-   while ( readToken( tokenName ) )
-   {
-      bool initialTokenOk = true;
-      while ( tokenName.type_ == tokenComment  &&  initialTokenOk )
-         initialTokenOk = readToken( tokenName );
-      if  ( !initialTokenOk )
-         break;
-      if ( tokenName.type_ == tokenObjectEnd  &&  name.empty() )  // empty object
-         return true;
-      name = "";
-      if ( tokenName.type_ == tokenString )
-      {
-         if ( !decodeString( tokenName, name ) )
-            return recoverFromError( tokenObjectEnd );
-      }
-      else if ( tokenName.type_ == tokenNumber &&
-                features_.allowNumericKeys_ )
-      {
-         Value numberName;
-         if ( !decodeNumber( tokenName, numberName ) )
-            return recoverFromError( tokenObjectEnd );
-         name = numberName.asString();
-      }
-      else
-      {
-         break;
-      }
+  if (collectComments_) {
+    CommentPlacement placement = commentBefore;
+    if (lastValueEnd_ && !containsNewLine(lastValueEnd_, commentBegin)) {
+      if (c != '*' || !containsNewLine(commentBegin, current_))
+        placement = commentAfterOnSameLine;
+    }
 
-      Token colon;
-      if ( !readToken( colon ) ||  colon.type_ != tokenMemberSeparator )
-      {
-         return addErrorAndRecover( "Missing ':' after object member name", 
-                                    colon, 
-                                    tokenObjectEnd );
-      }
-      Value &value = currentValue()[ name ];
-      nodes_.push( &value );
-      bool ok = readValue();
-      nodes_.pop();
-      if ( !ok ) // error already set
-         return recoverFromError( tokenObjectEnd );
-
-      Token comma;
-      if ( !readToken( comma )
-            ||  ( comma.type_ != tokenObjectEnd  &&  
-                  comma.type_ != tokenArraySeparator &&
-                  comma.type_ != tokenComment ) )
-      {
-         return addErrorAndRecover( "Missing ',' or '}' in object declaration", 
-                                    comma, 
-                                    tokenObjectEnd );
-      }
-      bool finalizeTokenOk = true;
-      while ( comma.type_ == tokenComment &&
-              finalizeTokenOk )
-         finalizeTokenOk = readToken( comma );
-      if ( comma.type_ == tokenObjectEnd )
-         return true;
-   }
-   return addErrorAndRecover( "Missing '}' or object member name", 
-                              tokenName, 
-                              tokenObjectEnd );
+    addComment(commentBegin, current_, placement);
+  }
+  return true;
 }
 
+void
+Reader::addComment(Location begin, Location end, CommentPlacement placement) {
+  assert(collectComments_);
+  if (placement == commentAfterOnSameLine) {
+    assert(lastValue_ != 0);
+    lastValue_->setComment(std::string(begin, end), placement);
+  } else {
+    if (!commentsBefore_.empty())
+      commentsBefore_ += "\n";
+    commentsBefore_ += std::string(begin, end);
+  }
+}
 
-bool 
-Reader::readArray( Token &tokenStart )
-{
-   currentValue() = Value( arrayValue );
-   currentValue().setOffsetStart(tokenStart.start_ - begin_);
-   skipSpaces();
-   if ( *current_ == ']' ) // empty array
-   {
-      Token endArray;
-      readToken( endArray );
+bool Reader::readCStyleComment() {
+  while (current_ != end_) {
+    Char c = getNextChar();
+    if (c == '*' && *current_ == '/')
+      break;
+  }
+  return getNextChar() == '/';
+}
+
+bool Reader::readCppStyleComment() {
+  while (current_ != end_) {
+    Char c = getNextChar();
+    if (c == '\r' || c == '\n')
+      break;
+  }
+  return true;
+}
+
+void Reader::readNumber() {
+  while (current_ != end_) {
+    if (!(*current_ >= '0' && *current_ <= '9') &&
+        !in(*current_, '.', 'e', 'E', '+', '-'))
+      break;
+    ++current_;
+  }
+}
+
+bool Reader::readString() {
+  Char c = 0;
+  while (current_ != end_) {
+    c = getNextChar();
+    if (c == '\\')
+      getNextChar();
+    else if (c == '"')
+      break;
+  }
+  return c == '"';
+}
+
+bool Reader::readObject(Token &tokenStart) {
+  Token tokenName;
+  std::string name;
+  currentValue() = Value(objectValue);
+  currentValue().setOffsetStart(tokenStart.start_ - begin_);
+  while (readToken(tokenName)) {
+    bool initialTokenOk = true;
+    while (tokenName.type_ == tokenComment && initialTokenOk)
+      initialTokenOk = readToken(tokenName);
+    if (!initialTokenOk)
+      break;
+    if (tokenName.type_ == tokenObjectEnd && name.empty()) // empty object
       return true;
-   }
-   int index = 0;
-   for (;;)
-   {
-      Value &value = currentValue()[ index++ ];
-      nodes_.push( &value );
-      bool ok = readValue();
-      nodes_.pop();
-      if ( !ok ) // error already set
-         return recoverFromError( tokenArrayEnd );
+    name = "";
+    if (tokenName.type_ == tokenString) {
+      if (!decodeString(tokenName, name))
+        return recoverFromError(tokenObjectEnd);
+    } else if (tokenName.type_ == tokenNumber && features_.allowNumericKeys_) {
+      Value numberName;
+      if (!decodeNumber(tokenName, numberName))
+        return recoverFromError(tokenObjectEnd);
+      name = numberName.asString();
+    } else {
+      break;
+    }
 
-      Token token;
-      // Accept Comment after last item in the array.
-      ok = readToken( token );
-      while ( token.type_ == tokenComment  &&  ok )
-      {
-         ok = readToken( token );
-      }
-      bool badTokenType = ( token.type_ != tokenArraySeparator  &&
-                            token.type_ != tokenArrayEnd );
-      if ( !ok  ||  badTokenType )
-      {
-         return addErrorAndRecover( "Missing ',' or ']' in array declaration", 
-                                    token, 
-                                    tokenArrayEnd );
-      }
-      if ( token.type_ == tokenArrayEnd )
-         break;
-   }
-   return true;
+    Token colon;
+    if (!readToken(colon) || colon.type_ != tokenMemberSeparator) {
+      return addErrorAndRecover(
+          "Missing ':' after object member name", colon, tokenObjectEnd);
+    }
+    Value &value = currentValue()[name];
+    nodes_.push(&value);
+    bool ok = readValue();
+    nodes_.pop();
+    if (!ok) // error already set
+      return recoverFromError(tokenObjectEnd);
+
+    Token comma;
+    if (!readToken(comma) ||
+        (comma.type_ != tokenObjectEnd && comma.type_ != tokenArraySeparator &&
+         comma.type_ != tokenComment)) {
+      return addErrorAndRecover(
+          "Missing ',' or '}' in object declaration", comma, tokenObjectEnd);
+    }
+    bool finalizeTokenOk = true;
+    while (comma.type_ == tokenComment && finalizeTokenOk)
+      finalizeTokenOk = readToken(comma);
+    if (comma.type_ == tokenObjectEnd)
+      return true;
+  }
+  return addErrorAndRecover(
+      "Missing '}' or object member name", tokenName, tokenObjectEnd);
 }
 
+bool Reader::readArray(Token &tokenStart) {
+  currentValue() = Value(arrayValue);
+  currentValue().setOffsetStart(tokenStart.start_ - begin_);
+  skipSpaces();
+  if (*current_ == ']') // empty array
+  {
+    Token endArray;
+    readToken(endArray);
+    return true;
+  }
+  int index = 0;
+  for (;;) {
+    Value &value = currentValue()[index++];
+    nodes_.push(&value);
+    bool ok = readValue();
+    nodes_.pop();
+    if (!ok) // error already set
+      return recoverFromError(tokenArrayEnd);
 
-bool 
-Reader::decodeNumber( Token &token )
-{
+    Token token;
+    // Accept Comment after last item in the array.
+    ok = readToken(token);
+    while (token.type_ == tokenComment && ok) {
+      ok = readToken(token);
+    }
+    bool badTokenType =
+        (token.type_ != tokenArraySeparator && token.type_ != tokenArrayEnd);
+    if (!ok || badTokenType) {
+      return addErrorAndRecover(
+          "Missing ',' or ']' in array declaration", token, tokenArrayEnd);
+    }
+    if (token.type_ == tokenArrayEnd)
+      break;
+  }
+  return true;
+}
+
+bool Reader::decodeNumber(Token &token) {
   Value decoded;
-  if ( !decodeNumber( token, decoded ) )
-     return false;
+  if (!decodeNumber(token, decoded))
+    return false;
   currentValue() = decoded;
   currentValue().setOffsetStart(token.start_ - begin_);
   currentValue().setOffsetLimit(token.end_ - begin_);
   return true;
 }
 
-
-bool
-Reader::decodeNumber( Token &token, Value &decoded )
-{
-   bool isDouble = false;
-   for ( Location inspect = token.start_; inspect != token.end_; ++inspect )
-   {
-      isDouble = isDouble  
-                 ||  in( *inspect, '.', 'e', 'E', '+' )  
-                 ||  ( *inspect == '-'  &&  inspect != token.start_ );
-   }
-   if ( isDouble )
-      return decodeDouble( token, decoded );
-   // Attempts to parse the number as an integer. If the number is
-   // larger than the maximum supported value of an integer then
-   // we decode the number as a double.
-   Location current = token.start_;
-   bool isNegative = *current == '-';
-   if ( isNegative )
-      ++current;
-   Value::LargestUInt maxIntegerValue = isNegative ? Value::LargestUInt(-Value::minLargestInt) 
-                                                   : Value::maxLargestUInt;
-   Value::LargestUInt threshold = maxIntegerValue / 10;
-   Value::LargestUInt value = 0;
-   while ( current < token.end_ )
-   {
-      Char c = *current++;
-      if ( c < '0'  ||  c > '9' )
-         return addError( "'" + std::string( token.start_, token.end_ ) + "' is not a number.", token );
-      Value::UInt digit(c - '0');
-      if ( value >= threshold )
-      {
-         // We've hit or exceeded the max value divided by 10 (rounded down). If
-         // a) we've only just touched the limit, b) this is the last digit, and
-         // c) it's small enough to fit in that rounding delta, we're okay.
-         // Otherwise treat this number as a double to avoid overflow.
-         if (value > threshold ||
-             current != token.end_ ||
-             digit > maxIntegerValue % 10)
-         {
-            return decodeDouble( token, decoded );
-         }
+bool Reader::decodeNumber(Token &token, Value &decoded) {
+  bool isDouble = false;
+  for (Location inspect = token.start_; inspect != token.end_; ++inspect) {
+    isDouble = isDouble || in(*inspect, '.', 'e', 'E', '+') ||
+               (*inspect == '-' && inspect != token.start_);
+  }
+  if (isDouble)
+    return decodeDouble(token, decoded);
+  // Attempts to parse the number as an integer. If the number is
+  // larger than the maximum supported value of an integer then
+  // we decode the number as a double.
+  Location current = token.start_;
+  bool isNegative = *current == '-';
+  if (isNegative)
+    ++current;
+  Value::LargestUInt maxIntegerValue =
+      isNegative ? Value::LargestUInt(-Value::minLargestInt)
+                 : Value::maxLargestUInt;
+  Value::LargestUInt threshold = maxIntegerValue / 10;
+  Value::LargestUInt value = 0;
+  while (current < token.end_) {
+    Char c = *current++;
+    if (c < '0' || c > '9')
+      return addError("'" + std::string(token.start_, token.end_) +
+                          "' is not a number.",
+                      token);
+    Value::UInt digit(c - '0');
+    if (value >= threshold) {
+      // We've hit or exceeded the max value divided by 10 (rounded down). If
+      // a) we've only just touched the limit, b) this is the last digit, and
+      // c) it's small enough to fit in that rounding delta, we're okay.
+      // Otherwise treat this number as a double to avoid overflow.
+      if (value > threshold || current != token.end_ ||
+          digit > maxIntegerValue % 10) {
+        return decodeDouble(token, decoded);
       }
-      value = value * 10 + digit;
-   }
-   if ( isNegative )
-      decoded = -Value::LargestInt( value );
-   else if ( value <= Value::LargestUInt(Value::maxInt) )
-      decoded = Value::LargestInt( value );
-   else
-      decoded = value;
-   return true;
+    }
+    value = value * 10 + digit;
+  }
+  if (isNegative)
+    decoded = -Value::LargestInt(value);
+  else if (value <= Value::LargestUInt(Value::maxInt))
+    decoded = Value::LargestInt(value);
+  else
+    decoded = value;
+  return true;
 }
 
-
-bool 
-Reader::decodeDouble( Token &token )
-{
+bool Reader::decodeDouble(Token &token) {
   Value decoded;
-  if ( !decodeDouble( token, decoded ) )
-     return false;
+  if (!decodeDouble(token, decoded))
+    return false;
   currentValue() = decoded;
   currentValue().setOffsetStart(token.start_ - begin_);
   currentValue().setOffsetLimit(token.end_ - begin_);
   return true;
 }
 
+bool Reader::decodeDouble(Token &token, Value &decoded) {
+  double value = 0;
+  const int bufferSize = 32;
+  int count;
+  int length = int(token.end_ - token.start_);
 
-bool
-Reader::decodeDouble( Token &token, Value &decoded )
-{
-   double value = 0;
-   const int bufferSize = 32;
-   int count;
-   int length = int(token.end_ - token.start_);
+  // Sanity check to avoid buffer overflow exploits.
+  if (length < 0) {
+    return addError("Unable to parse token length", token);
+  }
 
-   // Sanity check to avoid buffer overflow exploits.
-   if (length < 0) {
-      return addError( "Unable to parse token length", token );
-   }
+  // Avoid using a string constant for the format control string given to
+  // sscanf, as this can cause hard to debug crashes on OS X. See here for more
+  // info:
+  //
+  //     http://developer.apple.com/library/mac/#DOCUMENTATION/DeveloperTools/gcc-4.0.1/gcc/Incompatibilities.html
+  char format[] = "%lf";
 
-   // Avoid using a string constant for the format control string given to
-   // sscanf, as this can cause hard to debug crashes on OS X. See here for more
-   // info:
-   //
-   //     http://developer.apple.com/library/mac/#DOCUMENTATION/DeveloperTools/gcc-4.0.1/gcc/Incompatibilities.html
-   char format[] = "%lf";
+  if (length <= bufferSize) {
+    Char buffer[bufferSize + 1];
+    memcpy(buffer, token.start_, length);
+    buffer[length] = 0;
+    count = sscanf(buffer, format, &value);
+  } else {
+    std::string buffer(token.start_, token.end_);
+    count = sscanf(buffer.c_str(), format, &value);
+  }
 
-   if ( length <= bufferSize )
-   {
-      Char buffer[bufferSize+1];
-      memcpy( buffer, token.start_, length );
-      buffer[length] = 0;
-      count = sscanf( buffer, format, &value );
-   }
-   else
-   {
-      std::string buffer( token.start_, token.end_ );
-      count = sscanf( buffer.c_str(), format, &value );
-   }
-
-   if ( count != 1 )
-      return addError( "'" + std::string( token.start_, token.end_ ) + "' is not a number.", token );
-   decoded = value;
-   return true;
+  if (count != 1)
+    return addError("'" + std::string(token.start_, token.end_) +
+                        "' is not a number.",
+                    token);
+  decoded = value;
+  return true;
 }
 
-
-bool 
-Reader::decodeString( Token &token )
-{
-   std::string decoded;
-   if ( !decodeString( token, decoded ) )
-      return false;
-   currentValue() = decoded;
-   currentValue().setOffsetStart(token.start_ - begin_);
-   currentValue().setOffsetLimit(token.end_ - begin_);
-   return true;
+bool Reader::decodeString(Token &token) {
+  std::string decoded;
+  if (!decodeString(token, decoded))
+    return false;
+  currentValue() = decoded;
+  currentValue().setOffsetStart(token.start_ - begin_);
+  currentValue().setOffsetLimit(token.end_ - begin_);
+  return true;
 }
 
+bool Reader::decodeString(Token &token, std::string &decoded) {
+  decoded.reserve(token.end_ - token.start_ - 2);
+  Location current = token.start_ + 1; // skip '"'
+  Location end = token.end_ - 1;       // do not include '"'
+  while (current != end) {
+    Char c = *current++;
+    if (c == '"')
+      break;
+    else if (c == '\\') {
+      if (current == end)
+        return addError("Empty escape sequence in string", token, current);
+      Char escape = *current++;
+      switch (escape) {
+      case '"':
+        decoded += '"';
+        break;
+      case '/':
+        decoded += '/';
+        break;
+      case '\\':
+        decoded += '\\';
+        break;
+      case 'b':
+        decoded += '\b';
+        break;
+      case 'f':
+        decoded += '\f';
+        break;
+      case 'n':
+        decoded += '\n';
+        break;
+      case 'r':
+        decoded += '\r';
+        break;
+      case 't':
+        decoded += '\t';
+        break;
+      case 'u': {
+        unsigned int unicode;
+        if (!decodeUnicodeCodePoint(token, current, end, unicode))
+          return false;
+        decoded += codePointToUTF8(unicode);
+      } break;
+      default:
+        return addError("Bad escape sequence in string", token, current);
+      }
+    } else {
+      decoded += c;
+    }
+  }
+  return true;
+}
 
-bool 
-Reader::decodeString( Token &token, std::string &decoded )
-{
-   decoded.reserve( token.end_ - token.start_ - 2 );
-   Location current = token.start_ + 1; // skip '"'
-   Location end = token.end_ - 1;      // do not include '"'
-   while ( current != end )
-   {
-      Char c = *current++;
-      if ( c == '"' )
-         break;
-      else if ( c == '\\' )
-      {
-         if ( current == end )
-            return addError( "Empty escape sequence in string", token, current );
-         Char escape = *current++;
-         switch ( escape )
-         {
-         case '"': decoded += '"'; break;
-         case '/': decoded += '/'; break;
-         case '\\': decoded += '\\'; break;
-         case 'b': decoded += '\b'; break;
-         case 'f': decoded += '\f'; break;
-         case 'n': decoded += '\n'; break;
-         case 'r': decoded += '\r'; break;
-         case 't': decoded += '\t'; break;
-         case 'u':
-            {
-               unsigned int unicode;
-               if ( !decodeUnicodeCodePoint( token, current, end, unicode ) )
-                  return false;
-               decoded += codePointToUTF8(unicode);
-            }
-            break;
-         default:
-            return addError( "Bad escape sequence in string", token, current );
-         }
-      }
-      else
-      {
-         decoded += c;
-      }
-   }
-   return true;
+bool Reader::decodeUnicodeCodePoint(Token &token,
+                                    Location &current,
+                                    Location end,
+                                    unsigned int &unicode) {
+
+  if (!decodeUnicodeEscapeSequence(token, current, end, unicode))
+    return false;
+  if (unicode >= 0xD800 && unicode <= 0xDBFF) {
+    // surrogate pairs
+    if (end - current < 6)
+      return addError(
+          "additional six characters expected to parse unicode surrogate pair.",
+          token,
+          current);
+    unsigned int surrogatePair;
+    if (*(current++) == '\\' && *(current++) == 'u') {
+      if (decodeUnicodeEscapeSequence(token, current, end, surrogatePair)) {
+        unicode = 0x10000 + ((unicode & 0x3FF) << 10) + (surrogatePair & 0x3FF);
+      } else
+        return false;
+    } else
+      return addError("expecting another \\u token to begin the second half of "
+                      "a unicode surrogate pair",
+                      token,
+                      current);
+  }
+  return true;
+}
+
+bool Reader::decodeUnicodeEscapeSequence(Token &token,
+                                         Location &current,
+                                         Location end,
+                                         unsigned int &unicode) {
+  if (end - current < 4)
+    return addError(
+        "Bad unicode escape sequence in string: four digits expected.",
+        token,
+        current);
+  unicode = 0;
+  for (int index = 0; index < 4; ++index) {
+    Char c = *current++;
+    unicode *= 16;
+    if (c >= '0' && c <= '9')
+      unicode += c - '0';
+    else if (c >= 'a' && c <= 'f')
+      unicode += c - 'a' + 10;
+    else if (c >= 'A' && c <= 'F')
+      unicode += c - 'A' + 10;
+    else
+      return addError(
+          "Bad unicode escape sequence in string: hexadecimal digit expected.",
+          token,
+          current);
+  }
+  return true;
 }
 
 bool
-Reader::decodeUnicodeCodePoint( Token &token, 
-                                     Location &current, 
-                                     Location end, 
-                                     unsigned int &unicode )
-{
-
-   if ( !decodeUnicodeEscapeSequence( token, current, end, unicode ) )
-      return false;
-   if (unicode >= 0xD800 && unicode <= 0xDBFF)
-   {
-      // surrogate pairs
-      if (end - current < 6)
-         return addError( "additional six characters expected to parse unicode surrogate pair.", token, current );
-      unsigned int surrogatePair;
-      if (*(current++) == '\\' && *(current++)== 'u')
-      {
-         if (decodeUnicodeEscapeSequence( token, current, end, surrogatePair ))
-         {
-            unicode = 0x10000 + ((unicode & 0x3FF) << 10) + (surrogatePair & 0x3FF);
-         } 
-         else
-            return false;
-      } 
-      else
-         return addError( "expecting another \\u token to begin the second half of a unicode surrogate pair", token, current );
-   }
-   return true;
+Reader::addError(const std::string &message, Token &token, Location extra) {
+  ErrorInfo info;
+  info.token_ = token;
+  info.message_ = message;
+  info.extra_ = extra;
+  errors_.push_back(info);
+  return false;
 }
 
-bool 
-Reader::decodeUnicodeEscapeSequence( Token &token, 
-                                     Location &current, 
-                                     Location end, 
-                                     unsigned int &unicode )
-{
-   if ( end - current < 4 )
-      return addError( "Bad unicode escape sequence in string: four digits expected.", token, current );
-   unicode = 0;
-   for ( int index =0; index < 4; ++index )
-   {
-      Char c = *current++;
-      unicode *= 16;
-      if ( c >= '0'  &&  c <= '9' )
-         unicode += c - '0';
-      else if ( c >= 'a'  &&  c <= 'f' )
-         unicode += c - 'a' + 10;
-      else if ( c >= 'A'  &&  c <= 'F' )
-         unicode += c - 'A' + 10;
-      else
-         return addError( "Bad unicode escape sequence in string: hexadecimal digit expected.", token, current );
-   }
-   return true;
+bool Reader::recoverFromError(TokenType skipUntilToken) {
+  int errorCount = int(errors_.size());
+  Token skip;
+  for (;;) {
+    if (!readToken(skip))
+      errors_.resize(errorCount); // discard errors caused by recovery
+    if (skip.type_ == skipUntilToken || skip.type_ == tokenEndOfStream)
+      break;
+  }
+  errors_.resize(errorCount);
+  return false;
 }
 
-
-bool 
-Reader::addError( const std::string &message, 
-                  Token &token,
-                  Location extra )
-{
-   ErrorInfo info;
-   info.token_ = token;
-   info.message_ = message;
-   info.extra_ = extra;
-   errors_.push_back( info );
-   return false;
+bool Reader::addErrorAndRecover(const std::string &message,
+                                Token &token,
+                                TokenType skipUntilToken) {
+  addError(message, token);
+  return recoverFromError(skipUntilToken);
 }
 
+Value &Reader::currentValue() { return *(nodes_.top()); }
 
-bool 
-Reader::recoverFromError( TokenType skipUntilToken )
-{
-   int errorCount = int(errors_.size());
-   Token skip;
-   for (;;)
-   {
-      if ( !readToken(skip) )
-         errors_.resize( errorCount ); // discard errors caused by recovery
-      if ( skip.type_ == skipUntilToken  ||  skip.type_ == tokenEndOfStream )
-         break;
-   }
-   errors_.resize( errorCount );
-   return false;
+Reader::Char Reader::getNextChar() {
+  if (current_ == end_)
+    return 0;
+  return *current_++;
 }
 
-
-bool 
-Reader::addErrorAndRecover( const std::string &message, 
-                            Token &token,
-                            TokenType skipUntilToken )
-{
-   addError( message, token );
-   return recoverFromError( skipUntilToken );
+void Reader::getLocationLineAndColumn(Location location,
+                                      int &line,
+                                      int &column) const {
+  Location current = begin_;
+  Location lastLineStart = current;
+  line = 0;
+  while (current < location && current != end_) {
+    Char c = *current++;
+    if (c == '\r') {
+      if (*current == '\n')
+        ++current;
+      lastLineStart = current;
+      ++line;
+    } else if (c == '\n') {
+      lastLineStart = current;
+      ++line;
+    }
+  }
+  // column & line start at 1
+  column = int(location - lastLineStart) + 1;
+  ++line;
 }
 
-
-Value &
-Reader::currentValue()
-{
-   return *(nodes_.top());
-}
-
-
-Reader::Char 
-Reader::getNextChar()
-{
-   if ( current_ == end_ )
-      return 0;
-   return *current_++;
-}
-
-
-void 
-Reader::getLocationLineAndColumn( Location location,
-                                  int &line,
-                                  int &column ) const
-{
-   Location current = begin_;
-   Location lastLineStart = current;
-   line = 0;
-   while ( current < location  &&  current != end_ )
-   {
-      Char c = *current++;
-      if ( c == '\r' )
-      {
-         if ( *current == '\n' )
-            ++current;
-         lastLineStart = current;
-         ++line;
-      }
-      else if ( c == '\n' )
-      {
-         lastLineStart = current;
-         ++line;
-      }
-   }
-   // column & line start at 1
-   column = int(location - lastLineStart) + 1;
-   ++line;
-}
-
-
-std::string
-Reader::getLocationLineAndColumn( Location location ) const
-{
-   int line, column;
-   getLocationLineAndColumn( location, line, column );
-   char buffer[18+16+16+1];
+std::string Reader::getLocationLineAndColumn(Location location) const {
+  int line, column;
+  getLocationLineAndColumn(location, line, column);
+  char buffer[18 + 16 + 16 + 1];
 #if defined(_MSC_VER) && defined(__STDC_SECURE_LIB__)
-   sprintf_s(buffer, sizeof(buffer), "Line %d, Column %d", line, column);
+  sprintf_s(buffer, sizeof(buffer), "Line %d, Column %d", line, column);
 #else
-   snprintf(buffer, sizeof(buffer), "Line %d, Column %d", line, column);
+  snprintf(buffer, sizeof(buffer), "Line %d, Column %d", line, column);
 #endif
-   return buffer;
+  return buffer;
 }
 
-
 // Deprecated. Preserved for backward compatibility
-std::string 
-Reader::getFormatedErrorMessages() const
-{
-    return getFormattedErrorMessages();
+std::string Reader::getFormatedErrorMessages() const {
+  return getFormattedErrorMessages();
 }
 
-
-std::string 
-Reader::getFormattedErrorMessages() const
-{
-   std::string formattedMessage;
-   for ( Errors::const_iterator itError = errors_.begin();
-         itError != errors_.end();
-         ++itError )
-   {
-      const ErrorInfo &error = *itError;
-      formattedMessage += "* " + getLocationLineAndColumn( error.token_.start_ ) + "\n";
-      formattedMessage += "  " + error.message_ + "\n";
-      if ( error.extra_ )
-         formattedMessage += "See " + getLocationLineAndColumn( error.extra_ ) + " for detail.\n";
-   }
-   return formattedMessage;
+std::string Reader::getFormattedErrorMessages() const {
+  std::string formattedMessage;
+  for (Errors::const_iterator itError = errors_.begin();
+       itError != errors_.end();
+       ++itError) {
+    const ErrorInfo &error = *itError;
+    formattedMessage +=
+        "* " + getLocationLineAndColumn(error.token_.start_) + "\n";
+    formattedMessage += "  " + error.message_ + "\n";
+    if (error.extra_)
+      formattedMessage +=
+          "See " + getLocationLineAndColumn(error.extra_) + " for detail.\n";
+  }
+  return formattedMessage;
 }
 
-
-std::vector<Reader::StructuredError>
-Reader::getStructuredErrors() const
-{
-   std::vector<Reader::StructuredError> allErrors;
-   for ( Errors::const_iterator itError = errors_.begin();
-         itError != errors_.end();
-         ++itError )
-   {
-      const ErrorInfo &error = *itError;
-      Reader::StructuredError structured;
-      structured.offset_start = error.token_.start_ - begin_;
-      structured.offset_limit = error.token_.end_ - begin_;
-      structured.message = error.message_;
-      allErrors.push_back(structured);
-   }
-   return allErrors;
+std::vector<Reader::StructuredError> Reader::getStructuredErrors() const {
+  std::vector<Reader::StructuredError> allErrors;
+  for (Errors::const_iterator itError = errors_.begin();
+       itError != errors_.end();
+       ++itError) {
+    const ErrorInfo &error = *itError;
+    Reader::StructuredError structured;
+    structured.offset_start = error.token_.start_ - begin_;
+    structured.offset_limit = error.token_.end_ - begin_;
+    structured.message = error.message_;
+    allErrors.push_back(structured);
+  }
+  return allErrors;
 }
 
+std::istream &operator>>(std::istream &sin, Value &root) {
+  Json::Reader reader;
+  bool ok = reader.parse(sin, root, true);
+  if (!ok) {
+    fprintf(stderr,
+            "Error from reader: %s",
+            reader.getFormattedErrorMessages().c_str());
 
-std::istream& operator>>( std::istream &sin, Value &root )
-{
-    Json::Reader reader;
-    bool ok = reader.parse(sin, root, true);
-    if (!ok) {
-      fprintf(
-          stderr,
-          "Error from reader: %s",
-          reader.getFormattedErrorMessages().c_str());
-
-      JSON_FAIL_MESSAGE("reader error");
-    }
-    return sin;
+    JSON_FAIL_MESSAGE("reader error");
+  }
+  return sin;
 }
 
-
 } // namespace Json
 // vim: et ts=3 sts=3 sw=3 tw=0
diff --git a/src/lib_json/json_tool.h b/src/lib_json/json_tool.h
index 658031b..c18a768 100644
--- a/src/lib_json/json_tool.h
+++ b/src/lib_json/json_tool.h
@@ -4,7 +4,7 @@
 // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
 
 #ifndef LIB_JSONCPP_JSON_TOOL_H_INCLUDED
-# define LIB_JSONCPP_JSON_TOOL_H_INCLUDED
+#define LIB_JSONCPP_JSON_TOOL_H_INCLUDED
 
 /* This header provides common string manipulation support, such as UTF-8,
  * portable conversion from/to string...
@@ -15,77 +15,57 @@
 namespace Json {
 
 /// Converts a unicode code-point to UTF-8.
-static inline std::string 
-codePointToUTF8(unsigned int cp)
-{
-   std::string result;
-   
-   // based on description from http://en.wikipedia.org/wiki/UTF-8
+static inline std::string codePointToUTF8(unsigned int cp) {
+  std::string result;
 
-   if (cp <= 0x7f) 
-   {
-      result.resize(1);
-      result[0] = static_cast<char>(cp);
-   } 
-   else if (cp <= 0x7FF) 
-   {
-      result.resize(2);
-      result[1] = static_cast<char>(0x80 | (0x3f & cp));
-      result[0] = static_cast<char>(0xC0 | (0x1f & (cp >> 6)));
-   } 
-   else if (cp <= 0xFFFF) 
-   {
-      result.resize(3);
-      result[2] = static_cast<char>(0x80 | (0x3f & cp));
-      result[1] = 0x80 | static_cast<char>((0x3f & (cp >> 6)));
-      result[0] = 0xE0 | static_cast<char>((0xf & (cp >> 12)));
-   }
-   else if (cp <= 0x10FFFF) 
-   {
-      result.resize(4);
-      result[3] = static_cast<char>(0x80 | (0x3f & cp));
-      result[2] = static_cast<char>(0x80 | (0x3f & (cp >> 6)));
-      result[1] = static_cast<char>(0x80 | (0x3f & (cp >> 12)));
-      result[0] = static_cast<char>(0xF0 | (0x7 & (cp >> 18)));
-   }
+  // based on description from http://en.wikipedia.org/wiki/UTF-8
 
-   return result;
+  if (cp <= 0x7f) {
+    result.resize(1);
+    result[0] = static_cast<char>(cp);
+  } else if (cp <= 0x7FF) {
+    result.resize(2);
+    result[1] = static_cast<char>(0x80 | (0x3f & cp));
+    result[0] = static_cast<char>(0xC0 | (0x1f & (cp >> 6)));
+  } else if (cp <= 0xFFFF) {
+    result.resize(3);
+    result[2] = static_cast<char>(0x80 | (0x3f & cp));
+    result[1] = 0x80 | static_cast<char>((0x3f & (cp >> 6)));
+    result[0] = 0xE0 | static_cast<char>((0xf & (cp >> 12)));
+  } else if (cp <= 0x10FFFF) {
+    result.resize(4);
+    result[3] = static_cast<char>(0x80 | (0x3f & cp));
+    result[2] = static_cast<char>(0x80 | (0x3f & (cp >> 6)));
+    result[1] = static_cast<char>(0x80 | (0x3f & (cp >> 12)));
+    result[0] = static_cast<char>(0xF0 | (0x7 & (cp >> 18)));
+  }
+
+  return result;
 }
 
-
 /// Returns true if ch is a control character (in range [0,32[).
-static inline bool 
-isControlCharacter(char ch)
-{
-   return ch > 0 && ch <= 0x1F;
-}
+static inline bool isControlCharacter(char ch) { return ch > 0 && ch <= 0x1F; }
 
-
-enum { 
-   /// Constant that specify the size of the buffer that must be passed to uintToString.
-   uintToStringBufferSize = 3*sizeof(LargestUInt)+1 
+enum {
+  /// Constant that specify the size of the buffer that must be passed to
+  /// uintToString.
+  uintToStringBufferSize = 3 * sizeof(LargestUInt) + 1
 };
 
 // Defines a char buffer for use with uintToString().
 typedef char UIntToStringBuffer[uintToStringBufferSize];
 
-
 /** Converts an unsigned integer to string.
  * @param value Unsigned interger to convert to string
- * @param current Input/Output string buffer. 
+ * @param current Input/Output string buffer.
  *        Must have at least uintToStringBufferSize chars free.
  */
-static inline void 
-uintToString( LargestUInt value, 
-              char *&current )
-{
-   *--current = 0;
-   do
-   {
-      *--current = char(value % 10) + '0';
-      value /= 10;
-   }
-   while ( value != 0 );
+static inline void uintToString(LargestUInt value, char *&current) {
+  *--current = 0;
+  do {
+    *--current = char(value % 10) + '0';
+    value /= 10;
+  } while (value != 0);
 }
 
 } // namespace Json {
diff --git a/src/lib_json/json_value.cpp b/src/lib_json/json_value.cpp
index 55a47c9..6f952f6 100644
--- a/src/lib_json/json_value.cpp
+++ b/src/lib_json/json_value.cpp
@@ -4,12 +4,12 @@
 // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
 
 #if !defined(JSON_IS_AMALGAMATION)
-# include <json/assertions.h>
-# include <json/value.h>
-# include <json/writer.h>
-# ifndef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR
-#  include "json_batchallocator.h"
-# endif // #ifndef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR
+#include <json/assertions.h>
+#include <json/value.h>
+#include <json/writer.h>
+#ifndef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR
+#include "json_batchallocator.h"
+#endif // #ifndef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR
 #endif // if !defined(JSON_IS_AMALGAMATION)
 #include <math.h>
 #include <sstream>
@@ -17,59 +17,54 @@
 #include <cstring>
 #include <cassert>
 #ifdef JSON_USE_CPPTL
-# include <cpptl/conststring.h>
+#include <cpptl/conststring.h>
 #endif
-#include <cstddef>    // size_t
+#include <cstddef> // size_t
 
-#define JSON_ASSERT_UNREACHABLE assert( false )
+#define JSON_ASSERT_UNREACHABLE assert(false)
 
 namespace Json {
 
 const Value Value::null;
-const Int Value::minInt = Int( ~(UInt(-1)/2) );
-const Int Value::maxInt = Int( UInt(-1)/2 );
+const Int Value::minInt = Int(~(UInt(-1) / 2));
+const Int Value::maxInt = Int(UInt(-1) / 2);
 const UInt Value::maxUInt = UInt(-1);
-# if defined(JSON_HAS_INT64)
-const Int64 Value::minInt64 = Int64( ~(UInt64(-1)/2) );
-const Int64 Value::maxInt64 = Int64( UInt64(-1)/2 );
+#if defined(JSON_HAS_INT64)
+const Int64 Value::minInt64 = Int64(~(UInt64(-1) / 2));
+const Int64 Value::maxInt64 = Int64(UInt64(-1) / 2);
 const UInt64 Value::maxUInt64 = UInt64(-1);
 // The constant is hard-coded because some compiler have trouble
 // converting Value::maxUInt64 to a double correctly (AIX/xlC).
 // Assumes that UInt64 is a 64 bits integer.
 static const double maxUInt64AsDouble = 18446744073709551615.0;
 #endif // defined(JSON_HAS_INT64)
-const LargestInt Value::minLargestInt = LargestInt( ~(LargestUInt(-1)/2) );
-const LargestInt Value::maxLargestInt = LargestInt( LargestUInt(-1)/2 );
+const LargestInt Value::minLargestInt = LargestInt(~(LargestUInt(-1) / 2));
+const LargestInt Value::maxLargestInt = LargestInt(LargestUInt(-1) / 2);
 const LargestUInt Value::maxLargestUInt = LargestUInt(-1);
 
-
 /// Unknown size marker
 static const unsigned int unknown = (unsigned)-1;
 
 #if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
 template <typename T, typename U>
 static inline bool InRange(double d, T min, U max) {
-   return d >= min && d <= max;
+  return d >= min && d <= max;
 }
-#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
-static inline double integerToDouble( Json::UInt64 value )
-{
-    return static_cast<double>( Int64(value/2) ) * 2.0 + Int64(value & 1);
+#else  // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+static inline double integerToDouble(Json::UInt64 value) {
+  return static_cast<double>(Int64(value / 2)) * 2.0 + Int64(value & 1);
 }
 
-template<typename T>
-static inline double integerToDouble( T value )
-{
-    return static_cast<double>( value );
+template <typename T> static inline double integerToDouble(T value) {
+  return static_cast<double>(value);
 }
 
 template <typename T, typename U>
 static inline bool InRange(double d, T min, U max) {
-   return d >= integerToDouble(min) && d <= integerToDouble(max);
+  return d >= integerToDouble(min) && d <= integerToDouble(max);
 }
 #endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
 
-
 /** Duplicates the specified string value.
  * @param value Pointer to the string to duplicate. Must be zero-terminated if
  *              length is "unknown".
@@ -77,38 +72,33 @@
  *               computed using strlen(value).
  * @return Pointer on the duplicate instance of string.
  */
-static inline char *
-duplicateStringValue( const char *value, 
-                      unsigned int length = unknown )
-{
-   if ( length == unknown )
-      length = (unsigned int)strlen(value);
+static inline char *duplicateStringValue(const char *value,
+                                         unsigned int length = unknown) {
+  if (length == unknown)
+    length = (unsigned int)strlen(value);
 
-   // Avoid an integer overflow in the call to malloc below by limiting length
-   // to a sane value.
-   if (length >= (unsigned)Value::maxInt)
-      length = Value::maxInt - 1;
+  // Avoid an integer overflow in the call to malloc below by limiting length
+  // to a sane value.
+  if (length >= (unsigned)Value::maxInt)
+    length = Value::maxInt - 1;
 
-   char *newString = static_cast<char *>( malloc( length + 1 ) );
-   JSON_ASSERT_MESSAGE( newString != 0, "in Json::Value::duplicateStringValue(): Failed to allocate string value buffer" );
-   memcpy( newString, value, length );
-   newString[length] = 0;
-   return newString;
+  char *newString = static_cast<char *>(malloc(length + 1));
+  JSON_ASSERT_MESSAGE(newString != 0, "in Json::Value::duplicateStringValue(): "
+                                      "Failed to allocate string value buffer");
+  memcpy(newString, value, length);
+  newString[length] = 0;
+  return newString;
 }
 
-
 /** Free the string duplicated by duplicateStringValue().
  */
-static inline void 
-releaseStringValue( char *value )
-{
-   if ( value )
-      free( value );
+static inline void releaseStringValue(char *value) {
+  if (value)
+    free(value);
 }
 
 } // namespace Json
 
-
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
@@ -117,12 +107,12 @@
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
 #if !defined(JSON_IS_AMALGAMATION)
-# ifdef JSON_VALUE_USE_INTERNAL_MAP
-#  include "json_internalarray.inl"
-#  include "json_internalmap.inl"
-# endif // JSON_VALUE_USE_INTERNAL_MAP
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+#include "json_internalarray.inl"
+#include "json_internalmap.inl"
+#endif // JSON_VALUE_USE_INTERNAL_MAP
 
-# include "json_valueiterator.inl"
+#include "json_valueiterator.inl"
 #endif // if !defined(JSON_IS_AMALGAMATION)
 
 namespace Json {
@@ -135,31 +125,24 @@
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
 
+Value::CommentInfo::CommentInfo() : comment_(0) {}
 
-Value::CommentInfo::CommentInfo()
-   : comment_( 0 )
-{
+Value::CommentInfo::~CommentInfo() {
+  if (comment_)
+    releaseStringValue(comment_);
 }
 
-Value::CommentInfo::~CommentInfo()
-{
-   if ( comment_ )
-      releaseStringValue( comment_ );
+void Value::CommentInfo::setComment(const char *text) {
+  if (comment_)
+    releaseStringValue(comment_);
+  JSON_ASSERT(text != 0);
+  JSON_ASSERT_MESSAGE(
+      text[0] == '\0' || text[0] == '/',
+      "in Json::Value::setComment(): Comments must start with /");
+  // It seems that /**/ style comments are acceptable as well.
+  comment_ = duplicateStringValue(text);
 }
 
-
-void 
-Value::CommentInfo::setComment( const char *text )
-{
-   if ( comment_ )
-      releaseStringValue( comment_ );
-   JSON_ASSERT( text != 0 );
-   JSON_ASSERT_MESSAGE( text[0]=='\0' || text[0]=='/', "in Json::Value::setComment(): Comments must start with /");
-   // It seems that /**/ style comments are acceptable as well.
-   comment_ = duplicateStringValue( text );
-}
-
-
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
@@ -167,93 +150,61 @@
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
-# ifndef JSON_VALUE_USE_INTERNAL_MAP
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
 
 // Notes: index_ indicates if the string was allocated when
 // a string is stored.
 
-Value::CZString::CZString( ArrayIndex index )
-   : cstr_( 0 )
-   , index_( index )
-{
+Value::CZString::CZString(ArrayIndex index) : cstr_(0), index_(index) {}
+
+Value::CZString::CZString(const char *cstr, DuplicationPolicy allocate)
+    : cstr_(allocate == duplicate ? duplicateStringValue(cstr) : cstr),
+      index_(allocate) {}
+
+Value::CZString::CZString(const CZString &other)
+    : cstr_(other.index_ != noDuplication && other.cstr_ != 0
+                ? duplicateStringValue(other.cstr_)
+                : other.cstr_),
+      index_(other.cstr_
+                 ? (other.index_ == noDuplication ? noDuplication : duplicate)
+                 : other.index_) {}
+
+Value::CZString::~CZString() {
+  if (cstr_ && index_ == duplicate)
+    releaseStringValue(const_cast<char *>(cstr_));
 }
 
-Value::CZString::CZString( const char *cstr, DuplicationPolicy allocate )
-   : cstr_( allocate == duplicate ? duplicateStringValue(cstr) 
-                                  : cstr )
-   , index_( allocate )
-{
+void Value::CZString::swap(CZString &other) {
+  std::swap(cstr_, other.cstr_);
+  std::swap(index_, other.index_);
 }
 
-Value::CZString::CZString( const CZString &other )
-: cstr_( other.index_ != noDuplication &&  other.cstr_ != 0
-                ?  duplicateStringValue( other.cstr_ )
-                : other.cstr_ )
-   , index_( other.cstr_ ? (other.index_ == noDuplication ? noDuplication : duplicate)
-                         : other.index_ )
-{
+Value::CZString &Value::CZString::operator=(const CZString &other) {
+  CZString temp(other);
+  swap(temp);
+  return *this;
 }
 
-Value::CZString::~CZString()
-{
-   if ( cstr_  &&  index_ == duplicate )
-      releaseStringValue( const_cast<char *>( cstr_ ) );
+bool Value::CZString::operator<(const CZString &other) const {
+  if (cstr_)
+    return strcmp(cstr_, other.cstr_) < 0;
+  return index_ < other.index_;
 }
 
-void 
-Value::CZString::swap( CZString &other )
-{
-   std::swap( cstr_, other.cstr_ );
-   std::swap( index_, other.index_ );
+bool Value::CZString::operator==(const CZString &other) const {
+  if (cstr_)
+    return strcmp(cstr_, other.cstr_) == 0;
+  return index_ == other.index_;
 }
 
-Value::CZString &
-Value::CZString::operator =( const CZString &other )
-{
-   CZString temp( other );
-   swap( temp );
-   return *this;
-}
+ArrayIndex Value::CZString::index() const { return index_; }
 
-bool 
-Value::CZString::operator<( const CZString &other ) const 
-{
-   if ( cstr_ )
-      return strcmp( cstr_, other.cstr_ ) < 0;
-   return index_ < other.index_;
-}
+const char *Value::CZString::c_str() const { return cstr_; }
 
-bool 
-Value::CZString::operator==( const CZString &other ) const 
-{
-   if ( cstr_ )
-      return strcmp( cstr_, other.cstr_ ) == 0;
-   return index_ == other.index_;
-}
-
-
-ArrayIndex 
-Value::CZString::index() const
-{
-   return index_;
-}
-
-
-const char *
-Value::CZString::c_str() const
-{
-   return cstr_;
-}
-
-bool 
-Value::CZString::isStaticString() const
-{
-   return index_ == noDuplication;
-}
+bool Value::CZString::isStaticString() const { return index_ == noDuplication; }
 
 #endif // ifndef JSON_VALUE_USE_INTERNAL_MAP
 
-
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
@@ -266,1115 +217,906 @@
  * memset( this, 0, sizeof(Value) )
  * This optimization is used in ValueInternalMap fast allocator.
  */
-Value::Value( ValueType type )
-   : type_( type )
-   , allocated_( false )
-# ifdef JSON_VALUE_USE_INTERNAL_MAP
-   , itemIsUsed_( 0 )
+Value::Value(ValueType type)
+    : type_(type), allocated_(false)
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+      ,
+      itemIsUsed_(0)
 #endif
-   , comments_( 0 )
-   , start_( 0 )
-   , limit_( 0 )
-{
-   switch ( type )
-   {
-   case nullValue:
-      break;
-   case intValue:
-   case uintValue:
-      value_.int_ = 0;
-      break;
-   case realValue:
-      value_.real_ = 0.0;
-      break;
-   case stringValue:
-      value_.string_ = 0;
-      break;
+      ,
+      comments_(0), start_(0), limit_(0) {
+  switch (type) {
+  case nullValue:
+    break;
+  case intValue:
+  case uintValue:
+    value_.int_ = 0;
+    break;
+  case realValue:
+    value_.real_ = 0.0;
+    break;
+  case stringValue:
+    value_.string_ = 0;
+    break;
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
-   case arrayValue:
-   case objectValue:
-      value_.map_ = new ObjectValues();
-      break;
+  case arrayValue:
+  case objectValue:
+    value_.map_ = new ObjectValues();
+    break;
 #else
-   case arrayValue:
-      value_.array_ = arrayAllocator()->newArray();
-      break;
-   case objectValue:
-      value_.map_ = mapAllocator()->newMap();
-      break;
+  case arrayValue:
+    value_.array_ = arrayAllocator()->newArray();
+    break;
+  case objectValue:
+    value_.map_ = mapAllocator()->newMap();
+    break;
 #endif
-   case booleanValue:
-      value_.bool_ = false;
-      break;
-   default:
-      JSON_ASSERT_UNREACHABLE;
-   }
+  case booleanValue:
+    value_.bool_ = false;
+    break;
+  default:
+    JSON_ASSERT_UNREACHABLE;
+  }
 }
 
-
-Value::Value( UInt value )
-   : type_( uintValue )
-   , allocated_( false )
-# ifdef JSON_VALUE_USE_INTERNAL_MAP
-   , itemIsUsed_( 0 )
+Value::Value(UInt value)
+    : type_(uintValue), allocated_(false)
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+      ,
+      itemIsUsed_(0)
 #endif
-   , comments_( 0 )
-   , start_( 0 )
-   , limit_( 0 )
-{
-   value_.uint_ = value;
+      ,
+      comments_(0), start_(0), limit_(0) {
+  value_.uint_ = value;
 }
 
-Value::Value( Int value )
-   : type_( intValue )
-   , allocated_( false )
-# ifdef JSON_VALUE_USE_INTERNAL_MAP
-   , itemIsUsed_( 0 )
+Value::Value(Int value)
+    : type_(intValue), allocated_(false)
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+      ,
+      itemIsUsed_(0)
 #endif
-   , comments_( 0 )
-   , start_( 0 )
-   , limit_( 0 )
-{
-   value_.int_ = value;
+      ,
+      comments_(0), start_(0), limit_(0) {
+  value_.int_ = value;
 }
 
-
-# if defined(JSON_HAS_INT64)
-Value::Value( Int64 value )
-   : type_( intValue )
-   , allocated_( false )
-# ifdef JSON_VALUE_USE_INTERNAL_MAP
-   , itemIsUsed_( 0 )
+#if defined(JSON_HAS_INT64)
+Value::Value(Int64 value)
+    : type_(intValue), allocated_(false)
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+      ,
+      itemIsUsed_(0)
 #endif
-   , comments_( 0 )
-   , start_( 0 )
-   , limit_( 0 )
-{
-   value_.int_ = value;
+      ,
+      comments_(0), start_(0), limit_(0) {
+  value_.int_ = value;
 }
 
-
-Value::Value( UInt64 value )
-   : type_( uintValue )
-   , allocated_( false )
-# ifdef JSON_VALUE_USE_INTERNAL_MAP
-   , itemIsUsed_( 0 )
+Value::Value(UInt64 value)
+    : type_(uintValue), allocated_(false)
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+      ,
+      itemIsUsed_(0)
 #endif
-   , comments_( 0 )
-   , start_( 0 )
-   , limit_( 0 )
-{
-   value_.uint_ = value;
+      ,
+      comments_(0), start_(0), limit_(0) {
+  value_.uint_ = value;
 }
 #endif // defined(JSON_HAS_INT64)
 
-Value::Value( double value )
-   : type_( realValue )
-   , allocated_( false )
-# ifdef JSON_VALUE_USE_INTERNAL_MAP
-   , itemIsUsed_( 0 )
+Value::Value(double value)
+    : type_(realValue), allocated_(false)
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+      ,
+      itemIsUsed_(0)
 #endif
-   , comments_( 0 )
-   , start_( 0 )
-   , limit_( 0 )
-{
-   value_.real_ = value;
+      ,
+      comments_(0), start_(0), limit_(0) {
+  value_.real_ = value;
 }
 
-Value::Value( const char *value )
-   : type_( stringValue )
-   , allocated_( true )
-# ifdef JSON_VALUE_USE_INTERNAL_MAP
-   , itemIsUsed_( 0 )
+Value::Value(const char *value)
+    : type_(stringValue), allocated_(true)
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+      ,
+      itemIsUsed_(0)
 #endif
-   , comments_( 0 )
-   , start_( 0 )
-   , limit_( 0 )
-{
-   value_.string_ = duplicateStringValue( value );
+      ,
+      comments_(0), start_(0), limit_(0) {
+  value_.string_ = duplicateStringValue(value);
 }
 
-
-Value::Value( const char *beginValue, 
-              const char *endValue )
-   : type_( stringValue )
-   , allocated_( true )
-# ifdef JSON_VALUE_USE_INTERNAL_MAP
-   , itemIsUsed_( 0 )
+Value::Value(const char *beginValue, const char *endValue)
+    : type_(stringValue), allocated_(true)
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+      ,
+      itemIsUsed_(0)
 #endif
-   , comments_( 0 )
-   , start_( 0 )
-   , limit_( 0 )
-{
-   value_.string_ = duplicateStringValue( beginValue, 
-                                          (unsigned int)(endValue - beginValue) );
+      ,
+      comments_(0), start_(0), limit_(0) {
+  value_.string_ =
+      duplicateStringValue(beginValue, (unsigned int)(endValue - beginValue));
 }
 
-
-Value::Value( const std::string &value )
-   : type_( stringValue )
-   , allocated_( true )
-# ifdef JSON_VALUE_USE_INTERNAL_MAP
-   , itemIsUsed_( 0 )
+Value::Value(const std::string &value)
+    : type_(stringValue), allocated_(true)
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+      ,
+      itemIsUsed_(0)
 #endif
-   , comments_( 0 )
-   , start_( 0 )
-   , limit_( 0 )
-{
-   value_.string_ = duplicateStringValue( value.c_str(), 
-                                          (unsigned int)value.length() );
-
+      ,
+      comments_(0), start_(0), limit_(0) {
+  value_.string_ =
+      duplicateStringValue(value.c_str(), (unsigned int)value.length());
 }
 
-Value::Value( const StaticString &value )
-   : type_( stringValue )
-   , allocated_( false )
-# ifdef JSON_VALUE_USE_INTERNAL_MAP
-   , itemIsUsed_( 0 )
+Value::Value(const StaticString &value)
+    : type_(stringValue), allocated_(false)
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+      ,
+      itemIsUsed_(0)
 #endif
-   , comments_( 0 )
-   , start_( 0 )
-   , limit_( 0 )
-{
-   value_.string_ = const_cast<char *>( value.c_str() );
+      ,
+      comments_(0), start_(0), limit_(0) {
+  value_.string_ = const_cast<char *>(value.c_str());
 }
 
-
-# ifdef JSON_USE_CPPTL
-Value::Value( const CppTL::ConstString &value )
-   : type_( stringValue )
-   , allocated_( true )
-# ifdef JSON_VALUE_USE_INTERNAL_MAP
-   , itemIsUsed_( 0 )
+#ifdef JSON_USE_CPPTL
+Value::Value(const CppTL::ConstString &value)
+    : type_(stringValue), allocated_(true)
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+      ,
+      itemIsUsed_(0)
 #endif
-   , comments_( 0 )
-   , start_( 0 )
-   , limit_( 0 )
-{
-   value_.string_ = duplicateStringValue( value, value.length() );
+      ,
+      comments_(0), start_(0), limit_(0) {
+  value_.string_ = duplicateStringValue(value, value.length());
 }
-# endif
-
-Value::Value( bool value )
-   : type_( booleanValue )
-   , allocated_( false )
-# ifdef JSON_VALUE_USE_INTERNAL_MAP
-   , itemIsUsed_( 0 )
 #endif
-   , comments_( 0 )
-   , start_( 0 )
-   , limit_( 0 )
-{
-   value_.bool_ = value;
+
+Value::Value(bool value)
+    : type_(booleanValue), allocated_(false)
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+      ,
+      itemIsUsed_(0)
+#endif
+      ,
+      comments_(0), start_(0), limit_(0) {
+  value_.bool_ = value;
 }
 
-
-Value::Value( const Value &other )
-   : type_( other.type_ )
-   , allocated_( false )
-# ifdef JSON_VALUE_USE_INTERNAL_MAP
-   , itemIsUsed_( 0 )
+Value::Value(const Value &other)
+    : type_(other.type_), allocated_(false)
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+      ,
+      itemIsUsed_(0)
 #endif
-   , comments_( 0 )
-   , start_( other.start_ )
-   , limit_( other.limit_ )
-{
-   switch ( type_ )
-   {
-   case nullValue:
-   case intValue:
-   case uintValue:
-   case realValue:
-   case booleanValue:
-      value_ = other.value_;
-      break;
-   case stringValue:
-      if ( other.value_.string_ )
-      {
-         value_.string_ = duplicateStringValue( other.value_.string_ );
-         allocated_ = true;
-      }
-      else
-      {
-         value_.string_ = 0;
-         allocated_ = false;
-      }
-      break;
+      ,
+      comments_(0), start_(other.start_), limit_(other.limit_) {
+  switch (type_) {
+  case nullValue:
+  case intValue:
+  case uintValue:
+  case realValue:
+  case booleanValue:
+    value_ = other.value_;
+    break;
+  case stringValue:
+    if (other.value_.string_) {
+      value_.string_ = duplicateStringValue(other.value_.string_);
+      allocated_ = true;
+    } else {
+      value_.string_ = 0;
+      allocated_ = false;
+    }
+    break;
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
-   case arrayValue:
-   case objectValue:
-      value_.map_ = new ObjectValues( *other.value_.map_ );
-      break;
+  case arrayValue:
+  case objectValue:
+    value_.map_ = new ObjectValues(*other.value_.map_);
+    break;
 #else
-   case arrayValue:
-      value_.array_ = arrayAllocator()->newArrayCopy( *other.value_.array_ );
-      break;
-   case objectValue:
-      value_.map_ = mapAllocator()->newMapCopy( *other.value_.map_ );
-      break;
+  case arrayValue:
+    value_.array_ = arrayAllocator()->newArrayCopy(*other.value_.array_);
+    break;
+  case objectValue:
+    value_.map_ = mapAllocator()->newMapCopy(*other.value_.map_);
+    break;
 #endif
-   default:
-      JSON_ASSERT_UNREACHABLE;
-   }
-   if ( other.comments_ )
-   {
-      comments_ = new CommentInfo[numberOfCommentPlacement];
-      for ( int comment =0; comment < numberOfCommentPlacement; ++comment )
-      {
-         const CommentInfo &otherComment = other.comments_[comment];
-         if ( otherComment.comment_ )
-            comments_[comment].setComment( otherComment.comment_ );
-      }
-   }
+  default:
+    JSON_ASSERT_UNREACHABLE;
+  }
+  if (other.comments_) {
+    comments_ = new CommentInfo[numberOfCommentPlacement];
+    for (int comment = 0; comment < numberOfCommentPlacement; ++comment) {
+      const CommentInfo &otherComment = other.comments_[comment];
+      if (otherComment.comment_)
+        comments_[comment].setComment(otherComment.comment_);
+    }
+  }
 }
 
-
-Value::~Value()
-{
-   switch ( type_ )
-   {
-   case nullValue:
-   case intValue:
-   case uintValue:
-   case realValue:
-   case booleanValue:
-      break;
-   case stringValue:
-      if ( allocated_ )
-         releaseStringValue( value_.string_ );
-      break;
+Value::~Value() {
+  switch (type_) {
+  case nullValue:
+  case intValue:
+  case uintValue:
+  case realValue:
+  case booleanValue:
+    break;
+  case stringValue:
+    if (allocated_)
+      releaseStringValue(value_.string_);
+    break;
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
-   case arrayValue:
-   case objectValue:
-      delete value_.map_;
-      break;
+  case arrayValue:
+  case objectValue:
+    delete value_.map_;
+    break;
 #else
-   case arrayValue:
-      arrayAllocator()->destructArray( value_.array_ );
-      break;
-   case objectValue:
-      mapAllocator()->destructMap( value_.map_ );
-      break;
+  case arrayValue:
+    arrayAllocator()->destructArray(value_.array_);
+    break;
+  case objectValue:
+    mapAllocator()->destructMap(value_.map_);
+    break;
 #endif
-   default:
-      JSON_ASSERT_UNREACHABLE;
-   }
+  default:
+    JSON_ASSERT_UNREACHABLE;
+  }
 
-   if ( comments_ )
-      delete[] comments_;
+  if (comments_)
+    delete[] comments_;
 }
 
-Value &
-Value::operator=( const Value &other )
-{
-   Value temp( other );
-   swap( temp );
-   return *this;
+Value &Value::operator=(const Value &other) {
+  Value temp(other);
+  swap(temp);
+  return *this;
 }
 
-void 
-Value::swap( Value &other )
-{
-   ValueType temp = type_;
-   type_ = other.type_;
-   other.type_ = temp;
-   std::swap( value_, other.value_ );
-   int temp2 = allocated_;
-   allocated_ = other.allocated_;
-   other.allocated_ = temp2;
-   std::swap( start_, other.start_ );
-   std::swap( limit_, other.limit_ );
+void Value::swap(Value &other) {
+  ValueType temp = type_;
+  type_ = other.type_;
+  other.type_ = temp;
+  std::swap(value_, other.value_);
+  int temp2 = allocated_;
+  allocated_ = other.allocated_;
+  other.allocated_ = temp2;
+  std::swap(start_, other.start_);
+  std::swap(limit_, other.limit_);
 }
 
-ValueType 
-Value::type() const
-{
-   return type_;
+ValueType Value::type() const { return type_; }
+
+int Value::compare(const Value &other) const {
+  if (*this < other)
+    return -1;
+  if (*this > other)
+    return 1;
+  return 0;
 }
 
-
-int 
-Value::compare( const Value &other ) const
-{
-   if ( *this < other )
-      return -1;
-   if ( *this > other )
-      return 1;
-   return 0;
-}
-
-
-bool 
-Value::operator <( const Value &other ) const
-{
-   int typeDelta = type_ - other.type_;
-   if ( typeDelta )
-      return typeDelta < 0 ? true : false;
-   switch ( type_ )
-   {
-   case nullValue:
-      return false;
-   case intValue:
-      return value_.int_ < other.value_.int_;
-   case uintValue:
-      return value_.uint_ < other.value_.uint_;
-   case realValue:
-      return value_.real_ < other.value_.real_;
-   case booleanValue:
-      return value_.bool_ < other.value_.bool_;
-   case stringValue:
-      return ( value_.string_ == 0  &&  other.value_.string_ )
-             || ( other.value_.string_  
-                  &&  value_.string_  
-                  && strcmp( value_.string_, other.value_.string_ ) < 0 );
+bool Value::operator<(const Value &other) const {
+  int typeDelta = type_ - other.type_;
+  if (typeDelta)
+    return typeDelta < 0 ? true : false;
+  switch (type_) {
+  case nullValue:
+    return false;
+  case intValue:
+    return value_.int_ < other.value_.int_;
+  case uintValue:
+    return value_.uint_ < other.value_.uint_;
+  case realValue:
+    return value_.real_ < other.value_.real_;
+  case booleanValue:
+    return value_.bool_ < other.value_.bool_;
+  case stringValue:
+    return (value_.string_ == 0 && other.value_.string_) ||
+           (other.value_.string_ && value_.string_ &&
+            strcmp(value_.string_, other.value_.string_) < 0);
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
-   case arrayValue:
-   case objectValue:
-      {
-         int delta = int( value_.map_->size() - other.value_.map_->size() );
-         if ( delta )
-            return delta < 0;
-         return (*value_.map_) < (*other.value_.map_);
-      }
+  case arrayValue:
+  case objectValue: {
+    int delta = int(value_.map_->size() - other.value_.map_->size());
+    if (delta)
+      return delta < 0;
+    return (*value_.map_) < (*other.value_.map_);
+  }
 #else
-   case arrayValue:
-      return value_.array_->compare( *(other.value_.array_) ) < 0;
-   case objectValue:
-      return value_.map_->compare( *(other.value_.map_) ) < 0;
+  case arrayValue:
+    return value_.array_->compare(*(other.value_.array_)) < 0;
+  case objectValue:
+    return value_.map_->compare(*(other.value_.map_)) < 0;
 #endif
-   default:
-      JSON_ASSERT_UNREACHABLE;
-   }
-   return false;  // unreachable
+  default:
+    JSON_ASSERT_UNREACHABLE;
+  }
+  return false; // unreachable
 }
 
-bool 
-Value::operator <=( const Value &other ) const
-{
-   return !(other < *this);
-}
+bool Value::operator<=(const Value &other) const { return !(other < *this); }
 
-bool 
-Value::operator >=( const Value &other ) const
-{
-   return !(*this < other);
-}
+bool Value::operator>=(const Value &other) const { return !(*this < other); }
 
-bool 
-Value::operator >( const Value &other ) const
-{
-   return other < *this;
-}
+bool Value::operator>(const Value &other) const { return other < *this; }
 
-bool 
-Value::operator ==( const Value &other ) const
-{
-   //if ( type_ != other.type_ )
-   // GCC 2.95.3 says:
-   // attempt to take address of bit-field structure member `Json::Value::type_'
-   // Beats me, but a temp solves the problem.
-   int temp = other.type_;
-   if ( type_ != temp )
-      return false;
-   switch ( type_ )
-   {
-   case nullValue:
-      return true;
-   case intValue:
-      return value_.int_ == other.value_.int_;
-   case uintValue:
-      return value_.uint_ == other.value_.uint_;
-   case realValue:
-      return value_.real_ == other.value_.real_;
-   case booleanValue:
-      return value_.bool_ == other.value_.bool_;
-   case stringValue:
-      return ( value_.string_ == other.value_.string_ )
-             || ( other.value_.string_  
-                  &&  value_.string_  
-                  && strcmp( value_.string_, other.value_.string_ ) == 0 );
+bool Value::operator==(const Value &other) const {
+  // if ( type_ != other.type_ )
+  // GCC 2.95.3 says:
+  // attempt to take address of bit-field structure member `Json::Value::type_'
+  // Beats me, but a temp solves the problem.
+  int temp = other.type_;
+  if (type_ != temp)
+    return false;
+  switch (type_) {
+  case nullValue:
+    return true;
+  case intValue:
+    return value_.int_ == other.value_.int_;
+  case uintValue:
+    return value_.uint_ == other.value_.uint_;
+  case realValue:
+    return value_.real_ == other.value_.real_;
+  case booleanValue:
+    return value_.bool_ == other.value_.bool_;
+  case stringValue:
+    return (value_.string_ == other.value_.string_) ||
+           (other.value_.string_ && value_.string_ &&
+            strcmp(value_.string_, other.value_.string_) == 0);
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
-   case arrayValue:
-   case objectValue:
-      return value_.map_->size() == other.value_.map_->size()
-             && (*value_.map_) == (*other.value_.map_);
+  case arrayValue:
+  case objectValue:
+    return value_.map_->size() == other.value_.map_->size() &&
+           (*value_.map_) == (*other.value_.map_);
 #else
-   case arrayValue:
-      return value_.array_->compare( *(other.value_.array_) ) == 0;
-   case objectValue:
-      return value_.map_->compare( *(other.value_.map_) ) == 0;
+  case arrayValue:
+    return value_.array_->compare(*(other.value_.array_)) == 0;
+  case objectValue:
+    return value_.map_->compare(*(other.value_.map_)) == 0;
 #endif
-   default:
-      JSON_ASSERT_UNREACHABLE;
-   }
-   return false;  // unreachable
+  default:
+    JSON_ASSERT_UNREACHABLE;
+  }
+  return false; // unreachable
 }
 
-bool 
-Value::operator !=( const Value &other ) const
-{
-   return !( *this == other );
+bool Value::operator!=(const Value &other) const { return !(*this == other); }
+
+const char *Value::asCString() const {
+  JSON_ASSERT_MESSAGE(type_ == stringValue,
+                      "in Json::Value::asCString(): requires stringValue");
+  return value_.string_;
 }
 
-const char *
-Value::asCString() const
-{
-   JSON_ASSERT_MESSAGE( type_ == stringValue, "in Json::Value::asCString(): requires stringValue" );
-   return value_.string_;
+std::string Value::asString() const {
+  switch (type_) {
+  case nullValue:
+    return "";
+  case stringValue:
+    return value_.string_ ? value_.string_ : "";
+  case booleanValue:
+    return value_.bool_ ? "true" : "false";
+  case intValue:
+    return valueToString(value_.int_);
+  case uintValue:
+    return valueToString(value_.uint_);
+  case realValue:
+    return valueToString(value_.real_);
+  default:
+    JSON_FAIL_MESSAGE("Type is not convertible to string");
+  }
 }
 
+#ifdef JSON_USE_CPPTL
+CppTL::ConstString Value::asConstString() const {
+  return CppTL::ConstString(asString().c_str());
+}
+#endif
 
-std::string 
-Value::asString() const
-{
-   switch ( type_ )
-   {
-   case nullValue:
-      return "";
-   case stringValue:
-      return value_.string_ ? value_.string_ : "";
-   case booleanValue:
-      return value_.bool_ ? "true" : "false";
-   case intValue:
-      return valueToString( value_.int_ );
-   case uintValue:
-      return valueToString( value_.uint_ );
-   case realValue:
-      return valueToString( value_.real_ );
-   default:
-      JSON_FAIL_MESSAGE( "Type is not convertible to string" );
-   }
+Value::Int Value::asInt() const {
+  switch (type_) {
+  case intValue:
+    JSON_ASSERT_MESSAGE(isInt(), "LargestInt out of Int range");
+    return Int(value_.int_);
+  case uintValue:
+    JSON_ASSERT_MESSAGE(isInt(), "LargestUInt out of Int range");
+    return Int(value_.uint_);
+  case realValue:
+    JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt, maxInt),
+                        "double out of Int range");
+    return Int(value_.real_);
+  case nullValue:
+    return 0;
+  case booleanValue:
+    return value_.bool_ ? 1 : 0;
+  default:
+    break;
+  }
+  JSON_FAIL_MESSAGE("Value is not convertible to Int.");
 }
 
-# ifdef JSON_USE_CPPTL
-CppTL::ConstString 
-Value::asConstString() const
-{
-   return CppTL::ConstString( asString().c_str() );
-}
-# endif
-
-
-Value::Int 
-Value::asInt() const
-{
-   switch ( type_ )
-   {
-   case intValue:
-      JSON_ASSERT_MESSAGE(isInt(), "LargestInt out of Int range");
-      return Int(value_.int_);
-   case uintValue:
-      JSON_ASSERT_MESSAGE(isInt(), "LargestUInt out of Int range");
-      return Int(value_.uint_);
-   case realValue:
-      JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt, maxInt), "double out of Int range");
-      return Int(value_.real_);
-   case nullValue:
-      return 0;
-   case booleanValue:
-      return value_.bool_ ? 1 : 0;
-   default:
-      break;
-   }
-   JSON_FAIL_MESSAGE("Value is not convertible to Int.");
+Value::UInt Value::asUInt() const {
+  switch (type_) {
+  case intValue:
+    JSON_ASSERT_MESSAGE(isUInt(), "LargestInt out of UInt range");
+    return UInt(value_.int_);
+  case uintValue:
+    JSON_ASSERT_MESSAGE(isUInt(), "LargestUInt out of UInt range");
+    return UInt(value_.uint_);
+  case realValue:
+    JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt),
+                        "double out of UInt range");
+    return UInt(value_.real_);
+  case nullValue:
+    return 0;
+  case booleanValue:
+    return value_.bool_ ? 1 : 0;
+  default:
+    break;
+  }
+  JSON_FAIL_MESSAGE("Value is not convertible to UInt.");
 }
 
+#if defined(JSON_HAS_INT64)
 
-Value::UInt 
-Value::asUInt() const
-{
-   switch ( type_ )
-   {
-   case intValue:
-      JSON_ASSERT_MESSAGE(isUInt(), "LargestInt out of UInt range");
-      return UInt(value_.int_);
-   case uintValue:
-      JSON_ASSERT_MESSAGE(isUInt(), "LargestUInt out of UInt range");
-      return UInt(value_.uint_);
-   case realValue:
-      JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt), "double out of UInt range");
-      return UInt( value_.real_ );
-   case nullValue:
-      return 0;
-   case booleanValue:
-      return value_.bool_ ? 1 : 0;
-   default:
-      break;
-   }
-   JSON_FAIL_MESSAGE("Value is not convertible to UInt.");
+Value::Int64 Value::asInt64() const {
+  switch (type_) {
+  case intValue:
+    return Int64(value_.int_);
+  case uintValue:
+    JSON_ASSERT_MESSAGE(isInt64(), "LargestUInt out of Int64 range");
+    return Int64(value_.uint_);
+  case realValue:
+    JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt64, maxInt64),
+                        "double out of Int64 range");
+    return Int64(value_.real_);
+  case nullValue:
+    return 0;
+  case booleanValue:
+    return value_.bool_ ? 1 : 0;
+  default:
+    break;
+  }
+  JSON_FAIL_MESSAGE("Value is not convertible to Int64.");
 }
 
-
-# if defined(JSON_HAS_INT64)
-
-Value::Int64
-Value::asInt64() const
-{
-   switch ( type_ )
-   {
-   case intValue:
-      return Int64(value_.int_);
-   case uintValue:
-      JSON_ASSERT_MESSAGE(isInt64(), "LargestUInt out of Int64 range");
-      return Int64(value_.uint_);
-   case realValue:
-      JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt64, maxInt64), "double out of Int64 range");
-      return Int64(value_.real_);
-   case nullValue:
-      return 0;
-   case booleanValue:
-      return value_.bool_ ? 1 : 0;
-   default:
-      break;
-   }
-   JSON_FAIL_MESSAGE("Value is not convertible to Int64.");
+Value::UInt64 Value::asUInt64() const {
+  switch (type_) {
+  case intValue:
+    JSON_ASSERT_MESSAGE(isUInt64(), "LargestInt out of UInt64 range");
+    return UInt64(value_.int_);
+  case uintValue:
+    return UInt64(value_.uint_);
+  case realValue:
+    JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt64),
+                        "double out of UInt64 range");
+    return UInt64(value_.real_);
+  case nullValue:
+    return 0;
+  case booleanValue:
+    return value_.bool_ ? 1 : 0;
+  default:
+    break;
+  }
+  JSON_FAIL_MESSAGE("Value is not convertible to UInt64.");
 }
+#endif // if defined(JSON_HAS_INT64)
 
-
-Value::UInt64
-Value::asUInt64() const
-{
-   switch ( type_ )
-   {
-   case intValue:
-      JSON_ASSERT_MESSAGE(isUInt64(), "LargestInt out of UInt64 range");
-      return UInt64(value_.int_);
-   case uintValue:
-      return UInt64(value_.uint_);
-   case realValue:
-      JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt64), "double out of UInt64 range");
-      return UInt64( value_.real_ );
-   case nullValue:
-      return 0;
-   case booleanValue:
-      return value_.bool_ ? 1 : 0;
-   default:
-      break;
-   }
-   JSON_FAIL_MESSAGE("Value is not convertible to UInt64.");
-}
-# endif // if defined(JSON_HAS_INT64)
-
-
-LargestInt 
-Value::asLargestInt() const
-{
+LargestInt Value::asLargestInt() const {
 #if defined(JSON_NO_INT64)
-    return asInt();
+  return asInt();
 #else
-    return asInt64();
+  return asInt64();
 #endif
 }
 
-
-LargestUInt 
-Value::asLargestUInt() const
-{
+LargestUInt Value::asLargestUInt() const {
 #if defined(JSON_NO_INT64)
-    return asUInt();
+  return asUInt();
 #else
-    return asUInt64();
+  return asUInt64();
 #endif
 }
 
-
-double 
-Value::asDouble() const
-{
-   switch ( type_ )
-   {
-   case intValue:
-      return static_cast<double>( value_.int_ );
-   case uintValue:
+double Value::asDouble() const {
+  switch (type_) {
+  case intValue:
+    return static_cast<double>(value_.int_);
+  case uintValue:
 #if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
-      return static_cast<double>( value_.uint_ );
-#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
-      return integerToDouble( value_.uint_ );
+    return static_cast<double>(value_.uint_);
+#else  // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+    return integerToDouble(value_.uint_);
 #endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
-   case realValue:
-      return value_.real_;
-   case nullValue:
-      return 0.0;
-   case booleanValue:
-      return value_.bool_ ? 1.0 : 0.0;
-   default:
-      break;
-   }
-   JSON_FAIL_MESSAGE("Value is not convertible to double.");
+  case realValue:
+    return value_.real_;
+  case nullValue:
+    return 0.0;
+  case booleanValue:
+    return value_.bool_ ? 1.0 : 0.0;
+  default:
+    break;
+  }
+  JSON_FAIL_MESSAGE("Value is not convertible to double.");
 }
 
-float
-Value::asFloat() const
-{
-   switch ( type_ )
-   {
-   case intValue:
-      return static_cast<float>( value_.int_ );
-   case uintValue:
+float Value::asFloat() const {
+  switch (type_) {
+  case intValue:
+    return static_cast<float>(value_.int_);
+  case uintValue:
 #if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
-      return static_cast<float>( value_.uint_ );
-#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
-      return integerToDouble( value_.uint_ );
+    return static_cast<float>(value_.uint_);
+#else  // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+    return integerToDouble(value_.uint_);
 #endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
-   case realValue:
-      return static_cast<float>( value_.real_ );
-   case nullValue:
-      return 0.0;
-   case booleanValue:
-      return value_.bool_ ? 1.0f : 0.0f;
-   default:
-      break;
-   }
-   JSON_FAIL_MESSAGE("Value is not convertible to float.");
+  case realValue:
+    return static_cast<float>(value_.real_);
+  case nullValue:
+    return 0.0;
+  case booleanValue:
+    return value_.bool_ ? 1.0f : 0.0f;
+  default:
+    break;
+  }
+  JSON_FAIL_MESSAGE("Value is not convertible to float.");
 }
 
-bool 
-Value::asBool() const
-{
-   switch ( type_ )
-   {
-   case booleanValue:
-      return value_.bool_;
-   case nullValue:
-      return false;
-   case intValue:
-      return value_.int_ ? true : false;
-   case uintValue:
-      return value_.uint_ ? true : false;
-   case realValue:
-      return value_.real_ ? true : false;
-   default:
-      break;
-   }
-   JSON_FAIL_MESSAGE("Value is not convertible to bool.");
+bool Value::asBool() const {
+  switch (type_) {
+  case booleanValue:
+    return value_.bool_;
+  case nullValue:
+    return false;
+  case intValue:
+    return value_.int_ ? true : false;
+  case uintValue:
+    return value_.uint_ ? true : false;
+  case realValue:
+    return value_.real_ ? true : false;
+  default:
+    break;
+  }
+  JSON_FAIL_MESSAGE("Value is not convertible to bool.");
 }
 
-
-bool 
-Value::isConvertibleTo( ValueType other ) const
-{
-   switch ( other )
-   {
-   case nullValue:
-      return ( isNumeric() && asDouble() == 0.0 )
-             || ( type_ == booleanValue && value_.bool_ == false )
-             || ( type_ == stringValue && asString() == "" )
-             || ( type_ == arrayValue && value_.map_->size() == 0 )
-             || ( type_ == objectValue && value_.map_->size() == 0 )
-             || type_ == nullValue;
-   case intValue:
-      return isInt()
-             || (type_ == realValue && InRange(value_.real_, minInt, maxInt))
-             || type_ == booleanValue
-             || type_ == nullValue;
-   case uintValue:
-      return isUInt()
-             || (type_ == realValue && InRange(value_.real_, 0, maxUInt))
-             || type_ == booleanValue
-             || type_ == nullValue;
-   case realValue:
-      return isNumeric()
-             || type_ == booleanValue
-             || type_ == nullValue;
-   case booleanValue:
-      return isNumeric()
-             || type_ == booleanValue
-             || type_ == nullValue;
-   case stringValue:
-      return isNumeric()
-             || type_ == booleanValue
-             || type_ == stringValue
-             || type_ == nullValue;
-   case arrayValue:
-      return type_ == arrayValue
-             || type_ == nullValue;
-   case objectValue:
-      return type_ == objectValue
-             || type_ == nullValue;
-   }
-   JSON_ASSERT_UNREACHABLE;
-   return false;
+bool Value::isConvertibleTo(ValueType other) const {
+  switch (other) {
+  case nullValue:
+    return (isNumeric() && asDouble() == 0.0) ||
+           (type_ == booleanValue && value_.bool_ == false) ||
+           (type_ == stringValue && asString() == "") ||
+           (type_ == arrayValue && value_.map_->size() == 0) ||
+           (type_ == objectValue && value_.map_->size() == 0) ||
+           type_ == nullValue;
+  case intValue:
+    return isInt() ||
+           (type_ == realValue && InRange(value_.real_, minInt, maxInt)) ||
+           type_ == booleanValue || type_ == nullValue;
+  case uintValue:
+    return isUInt() ||
+           (type_ == realValue && InRange(value_.real_, 0, maxUInt)) ||
+           type_ == booleanValue || type_ == nullValue;
+  case realValue:
+    return isNumeric() || type_ == booleanValue || type_ == nullValue;
+  case booleanValue:
+    return isNumeric() || type_ == booleanValue || type_ == nullValue;
+  case stringValue:
+    return isNumeric() || type_ == booleanValue || type_ == stringValue ||
+           type_ == nullValue;
+  case arrayValue:
+    return type_ == arrayValue || type_ == nullValue;
+  case objectValue:
+    return type_ == objectValue || type_ == nullValue;
+  }
+  JSON_ASSERT_UNREACHABLE;
+  return false;
 }
 
-
 /// Number of values in array or object
-ArrayIndex 
-Value::size() const
-{
-   switch ( type_ )
-   {
-   case nullValue:
-   case intValue:
-   case uintValue:
-   case realValue:
-   case booleanValue:
-   case stringValue:
-      return 0;
+ArrayIndex Value::size() const {
+  switch (type_) {
+  case nullValue:
+  case intValue:
+  case uintValue:
+  case realValue:
+  case booleanValue:
+  case stringValue:
+    return 0;
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
-   case arrayValue:  // size of the array is highest index + 1
-      if ( !value_.map_->empty() )
-      {
-         ObjectValues::const_iterator itLast = value_.map_->end();
-         --itLast;
-         return (*itLast).first.index()+1;
-      }
-      return 0;
-   case objectValue:
-      return ArrayIndex( value_.map_->size() );
+  case arrayValue: // size of the array is highest index + 1
+    if (!value_.map_->empty()) {
+      ObjectValues::const_iterator itLast = value_.map_->end();
+      --itLast;
+      return (*itLast).first.index() + 1;
+    }
+    return 0;
+  case objectValue:
+    return ArrayIndex(value_.map_->size());
 #else
-   case arrayValue:
-      return Int( value_.array_->size() );
-   case objectValue:
-      return Int( value_.map_->size() );
+  case arrayValue:
+    return Int(value_.array_->size());
+  case objectValue:
+    return Int(value_.map_->size());
 #endif
-   }
-   JSON_ASSERT_UNREACHABLE;
-   return 0; // unreachable;
+  }
+  JSON_ASSERT_UNREACHABLE;
+  return 0; // unreachable;
 }
 
-
-bool 
-Value::empty() const
-{
-   if ( isNull() || isArray() || isObject() )
-      return size() == 0u;
-   else
-      return false;
+bool Value::empty() const {
+  if (isNull() || isArray() || isObject())
+    return size() == 0u;
+  else
+    return false;
 }
 
+bool Value::operator!() const { return isNull(); }
 
-bool
-Value::operator!() const
-{
-   return isNull();
-}
-
-
-void 
-Value::clear()
-{
-   JSON_ASSERT_MESSAGE( type_ == nullValue  ||  type_ == arrayValue  || type_ == objectValue, "in Json::Value::clear(): requires complex value" );
-   start_ = 0;
-   limit_ = 0;
-   switch ( type_ )
-   {
+void Value::clear() {
+  JSON_ASSERT_MESSAGE(type_ == nullValue || type_ == arrayValue ||
+                          type_ == objectValue,
+                      "in Json::Value::clear(): requires complex value");
+  start_ = 0;
+  limit_ = 0;
+  switch (type_) {
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
-   case arrayValue:
-   case objectValue:
-      value_.map_->clear();
-      break;
+  case arrayValue:
+  case objectValue:
+    value_.map_->clear();
+    break;
 #else
-   case arrayValue:
-      value_.array_->clear();
-      break;
-   case objectValue:
-      value_.map_->clear();
-      break;
+  case arrayValue:
+    value_.array_->clear();
+    break;
+  case objectValue:
+    value_.map_->clear();
+    break;
 #endif
-   default:
-      break;
-   }
+  default:
+    break;
+  }
 }
 
-void 
-Value::resize( ArrayIndex newSize )
-{
-   JSON_ASSERT_MESSAGE( type_ == nullValue  ||  type_ == arrayValue, "in Json::Value::resize(): requires arrayValue" );
-   if ( type_ == nullValue )
-      *this = Value( arrayValue );
+void Value::resize(ArrayIndex newSize) {
+  JSON_ASSERT_MESSAGE(type_ == nullValue || type_ == arrayValue,
+                      "in Json::Value::resize(): requires arrayValue");
+  if (type_ == nullValue)
+    *this = Value(arrayValue);
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
-   ArrayIndex oldSize = size();
-   if ( newSize == 0 )
-      clear();
-   else if ( newSize > oldSize )
-      (*this)[ newSize - 1 ];
-   else
-   {
-      for ( ArrayIndex index = newSize; index < oldSize; ++index )
-      {
-         value_.map_->erase( index );
-      }
-      assert( size() == newSize );
-   }
+  ArrayIndex oldSize = size();
+  if (newSize == 0)
+    clear();
+  else if (newSize > oldSize)
+    (*this)[newSize - 1];
+  else {
+    for (ArrayIndex index = newSize; index < oldSize; ++index) {
+      value_.map_->erase(index);
+    }
+    assert(size() == newSize);
+  }
 #else
-   value_.array_->resize( newSize );
+  value_.array_->resize(newSize);
 #endif
 }
 
-
-Value &
-Value::operator[]( ArrayIndex index )
-{
-   JSON_ASSERT_MESSAGE( type_ == nullValue  ||  type_ == arrayValue, "in Json::Value::operator[](ArrayIndex): requires arrayValue" );
-   if ( type_ == nullValue )
-      *this = Value( arrayValue );
+Value &Value::operator[](ArrayIndex index) {
+  JSON_ASSERT_MESSAGE(
+      type_ == nullValue || type_ == arrayValue,
+      "in Json::Value::operator[](ArrayIndex): requires arrayValue");
+  if (type_ == nullValue)
+    *this = Value(arrayValue);
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
-   CZString key( index );
-   ObjectValues::iterator it = value_.map_->lower_bound( key );
-   if ( it != value_.map_->end()  &&  (*it).first == key )
-      return (*it).second;
+  CZString key(index);
+  ObjectValues::iterator it = value_.map_->lower_bound(key);
+  if (it != value_.map_->end() && (*it).first == key)
+    return (*it).second;
 
-   ObjectValues::value_type defaultValue( key, null );
-   it = value_.map_->insert( it, defaultValue );
-   return (*it).second;
+  ObjectValues::value_type defaultValue(key, null);
+  it = value_.map_->insert(it, defaultValue);
+  return (*it).second;
 #else
-   return value_.array_->resolveReference( index );
+  return value_.array_->resolveReference(index);
 #endif
 }
 
-
-Value &
-Value::operator[]( int index )
-{
-   JSON_ASSERT_MESSAGE( index >= 0, "in Json::Value::operator[](int index): index cannot be negative" );
-   return (*this)[ ArrayIndex(index) ];
+Value &Value::operator[](int index) {
+  JSON_ASSERT_MESSAGE(
+      index >= 0,
+      "in Json::Value::operator[](int index): index cannot be negative");
+  return (*this)[ArrayIndex(index)];
 }
 
-
-const Value &
-Value::operator[]( ArrayIndex index ) const
-{
-   JSON_ASSERT_MESSAGE( type_ == nullValue  ||  type_ == arrayValue, "in Json::Value::operator[](ArrayIndex)const: requires arrayValue" );
-   if ( type_ == nullValue )
-      return null;
+const Value &Value::operator[](ArrayIndex index) const {
+  JSON_ASSERT_MESSAGE(
+      type_ == nullValue || type_ == arrayValue,
+      "in Json::Value::operator[](ArrayIndex)const: requires arrayValue");
+  if (type_ == nullValue)
+    return null;
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
-   CZString key( index );
-   ObjectValues::const_iterator it = value_.map_->find( key );
-   if ( it == value_.map_->end() )
-      return null;
-   return (*it).second;
+  CZString key(index);
+  ObjectValues::const_iterator it = value_.map_->find(key);
+  if (it == value_.map_->end())
+    return null;
+  return (*it).second;
 #else
-   Value *value = value_.array_->find( index );
-   return value ? *value : null;
+  Value *value = value_.array_->find(index);
+  return value ? *value : null;
 #endif
 }
 
-
-const Value &
-Value::operator[]( int index ) const
-{
-   JSON_ASSERT_MESSAGE( index >= 0, "in Json::Value::operator[](int index) const: index cannot be negative" );
-   return (*this)[ ArrayIndex(index) ];
+const Value &Value::operator[](int index) const {
+  JSON_ASSERT_MESSAGE(
+      index >= 0,
+      "in Json::Value::operator[](int index) const: index cannot be negative");
+  return (*this)[ArrayIndex(index)];
 }
 
-
-Value &
-Value::operator[]( const char *key )
-{
-   return resolveReference( key, false );
+Value &Value::operator[](const char *key) {
+  return resolveReference(key, false);
 }
 
-
-Value &
-Value::resolveReference( const char *key, 
-                         bool isStatic )
-{
-   JSON_ASSERT_MESSAGE( type_ == nullValue  ||  type_ == objectValue, "in Json::Value::resolveReference(): requires objectValue" );
-   if ( type_ == nullValue )
-      *this = Value( objectValue );
+Value &Value::resolveReference(const char *key, bool isStatic) {
+  JSON_ASSERT_MESSAGE(
+      type_ == nullValue || type_ == objectValue,
+      "in Json::Value::resolveReference(): requires objectValue");
+  if (type_ == nullValue)
+    *this = Value(objectValue);
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
-   CZString actualKey( key, isStatic ? CZString::noDuplication 
-                                     : CZString::duplicateOnCopy );
-   ObjectValues::iterator it = value_.map_->lower_bound( actualKey );
-   if ( it != value_.map_->end()  &&  (*it).first == actualKey )
-      return (*it).second;
+  CZString actualKey(
+      key, isStatic ? CZString::noDuplication : CZString::duplicateOnCopy);
+  ObjectValues::iterator it = value_.map_->lower_bound(actualKey);
+  if (it != value_.map_->end() && (*it).first == actualKey)
+    return (*it).second;
 
-   ObjectValues::value_type defaultValue( actualKey, null );
-   it = value_.map_->insert( it, defaultValue );
-   Value &value = (*it).second;
-   return value;
+  ObjectValues::value_type defaultValue(actualKey, null);
+  it = value_.map_->insert(it, defaultValue);
+  Value &value = (*it).second;
+  return value;
 #else
-   return value_.map_->resolveReference( key, isStatic );
+  return value_.map_->resolveReference(key, isStatic);
 #endif
 }
 
-
-Value 
-Value::get( ArrayIndex index, 
-            const Value &defaultValue ) const
-{
-   const Value *value = &((*this)[index]);
-   return value == &null ? defaultValue : *value;
+Value Value::get(ArrayIndex index, const Value &defaultValue) const {
+  const Value *value = &((*this)[index]);
+  return value == &null ? defaultValue : *value;
 }
 
+bool Value::isValidIndex(ArrayIndex index) const { return index < size(); }
 
-bool 
-Value::isValidIndex( ArrayIndex index ) const
-{
-   return index < size();
-}
-
-
-
-const Value &
-Value::operator[]( const char *key ) const
-{
-   JSON_ASSERT_MESSAGE( type_ == nullValue  ||  type_ == objectValue, "in Json::Value::operator[](char const*)const: requires objectValue" );
-   if ( type_ == nullValue )
-      return null;
+const Value &Value::operator[](const char *key) const {
+  JSON_ASSERT_MESSAGE(
+      type_ == nullValue || type_ == objectValue,
+      "in Json::Value::operator[](char const*)const: requires objectValue");
+  if (type_ == nullValue)
+    return null;
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
-   CZString actualKey( key, CZString::noDuplication );
-   ObjectValues::const_iterator it = value_.map_->find( actualKey );
-   if ( it == value_.map_->end() )
-      return null;
-   return (*it).second;
+  CZString actualKey(key, CZString::noDuplication);
+  ObjectValues::const_iterator it = value_.map_->find(actualKey);
+  if (it == value_.map_->end())
+    return null;
+  return (*it).second;
 #else
-   const Value *value = value_.map_->find( key );
-   return value ? *value : null;
+  const Value *value = value_.map_->find(key);
+  return value ? *value : null;
 #endif
 }
 
-
-Value &
-Value::operator[]( const std::string &key )
-{
-   return (*this)[ key.c_str() ];
+Value &Value::operator[](const std::string &key) {
+  return (*this)[key.c_str()];
 }
 
-
-const Value &
-Value::operator[]( const std::string &key ) const
-{
-   return (*this)[ key.c_str() ];
+const Value &Value::operator[](const std::string &key) const {
+  return (*this)[key.c_str()];
 }
 
-Value &
-Value::operator[]( const StaticString &key )
-{
-   return resolveReference( key, true );
+Value &Value::operator[](const StaticString &key) {
+  return resolveReference(key, true);
 }
 
-
-# ifdef JSON_USE_CPPTL
-Value &
-Value::operator[]( const CppTL::ConstString &key )
-{
-   return (*this)[ key.c_str() ];
+#ifdef JSON_USE_CPPTL
+Value &Value::operator[](const CppTL::ConstString &key) {
+  return (*this)[key.c_str()];
 }
 
-
-const Value &
-Value::operator[]( const CppTL::ConstString &key ) const
-{
-   return (*this)[ key.c_str() ];
+const Value &Value::operator[](const CppTL::ConstString &key) const {
+  return (*this)[key.c_str()];
 }
-# endif
+#endif
 
+Value &Value::append(const Value &value) { return (*this)[size()] = value; }
 
-Value &
-Value::append( const Value &value )
-{
-   return (*this)[size()] = value;
+Value Value::get(const char *key, const Value &defaultValue) const {
+  const Value *value = &((*this)[key]);
+  return value == &null ? defaultValue : *value;
 }
 
-
-Value 
-Value::get( const char *key, 
-            const Value &defaultValue ) const
-{
-   const Value *value = &((*this)[key]);
-   return value == &null ? defaultValue : *value;
+Value Value::get(const std::string &key, const Value &defaultValue) const {
+  return get(key.c_str(), defaultValue);
 }
 
-
-Value 
-Value::get( const std::string &key,
-            const Value &defaultValue ) const
-{
-   return get( key.c_str(), defaultValue );
-}
-
-Value
-Value::removeMember( const char* key )
-{
-   JSON_ASSERT_MESSAGE( type_ == nullValue  ||  type_ == objectValue, "in Json::Value::removeMember(): requires objectValue" );
-   if ( type_ == nullValue )
-      return null;
+Value Value::removeMember(const char *key) {
+  JSON_ASSERT_MESSAGE(type_ == nullValue || type_ == objectValue,
+                      "in Json::Value::removeMember(): requires objectValue");
+  if (type_ == nullValue)
+    return null;
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
-   CZString actualKey( key, CZString::noDuplication );
-   ObjectValues::iterator it = value_.map_->find( actualKey );
-   if ( it == value_.map_->end() )
-      return null;
-   Value old(it->second);
-   value_.map_->erase(it);
-   return old;
+  CZString actualKey(key, CZString::noDuplication);
+  ObjectValues::iterator it = value_.map_->find(actualKey);
+  if (it == value_.map_->end())
+    return null;
+  Value old(it->second);
+  value_.map_->erase(it);
+  return old;
 #else
-   Value *value = value_.map_->find( key );
-   if (value){
-      Value old(*value);
-      value_.map_.remove( key );
-      return old;
-   } else {
-      return null;
-   }
+  Value *value = value_.map_->find(key);
+  if (value) {
+    Value old(*value);
+    value_.map_.remove(key);
+    return old;
+  } else {
+    return null;
+  }
 #endif
 }
 
-Value
-Value::removeMember( const std::string &key )
-{
-   return removeMember( key.c_str() );
+Value Value::removeMember(const std::string &key) {
+  return removeMember(key.c_str());
 }
 
-# ifdef JSON_USE_CPPTL
-Value 
-Value::get( const CppTL::ConstString &key,
-            const Value &defaultValue ) const
-{
-   return get( key.c_str(), defaultValue );
-}
-# endif
-
-bool 
-Value::isMember( const char *key ) const
-{
-   const Value *value = &((*this)[key]);
-   return value != &null;
-}
-
-
-bool 
-Value::isMember( const std::string &key ) const
-{
-   return isMember( key.c_str() );
-}
-
-
-# ifdef JSON_USE_CPPTL
-bool 
-Value::isMember( const CppTL::ConstString &key ) const
-{
-   return isMember( key.c_str() );
+#ifdef JSON_USE_CPPTL
+Value Value::get(const CppTL::ConstString &key,
+                 const Value &defaultValue) const {
+  return get(key.c_str(), defaultValue);
 }
 #endif
 
-Value::Members 
-Value::getMemberNames() const
-{
-   JSON_ASSERT_MESSAGE( type_ == nullValue  ||  type_ == objectValue, "in Json::Value::getMemberNames(), value must be objectValue" );
-   if ( type_ == nullValue )
-       return Value::Members();
-   Members members;
-   members.reserve( value_.map_->size() );
+bool Value::isMember(const char *key) const {
+  const Value *value = &((*this)[key]);
+  return value != &null;
+}
+
+bool Value::isMember(const std::string &key) const {
+  return isMember(key.c_str());
+}
+
+#ifdef JSON_USE_CPPTL
+bool Value::isMember(const CppTL::ConstString &key) const {
+  return isMember(key.c_str());
+}
+#endif
+
+Value::Members Value::getMemberNames() const {
+  JSON_ASSERT_MESSAGE(
+      type_ == nullValue || type_ == objectValue,
+      "in Json::Value::getMemberNames(), value must be objectValue");
+  if (type_ == nullValue)
+    return Value::Members();
+  Members members;
+  members.reserve(value_.map_->size());
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
-   ObjectValues::const_iterator it = value_.map_->begin();
-   ObjectValues::const_iterator itEnd = value_.map_->end();
-   for ( ; it != itEnd; ++it )
-      members.push_back( std::string( (*it).first.c_str() ) );
+  ObjectValues::const_iterator it = value_.map_->begin();
+  ObjectValues::const_iterator itEnd = value_.map_->end();
+  for (; it != itEnd; ++it)
+    members.push_back(std::string((*it).first.c_str()));
 #else
-   ValueInternalMap::IteratorState it;
-   ValueInternalMap::IteratorState itEnd;
-   value_.map_->makeBeginIterator( it );
-   value_.map_->makeEndIterator( itEnd );
-   for ( ; !ValueInternalMap::equals( it, itEnd ); ValueInternalMap::increment(it) )
-      members.push_back( std::string( ValueInternalMap::key( it ) ) );
+  ValueInternalMap::IteratorState it;
+  ValueInternalMap::IteratorState itEnd;
+  value_.map_->makeBeginIterator(it);
+  value_.map_->makeEndIterator(itEnd);
+  for (; !ValueInternalMap::equals(it, itEnd); ValueInternalMap::increment(it))
+    members.push_back(std::string(ValueInternalMap::key(it)));
 #endif
-   return members;
+  return members;
 }
 //
 //# ifdef JSON_USE_CPPTL
-//EnumMemberNames
-//Value::enumMemberNames() const
+// EnumMemberNames
+// Value::enumMemberNames() const
 //{
 //   if ( type_ == objectValue )
 //   {
@@ -1386,11 +1128,11 @@
 //}
 //
 //
-//EnumValues 
-//Value::enumValues() const
+// EnumValues
+// Value::enumValues() const
 //{
 //   if ( type_ == objectValue  ||  type_ == arrayValue )
-//      return CppTL::Enum::anyValues( *(value_.map_), 
+//      return CppTL::Enum::anyValues( *(value_.map_),
 //                                     CppTL::Type<const Value &>() );
 //   return EnumValues();
 //}
@@ -1402,112 +1144,81 @@
   return modf(d, &integral_part) == 0.0;
 }
 
+bool Value::isNull() const { return type_ == nullValue; }
 
-bool
-Value::isNull() const
-{
-   return type_ == nullValue;
+bool Value::isBool() const { return type_ == booleanValue; }
+
+bool Value::isInt() const {
+  switch (type_) {
+  case intValue:
+    return value_.int_ >= minInt && value_.int_ <= maxInt;
+  case uintValue:
+    return value_.uint_ <= UInt(maxInt);
+  case realValue:
+    return value_.real_ >= minInt && value_.real_ <= maxInt &&
+           IsIntegral(value_.real_);
+  default:
+    break;
+  }
+  return false;
 }
 
-
-bool 
-Value::isBool() const
-{
-   return type_ == booleanValue;
+bool Value::isUInt() const {
+  switch (type_) {
+  case intValue:
+    return value_.int_ >= 0 && LargestUInt(value_.int_) <= LargestUInt(maxUInt);
+  case uintValue:
+    return value_.uint_ <= maxUInt;
+  case realValue:
+    return value_.real_ >= 0 && value_.real_ <= maxUInt &&
+           IsIntegral(value_.real_);
+  default:
+    break;
+  }
+  return false;
 }
 
-
-bool 
-Value::isInt() const
-{
-   switch ( type_ )
-   {
-   case intValue:
-      return value_.int_ >= minInt  &&  value_.int_ <= maxInt;
-   case uintValue:
-      return value_.uint_ <= UInt(maxInt);
-   case realValue:
-      return value_.real_ >= minInt &&
-             value_.real_ <= maxInt &&
-             IsIntegral(value_.real_);
-   default:
-      break;
-   }
-   return false;
+bool Value::isInt64() const {
+#if defined(JSON_HAS_INT64)
+  switch (type_) {
+  case intValue:
+    return true;
+  case uintValue:
+    return value_.uint_ <= UInt64(maxInt64);
+  case realValue:
+    // Note that maxInt64 (= 2^63 - 1) is not exactly representable as a
+    // double, so double(maxInt64) will be rounded up to 2^63. Therefore we
+    // require the value to be strictly less than the limit.
+    return value_.real_ >= double(minInt64) &&
+           value_.real_ < double(maxInt64) && IsIntegral(value_.real_);
+  default:
+    break;
+  }
+#endif // JSON_HAS_INT64
+  return false;
 }
 
-
-bool 
-Value::isUInt() const
-{
-   switch ( type_ )
-   {
-   case intValue:
-      return value_.int_ >= 0 && LargestUInt(value_.int_) <= LargestUInt(maxUInt);
-   case uintValue:
-      return value_.uint_ <= maxUInt;
-   case realValue:
-      return value_.real_ >= 0 &&
-             value_.real_ <= maxUInt &&
-             IsIntegral(value_.real_);
-   default:
-      break;
-   }
-   return false;
+bool Value::isUInt64() const {
+#if defined(JSON_HAS_INT64)
+  switch (type_) {
+  case intValue:
+    return value_.int_ >= 0;
+  case uintValue:
+    return true;
+  case realValue:
+    // Note that maxUInt64 (= 2^64 - 1) is not exactly representable as a
+    // double, so double(maxUInt64) will be rounded up to 2^64. Therefore we
+    // require the value to be strictly less than the limit.
+    return value_.real_ >= 0 && value_.real_ < maxUInt64AsDouble &&
+           IsIntegral(value_.real_);
+  default:
+    break;
+  }
+#endif // JSON_HAS_INT64
+  return false;
 }
 
-bool 
-Value::isInt64() const
-{
-# if defined(JSON_HAS_INT64)
-   switch ( type_ )
-   {
-   case intValue:
-     return true;
-   case uintValue:
-      return value_.uint_ <= UInt64(maxInt64);
-   case realValue:
-      // Note that maxInt64 (= 2^63 - 1) is not exactly representable as a
-      // double, so double(maxInt64) will be rounded up to 2^63. Therefore we
-      // require the value to be strictly less than the limit.
-      return value_.real_ >= double(minInt64) &&
-             value_.real_ < double(maxInt64) &&
-             IsIntegral(value_.real_);
-   default:
-      break;
-   }
-# endif  // JSON_HAS_INT64
-   return false;
-}
-
-bool 
-Value::isUInt64() const
-{
-# if defined(JSON_HAS_INT64)
-   switch ( type_ )
-   {
-   case intValue:
-     return value_.int_ >= 0;
-   case uintValue:
-      return true;
-   case realValue:
-      // Note that maxUInt64 (= 2^64 - 1) is not exactly representable as a
-      // double, so double(maxUInt64) will be rounded up to 2^64. Therefore we
-      // require the value to be strictly less than the limit.
-      return value_.real_ >= 0 &&
-             value_.real_ < maxUInt64AsDouble &&
-             IsIntegral(value_.real_);
-   default:
-      break;
-   }
-# endif  // JSON_HAS_INT64
-   return false;
-}
-
-
-bool 
-Value::isIntegral() const
-{
+bool Value::isIntegral() const {
 #if defined(JSON_HAS_INT64)
   return isInt64() || isUInt64();
 #else
@@ -1515,466 +1226,309 @@
 #endif
 }
 
+bool Value::isDouble() const { return type_ == realValue || isIntegral(); }
 
-bool 
-Value::isDouble() const
-{
-   return type_ == realValue || isIntegral();
+bool Value::isNumeric() const { return isIntegral() || isDouble(); }
+
+bool Value::isString() const { return type_ == stringValue; }
+
+bool Value::isArray() const { return type_ == arrayValue; }
+
+bool Value::isObject() const { return type_ == objectValue; }
+
+void Value::setComment(const char *comment, CommentPlacement placement) {
+  if (!comments_)
+    comments_ = new CommentInfo[numberOfCommentPlacement];
+  comments_[placement].setComment(comment);
 }
 
-
-bool 
-Value::isNumeric() const
-{
-   return isIntegral() || isDouble();
+void Value::setComment(const std::string &comment, CommentPlacement placement) {
+  setComment(comment.c_str(), placement);
 }
 
-
-bool 
-Value::isString() const
-{
-   return type_ == stringValue;
+bool Value::hasComment(CommentPlacement placement) const {
+  return comments_ != 0 && comments_[placement].comment_ != 0;
 }
 
-
-bool 
-Value::isArray() const
-{
-   return type_ == arrayValue;
+std::string Value::getComment(CommentPlacement placement) const {
+  if (hasComment(placement))
+    return comments_[placement].comment_;
+  return "";
 }
 
+void Value::setOffsetStart(size_t start) { start_ = start; }
 
-bool 
-Value::isObject() const
-{
-   return type_ == objectValue;
+void Value::setOffsetLimit(size_t limit) { limit_ = limit; }
+
+size_t Value::getOffsetStart() const { return start_; }
+
+size_t Value::getOffsetLimit() const { return limit_; }
+
+std::string Value::toStyledString() const {
+  StyledWriter writer;
+  return writer.write(*this);
 }
 
-
-void 
-Value::setComment( const char *comment,
-                   CommentPlacement placement )
-{
-   if ( !comments_ )
-      comments_ = new CommentInfo[numberOfCommentPlacement];
-   comments_[placement].setComment( comment );
-}
-
-
-void 
-Value::setComment( const std::string &comment,
-                   CommentPlacement placement )
-{
-   setComment( comment.c_str(), placement );
-}
-
-
-bool 
-Value::hasComment( CommentPlacement placement ) const
-{
-   return comments_ != 0  &&  comments_[placement].comment_ != 0;
-}
-
-std::string 
-Value::getComment( CommentPlacement placement ) const
-{
-   if ( hasComment(placement) )
-      return comments_[placement].comment_;
-   return "";
-}
-
-
-void
-Value::setOffsetStart( size_t start )
-{
-   start_ = start;
-}
-
-
-void
-Value::setOffsetLimit( size_t limit )
-{
-   limit_ = limit;
-}
-
-
-size_t
-Value::getOffsetStart() const
-{
-   return start_;
-}
-
-
-size_t
-Value::getOffsetLimit() const
-{
-   return limit_;
-}
-
-
-std::string 
-Value::toStyledString() const
-{
-   StyledWriter writer;
-   return writer.write( *this );
-}
-
-
-Value::const_iterator 
-Value::begin() const
-{
-   switch ( type_ )
-   {
+Value::const_iterator Value::begin() const {
+  switch (type_) {
 #ifdef JSON_VALUE_USE_INTERNAL_MAP
-   case arrayValue:
-      if ( value_.array_ )
-      {
-         ValueInternalArray::IteratorState it;
-         value_.array_->makeBeginIterator( it );
-         return const_iterator( it );
-      }
-      break;
-   case objectValue:
-      if ( value_.map_ )
-      {
-         ValueInternalMap::IteratorState it;
-         value_.map_->makeBeginIterator( it );
-         return const_iterator( it );
-      }
-      break;
+  case arrayValue:
+    if (value_.array_) {
+      ValueInternalArray::IteratorState it;
+      value_.array_->makeBeginIterator(it);
+      return const_iterator(it);
+    }
+    break;
+  case objectValue:
+    if (value_.map_) {
+      ValueInternalMap::IteratorState it;
+      value_.map_->makeBeginIterator(it);
+      return const_iterator(it);
+    }
+    break;
 #else
-   case arrayValue:
-   case objectValue:
-      if ( value_.map_ )
-         return const_iterator( value_.map_->begin() );
-      break;
+  case arrayValue:
+  case objectValue:
+    if (value_.map_)
+      return const_iterator(value_.map_->begin());
+    break;
 #endif
-   default:
-      break;
-   }
-   return const_iterator();
+  default:
+    break;
+  }
+  return const_iterator();
 }
 
-Value::const_iterator 
-Value::end() const
-{
-   switch ( type_ )
-   {
+Value::const_iterator Value::end() const {
+  switch (type_) {
 #ifdef JSON_VALUE_USE_INTERNAL_MAP
-   case arrayValue:
-      if ( value_.array_ )
-      {
-         ValueInternalArray::IteratorState it;
-         value_.array_->makeEndIterator( it );
-         return const_iterator( it );
-      }
-      break;
-   case objectValue:
-      if ( value_.map_ )
-      {
-         ValueInternalMap::IteratorState it;
-         value_.map_->makeEndIterator( it );
-         return const_iterator( it );
-      }
-      break;
+  case arrayValue:
+    if (value_.array_) {
+      ValueInternalArray::IteratorState it;
+      value_.array_->makeEndIterator(it);
+      return const_iterator(it);
+    }
+    break;
+  case objectValue:
+    if (value_.map_) {
+      ValueInternalMap::IteratorState it;
+      value_.map_->makeEndIterator(it);
+      return const_iterator(it);
+    }
+    break;
 #else
-   case arrayValue:
-   case objectValue:
-      if ( value_.map_ )
-         return const_iterator( value_.map_->end() );
-      break;
+  case arrayValue:
+  case objectValue:
+    if (value_.map_)
+      return const_iterator(value_.map_->end());
+    break;
 #endif
-   default:
-      break;
-   }
-   return const_iterator();
+  default:
+    break;
+  }
+  return const_iterator();
 }
 
-
-Value::iterator 
-Value::begin()
-{
-   switch ( type_ )
-   {
+Value::iterator Value::begin() {
+  switch (type_) {
 #ifdef JSON_VALUE_USE_INTERNAL_MAP
-   case arrayValue:
-      if ( value_.array_ )
-      {
-         ValueInternalArray::IteratorState it;
-         value_.array_->makeBeginIterator( it );
-         return iterator( it );
-      }
-      break;
-   case objectValue:
-      if ( value_.map_ )
-      {
-         ValueInternalMap::IteratorState it;
-         value_.map_->makeBeginIterator( it );
-         return iterator( it );
-      }
-      break;
+  case arrayValue:
+    if (value_.array_) {
+      ValueInternalArray::IteratorState it;
+      value_.array_->makeBeginIterator(it);
+      return iterator(it);
+    }
+    break;
+  case objectValue:
+    if (value_.map_) {
+      ValueInternalMap::IteratorState it;
+      value_.map_->makeBeginIterator(it);
+      return iterator(it);
+    }
+    break;
 #else
-   case arrayValue:
-   case objectValue:
-      if ( value_.map_ )
-         return iterator( value_.map_->begin() );
-      break;
+  case arrayValue:
+  case objectValue:
+    if (value_.map_)
+      return iterator(value_.map_->begin());
+    break;
 #endif
-   default:
-      break;
-   }
-   return iterator();
+  default:
+    break;
+  }
+  return iterator();
 }
 
-Value::iterator 
-Value::end()
-{
-   switch ( type_ )
-   {
+Value::iterator Value::end() {
+  switch (type_) {
 #ifdef JSON_VALUE_USE_INTERNAL_MAP
-   case arrayValue:
-      if ( value_.array_ )
-      {
-         ValueInternalArray::IteratorState it;
-         value_.array_->makeEndIterator( it );
-         return iterator( it );
-      }
-      break;
-   case objectValue:
-      if ( value_.map_ )
-      {
-         ValueInternalMap::IteratorState it;
-         value_.map_->makeEndIterator( it );
-         return iterator( it );
-      }
-      break;
+  case arrayValue:
+    if (value_.array_) {
+      ValueInternalArray::IteratorState it;
+      value_.array_->makeEndIterator(it);
+      return iterator(it);
+    }
+    break;
+  case objectValue:
+    if (value_.map_) {
+      ValueInternalMap::IteratorState it;
+      value_.map_->makeEndIterator(it);
+      return iterator(it);
+    }
+    break;
 #else
-   case arrayValue:
-   case objectValue:
-      if ( value_.map_ )
-         return iterator( value_.map_->end() );
-      break;
+  case arrayValue:
+  case objectValue:
+    if (value_.map_)
+      return iterator(value_.map_->end());
+    break;
 #endif
-   default:
-      break;
-   }
-   return iterator();
+  default:
+    break;
+  }
+  return iterator();
 }
 
-
 // class PathArgument
 // //////////////////////////////////////////////////////////////////
 
-PathArgument::PathArgument()
-   : key_()
-   , index_()
-   , kind_( kindNone )
-{
-}
+PathArgument::PathArgument() : key_(), index_(), kind_(kindNone) {}
 
+PathArgument::PathArgument(ArrayIndex index)
+    : key_(), index_(index), kind_(kindIndex) {}
 
-PathArgument::PathArgument( ArrayIndex index )
-   : key_()
-   , index_( index )
-   , kind_( kindIndex )
-{
-}
+PathArgument::PathArgument(const char *key)
+    : key_(key), index_(), kind_(kindKey) {}
 
-
-PathArgument::PathArgument( const char *key )
-   : key_( key )
-   , index_()
-   , kind_( kindKey )
-{
-}
-
-
-PathArgument::PathArgument( const std::string &key )
-   : key_( key.c_str() )
-   , index_()
-   , kind_( kindKey )
-{
-}
+PathArgument::PathArgument(const std::string &key)
+    : key_(key.c_str()), index_(), kind_(kindKey) {}
 
 // class Path
 // //////////////////////////////////////////////////////////////////
 
-Path::Path( const std::string &path,
-            const PathArgument &a1,
-            const PathArgument &a2,
-            const PathArgument &a3,
-            const PathArgument &a4,
-            const PathArgument &a5 )
-{
-   InArgs in;
-   in.push_back( &a1 );
-   in.push_back( &a2 );
-   in.push_back( &a3 );
-   in.push_back( &a4 );
-   in.push_back( &a5 );
-   makePath( path, in );
+Path::Path(const std::string &path,
+           const PathArgument &a1,
+           const PathArgument &a2,
+           const PathArgument &a3,
+           const PathArgument &a4,
+           const PathArgument &a5) {
+  InArgs in;
+  in.push_back(&a1);
+  in.push_back(&a2);
+  in.push_back(&a3);
+  in.push_back(&a4);
+  in.push_back(&a5);
+  makePath(path, in);
 }
 
-
-void 
-Path::makePath( const std::string &path,
-                const InArgs &in )
-{
-   const char *current = path.c_str();
-   const char *end = current + path.length();
-   InArgs::const_iterator itInArg = in.begin();
-   while ( current != end )
-   {
-      if ( *current == '[' )
-      {
-         ++current;
-         if ( *current == '%' )
-            addPathInArg( path, in, itInArg, PathArgument::kindIndex );
-         else
-         {
-            ArrayIndex index = 0;
-            for ( ; current != end && *current >= '0'  &&  *current <= '9'; ++current )
-               index = index * 10 + ArrayIndex(*current - '0');
-            args_.push_back( index );
-         }
-         if ( current == end  ||  *current++ != ']' )
-            invalidPath( path, int(current - path.c_str()) );
+void Path::makePath(const std::string &path, const InArgs &in) {
+  const char *current = path.c_str();
+  const char *end = current + path.length();
+  InArgs::const_iterator itInArg = in.begin();
+  while (current != end) {
+    if (*current == '[') {
+      ++current;
+      if (*current == '%')
+        addPathInArg(path, in, itInArg, PathArgument::kindIndex);
+      else {
+        ArrayIndex index = 0;
+        for (; current != end && *current >= '0' && *current <= '9'; ++current)
+          index = index * 10 + ArrayIndex(*current - '0');
+        args_.push_back(index);
       }
-      else if ( *current == '%' )
-      {
-         addPathInArg( path, in, itInArg, PathArgument::kindKey );
-         ++current;
-      }
-      else if ( *current == '.' )
-      {
-         ++current;
-      }
-      else
-      {
-         const char *beginName = current;
-         while ( current != end  &&  !strchr( "[.", *current ) )
-            ++current;
-         args_.push_back( std::string( beginName, current ) );
-      }
-   }
+      if (current == end || *current++ != ']')
+        invalidPath(path, int(current - path.c_str()));
+    } else if (*current == '%') {
+      addPathInArg(path, in, itInArg, PathArgument::kindKey);
+      ++current;
+    } else if (*current == '.') {
+      ++current;
+    } else {
+      const char *beginName = current;
+      while (current != end && !strchr("[.", *current))
+        ++current;
+      args_.push_back(std::string(beginName, current));
+    }
+  }
 }
 
-
-void 
-Path::addPathInArg( const std::string &/*path*/, 
-                    const InArgs &in, 
-                    InArgs::const_iterator &itInArg, 
-                    PathArgument::Kind kind )
-{
-   if ( itInArg == in.end() )
-   {
-      // Error: missing argument %d
-   }
-   else if ( (*itInArg)->kind_ != kind )
-   {
-      // Error: bad argument type
-   }
-   else
-   {
-      args_.push_back( **itInArg );
-   }
+void Path::addPathInArg(const std::string & /*path*/,
+                        const InArgs &in,
+                        InArgs::const_iterator &itInArg,
+                        PathArgument::Kind kind) {
+  if (itInArg == in.end()) {
+    // Error: missing argument %d
+  } else if ((*itInArg)->kind_ != kind) {
+    // Error: bad argument type
+  } else {
+    args_.push_back(**itInArg);
+  }
 }
 
-
-void 
-Path::invalidPath( const std::string &/*path*/, 
-                   int /*location*/ )
-{
-   // Error: invalid path.
+void Path::invalidPath(const std::string & /*path*/, int /*location*/) {
+  // Error: invalid path.
 }
 
-
-const Value &
-Path::resolve( const Value &root ) const
-{
-   const Value *node = &root;
-   for ( Args::const_iterator it = args_.begin(); it != args_.end(); ++it )
-   {
-      const PathArgument &arg = *it;
-      if ( arg.kind_ == PathArgument::kindIndex )
-      {
-         if ( !node->isArray()  ||  !node->isValidIndex( arg.index_ ) )
-         {
-            // Error: unable to resolve path (array value expected at position...
-         }
-         node = &((*node)[arg.index_]);
+const Value &Path::resolve(const Value &root) const {
+  const Value *node = &root;
+  for (Args::const_iterator it = args_.begin(); it != args_.end(); ++it) {
+    const PathArgument &arg = *it;
+    if (arg.kind_ == PathArgument::kindIndex) {
+      if (!node->isArray() || !node->isValidIndex(arg.index_)) {
+        // Error: unable to resolve path (array value expected at position...
       }
-      else if ( arg.kind_ == PathArgument::kindKey )
-      {
-         if ( !node->isObject() )
-         {
-            // Error: unable to resolve path (object value expected at position...)
-         }
-         node = &((*node)[arg.key_]);
-         if ( node == &Value::null )
-         {
-            // Error: unable to resolve path (object has no member named '' at position...)
-         }
+      node = &((*node)[arg.index_]);
+    } else if (arg.kind_ == PathArgument::kindKey) {
+      if (!node->isObject()) {
+        // Error: unable to resolve path (object value expected at position...)
       }
-   }
-   return *node;
+      node = &((*node)[arg.key_]);
+      if (node == &Value::null) {
+        // Error: unable to resolve path (object has no member named '' at
+        // position...)
+      }
+    }
+  }
+  return *node;
 }
 
-
-Value 
-Path::resolve( const Value &root, 
-               const Value &defaultValue ) const
-{
-   const Value *node = &root;
-   for ( Args::const_iterator it = args_.begin(); it != args_.end(); ++it )
-   {
-      const PathArgument &arg = *it;
-      if ( arg.kind_ == PathArgument::kindIndex )
-      {
-         if ( !node->isArray()  ||  !node->isValidIndex( arg.index_ ) )
-            return defaultValue;
-         node = &((*node)[arg.index_]);
-      }
-      else if ( arg.kind_ == PathArgument::kindKey )
-      {
-         if ( !node->isObject() )
-            return defaultValue;
-         node = &((*node)[arg.key_]);
-         if ( node == &Value::null )
-            return defaultValue;
-      }
-   }
-   return *node;
+Value Path::resolve(const Value &root, const Value &defaultValue) const {
+  const Value *node = &root;
+  for (Args::const_iterator it = args_.begin(); it != args_.end(); ++it) {
+    const PathArgument &arg = *it;
+    if (arg.kind_ == PathArgument::kindIndex) {
+      if (!node->isArray() || !node->isValidIndex(arg.index_))
+        return defaultValue;
+      node = &((*node)[arg.index_]);
+    } else if (arg.kind_ == PathArgument::kindKey) {
+      if (!node->isObject())
+        return defaultValue;
+      node = &((*node)[arg.key_]);
+      if (node == &Value::null)
+        return defaultValue;
+    }
+  }
+  return *node;
 }
 
-
-Value &
-Path::make( Value &root ) const
-{
-   Value *node = &root;
-   for ( Args::const_iterator it = args_.begin(); it != args_.end(); ++it )
-   {
-      const PathArgument &arg = *it;
-      if ( arg.kind_ == PathArgument::kindIndex )
-      {
-         if ( !node->isArray() )
-         {
-            // Error: node is not an array at position ...
-         }
-         node = &((*node)[arg.index_]);
+Value &Path::make(Value &root) const {
+  Value *node = &root;
+  for (Args::const_iterator it = args_.begin(); it != args_.end(); ++it) {
+    const PathArgument &arg = *it;
+    if (arg.kind_ == PathArgument::kindIndex) {
+      if (!node->isArray()) {
+        // Error: node is not an array at position ...
       }
-      else if ( arg.kind_ == PathArgument::kindKey )
-      {
-         if ( !node->isObject() )
-         {
-            // Error: node is not an object at position...
-         }
-         node = &((*node)[arg.key_]);
+      node = &((*node)[arg.index_]);
+    } else if (arg.kind_ == PathArgument::kindKey) {
+      if (!node->isObject()) {
+        // Error: node is not an object at position...
       }
-   }
-   return *node;
+      node = &((*node)[arg.key_]);
+    }
+  }
+  return *node;
 }
 
-
 } // namespace Json
 // vim: et ts=3 sts=3 sw=3 tw=0
diff --git a/src/lib_json/json_writer.cpp b/src/lib_json/json_writer.cpp
index 3b9027f..cba5d13 100644
--- a/src/lib_json/json_writer.cpp
+++ b/src/lib_json/json_writer.cpp
@@ -4,8 +4,8 @@
 // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
 
 #if !defined(JSON_IS_AMALGAMATION)
-# include <json/writer.h>
-# include "json_tool.h"
+#include <json/writer.h>
+#include "json_tool.h"
 #endif // if !defined(JSON_IS_AMALGAMATION)
 #include <utility>
 #include <assert.h>
@@ -14,725 +14,576 @@
 #include <sstream>
 #include <iomanip>
 
-#if defined(_MSC_VER)  &&  _MSC_VER >= 1400 // VC++ 8.0
-#pragma warning( disable : 4996 )   // disable warning about strdup being deprecated.
+#if defined(_MSC_VER) && _MSC_VER >= 1400 // VC++ 8.0
+#pragma warning(disable                                                        \
+                : 4996) // disable warning about strdup being deprecated.
 #endif
 
 namespace Json {
 
-static bool containsControlCharacter( const char* str )
-{
-   while ( *str ) 
-   {
-      if ( isControlCharacter( *(str++) ) )
-         return true;
-   }
-   return false;
+static bool containsControlCharacter(const char *str) {
+  while (*str) {
+    if (isControlCharacter(*(str++)))
+      return true;
+  }
+  return false;
 }
 
-
-std::string valueToString( LargestInt value )
-{
-   UIntToStringBuffer buffer;
-   char *current = buffer + sizeof(buffer);
-   bool isNegative = value < 0;
-   if ( isNegative )
-      value = -value;
-   uintToString( LargestUInt(value), current );
-   if ( isNegative )
-      *--current = '-';
-   assert( current >= buffer );
-   return current;
+std::string valueToString(LargestInt value) {
+  UIntToStringBuffer buffer;
+  char *current = buffer + sizeof(buffer);
+  bool isNegative = value < 0;
+  if (isNegative)
+    value = -value;
+  uintToString(LargestUInt(value), current);
+  if (isNegative)
+    *--current = '-';
+  assert(current >= buffer);
+  return current;
 }
 
-
-std::string valueToString( LargestUInt value )
-{
-   UIntToStringBuffer buffer;
-   char *current = buffer + sizeof(buffer);
-   uintToString( value, current );
-   assert( current >= buffer );
-   return current;
+std::string valueToString(LargestUInt value) {
+  UIntToStringBuffer buffer;
+  char *current = buffer + sizeof(buffer);
+  uintToString(value, current);
+  assert(current >= buffer);
+  return current;
 }
 
 #if defined(JSON_HAS_INT64)
 
-std::string valueToString( Int value )
-{
-   return valueToString( LargestInt(value) );
+std::string valueToString(Int value) {
+  return valueToString(LargestInt(value));
 }
 
-
-std::string valueToString( UInt value )
-{
-   return valueToString( LargestUInt(value) );
+std::string valueToString(UInt value) {
+  return valueToString(LargestUInt(value));
 }
 
 #endif // # if defined(JSON_HAS_INT64)
 
+std::string valueToString(double value) {
+  // Allocate a buffer that is more than large enough to store the 16 digits of
+  // precision requested below.
+  char buffer[32];
 
-std::string valueToString( double value )
-{
-   // Allocate a buffer that is more than large enough to store the 16 digits of
-   // precision requested below.
-   char buffer[32];
-
-   // Print into the buffer. We need not request the alternative representation
-   // that always has a decimal point because JSON doesn't distingish the
-   // concepts of reals and integers.
-#if defined(_MSC_VER) && defined(__STDC_SECURE_LIB__) // Use secure version with visual studio 2005 to avoid warning. 
-   sprintf_s(buffer, sizeof(buffer), "%.16g", value); 
+// Print into the buffer. We need not request the alternative representation
+// that always has a decimal point because JSON doesn't distingish the
+// concepts of reals and integers.
+#if defined(_MSC_VER) && defined(__STDC_SECURE_LIB__) // Use secure version with
+                                                      // visual studio 2005 to
+                                                      // avoid warning.
+  sprintf_s(buffer, sizeof(buffer), "%.16g", value);
 #else
-   snprintf(buffer, sizeof(buffer), "%.16g", value);
+  snprintf(buffer, sizeof(buffer), "%.16g", value);
 #endif
 
-   return buffer;
+  return buffer;
 }
 
+std::string valueToString(bool value) { return value ? "true" : "false"; }
 
-std::string valueToString( bool value )
-{
-   return value ? "true" : "false";
-}
-
-std::string valueToQuotedString( const char *value )
-{
-   if (value == NULL)
-      return "";
-   // Not sure how to handle unicode...
-   if (strpbrk(value, "\"\\\b\f\n\r\t") == NULL && !containsControlCharacter( value ))
-      return std::string("\"") + value + "\"";
-   // We have to walk value and escape any special characters.
-   // Appending to std::string is not efficient, but this should be rare.
-   // (Note: forward slashes are *not* rare, but I am not escaping them.)
-   std::string::size_type maxsize = strlen(value)*2 + 3; // allescaped+quotes+NULL
-   std::string result;
-   result.reserve(maxsize); // to avoid lots of mallocs
-   result += "\"";
-   for (const char* c=value; *c != 0; ++c)
-   {
-      switch(*c)
-      {
-         case '\"':
-            result += "\\\"";
-            break;
-         case '\\':
-            result += "\\\\";
-            break;
-         case '\b':
-            result += "\\b";
-            break;
-         case '\f':
-            result += "\\f";
-            break;
-         case '\n':
-            result += "\\n";
-            break;
-         case '\r':
-            result += "\\r";
-            break;
-         case '\t':
-            result += "\\t";
-            break;
-         //case '/':
-            // Even though \/ is considered a legal escape in JSON, a bare
-            // slash is also legal, so I see no reason to escape it.
-            // (I hope I am not misunderstanding something.
-            // blep notes: actually escaping \/ may be useful in javascript to avoid </ 
-            // sequence.
-            // Should add a flag to allow this compatibility mode and prevent this 
-            // sequence from occurring.
-         default:
-            if ( isControlCharacter( *c ) )
-            {
-               std::ostringstream oss;
-               oss << "\\u" << std::hex << std::uppercase << std::setfill('0') << std::setw(4) << static_cast<int>(*c);
-               result += oss.str();
-            }
-            else
-            {
-               result += *c;
-            }
-            break;
+std::string valueToQuotedString(const char *value) {
+  if (value == NULL)
+    return "";
+  // Not sure how to handle unicode...
+  if (strpbrk(value, "\"\\\b\f\n\r\t") == NULL &&
+      !containsControlCharacter(value))
+    return std::string("\"") + value + "\"";
+  // We have to walk value and escape any special characters.
+  // Appending to std::string is not efficient, but this should be rare.
+  // (Note: forward slashes are *not* rare, but I am not escaping them.)
+  std::string::size_type maxsize =
+      strlen(value) * 2 + 3; // allescaped+quotes+NULL
+  std::string result;
+  result.reserve(maxsize); // to avoid lots of mallocs
+  result += "\"";
+  for (const char *c = value; *c != 0; ++c) {
+    switch (*c) {
+    case '\"':
+      result += "\\\"";
+      break;
+    case '\\':
+      result += "\\\\";
+      break;
+    case '\b':
+      result += "\\b";
+      break;
+    case '\f':
+      result += "\\f";
+      break;
+    case '\n':
+      result += "\\n";
+      break;
+    case '\r':
+      result += "\\r";
+      break;
+    case '\t':
+      result += "\\t";
+      break;
+    // case '/':
+    // Even though \/ is considered a legal escape in JSON, a bare
+    // slash is also legal, so I see no reason to escape it.
+    // (I hope I am not misunderstanding something.
+    // blep notes: actually escaping \/ may be useful in javascript to avoid </
+    // sequence.
+    // Should add a flag to allow this compatibility mode and prevent this
+    // sequence from occurring.
+    default:
+      if (isControlCharacter(*c)) {
+        std::ostringstream oss;
+        oss << "\\u" << std::hex << std::uppercase << std::setfill('0')
+            << std::setw(4) << static_cast<int>(*c);
+        result += oss.str();
+      } else {
+        result += *c;
       }
-   }
-   result += "\"";
-   return result;
+      break;
+    }
+  }
+  result += "\"";
+  return result;
 }
 
 // Class Writer
 // //////////////////////////////////////////////////////////////////
-Writer::~Writer()
-{
-}
-
+Writer::~Writer() {}
 
 // Class FastWriter
 // //////////////////////////////////////////////////////////////////
 
 FastWriter::FastWriter()
-   : yamlCompatiblityEnabled_( false ),
-     dropNullPlaceholders_( false )
-{
+    : yamlCompatiblityEnabled_(false), dropNullPlaceholders_(false) {}
+
+void FastWriter::enableYAMLCompatibility() { yamlCompatiblityEnabled_ = true; }
+
+void FastWriter::dropNullPlaceholders() { dropNullPlaceholders_ = true; }
+
+std::string FastWriter::write(const Value &root) {
+  document_ = "";
+  writeValue(root);
+  document_ += "\n";
+  return document_;
 }
 
-
-void 
-FastWriter::enableYAMLCompatibility()
-{
-   yamlCompatiblityEnabled_ = true;
+void FastWriter::writeValue(const Value &value) {
+  switch (value.type()) {
+  case nullValue:
+    if (!dropNullPlaceholders_)
+      document_ += "null";
+    break;
+  case intValue:
+    document_ += valueToString(value.asLargestInt());
+    break;
+  case uintValue:
+    document_ += valueToString(value.asLargestUInt());
+    break;
+  case realValue:
+    document_ += valueToString(value.asDouble());
+    break;
+  case stringValue:
+    document_ += valueToQuotedString(value.asCString());
+    break;
+  case booleanValue:
+    document_ += valueToString(value.asBool());
+    break;
+  case arrayValue: {
+    document_ += "[";
+    int size = value.size();
+    for (int index = 0; index < size; ++index) {
+      if (index > 0)
+        document_ += ",";
+      writeValue(value[index]);
+    }
+    document_ += "]";
+  } break;
+  case objectValue: {
+    Value::Members members(value.getMemberNames());
+    document_ += "{";
+    for (Value::Members::iterator it = members.begin(); it != members.end();
+         ++it) {
+      const std::string &name = *it;
+      if (it != members.begin())
+        document_ += ",";
+      document_ += valueToQuotedString(name.c_str());
+      document_ += yamlCompatiblityEnabled_ ? ": " : ":";
+      writeValue(value[name]);
+    }
+    document_ += "}";
+  } break;
+  }
 }
 
-
-void
-FastWriter::dropNullPlaceholders()
-{
-   dropNullPlaceholders_ = true;
-}
-
-
-std::string 
-FastWriter::write( const Value &root )
-{
-   document_ = "";
-   writeValue( root );
-   document_ += "\n";
-   return document_;
-}
-
-
-void 
-FastWriter::writeValue( const Value &value )
-{
-   switch ( value.type() )
-   {
-   case nullValue:
-      if (!dropNullPlaceholders_) document_ += "null";
-      break;
-   case intValue:
-      document_ += valueToString( value.asLargestInt() );
-      break;
-   case uintValue:
-      document_ += valueToString( value.asLargestUInt() );
-      break;
-   case realValue:
-      document_ += valueToString( value.asDouble() );
-      break;
-   case stringValue:
-      document_ += valueToQuotedString( value.asCString() );
-      break;
-   case booleanValue:
-      document_ += valueToString( value.asBool() );
-      break;
-   case arrayValue:
-      {
-         document_ += "[";
-         int size = value.size();
-         for ( int index =0; index < size; ++index )
-         {
-            if ( index > 0 )
-               document_ += ",";
-            writeValue( value[index] );
-         }
-         document_ += "]";
-      }
-      break;
-   case objectValue:
-      {
-         Value::Members members( value.getMemberNames() );
-         document_ += "{";
-         for ( Value::Members::iterator it = members.begin(); 
-               it != members.end(); 
-               ++it )
-         {
-            const std::string &name = *it;
-            if ( it != members.begin() )
-               document_ += ",";
-            document_ += valueToQuotedString( name.c_str() );
-            document_ += yamlCompatiblityEnabled_ ? ": " 
-                                                  : ":";
-            writeValue( value[name] );
-         }
-         document_ += "}";
-      }
-      break;
-   }
-}
-
-
 // Class StyledWriter
 // //////////////////////////////////////////////////////////////////
 
 StyledWriter::StyledWriter()
-   : rightMargin_( 74 )
-   , indentSize_( 3 )
-   , addChildValues_()
-{
+    : rightMargin_(74), indentSize_(3), addChildValues_() {}
+
+std::string StyledWriter::write(const Value &root) {
+  document_ = "";
+  addChildValues_ = false;
+  indentString_ = "";
+  writeCommentBeforeValue(root);
+  writeValue(root);
+  writeCommentAfterValueOnSameLine(root);
+  document_ += "\n";
+  return document_;
 }
 
-
-std::string 
-StyledWriter::write( const Value &root )
-{
-   document_ = "";
-   addChildValues_ = false;
-   indentString_ = "";
-   writeCommentBeforeValue( root );
-   writeValue( root );
-   writeCommentAfterValueOnSameLine( root );
-   document_ += "\n";
-   return document_;
-}
-
-
-void 
-StyledWriter::writeValue( const Value &value )
-{
-   switch ( value.type() )
-   {
-   case nullValue:
-      pushValue( "null" );
-      break;
-   case intValue:
-      pushValue( valueToString( value.asLargestInt() ) );
-      break;
-   case uintValue:
-      pushValue( valueToString( value.asLargestUInt() ) );
-      break;
-   case realValue:
-      pushValue( valueToString( value.asDouble() ) );
-      break;
-   case stringValue:
-      pushValue( valueToQuotedString( value.asCString() ) );
-      break;
-   case booleanValue:
-      pushValue( valueToString( value.asBool() ) );
-      break;
-   case arrayValue:
-      writeArrayValue( value);
-      break;
-   case objectValue:
-      {
-         Value::Members members( value.getMemberNames() );
-         if ( members.empty() )
-            pushValue( "{}" );
-         else
-         {
-            writeWithIndent( "{" );
-            indent();
-            Value::Members::iterator it = members.begin();
-            for (;;)
-            {
-               const std::string &name = *it;
-               const Value &childValue = value[name];
-               writeCommentBeforeValue( childValue );
-               writeWithIndent( valueToQuotedString( name.c_str() ) );
-               document_ += " : ";
-               writeValue( childValue );
-               if ( ++it == members.end() )
-               {
-                  writeCommentAfterValueOnSameLine( childValue );
-                  break;
-               }
-               document_ += ",";
-               writeCommentAfterValueOnSameLine( childValue );
-            }
-            unindent();
-            writeWithIndent( "}" );
-         }
+void StyledWriter::writeValue(const Value &value) {
+  switch (value.type()) {
+  case nullValue:
+    pushValue("null");
+    break;
+  case intValue:
+    pushValue(valueToString(value.asLargestInt()));
+    break;
+  case uintValue:
+    pushValue(valueToString(value.asLargestUInt()));
+    break;
+  case realValue:
+    pushValue(valueToString(value.asDouble()));
+    break;
+  case stringValue:
+    pushValue(valueToQuotedString(value.asCString()));
+    break;
+  case booleanValue:
+    pushValue(valueToString(value.asBool()));
+    break;
+  case arrayValue:
+    writeArrayValue(value);
+    break;
+  case objectValue: {
+    Value::Members members(value.getMemberNames());
+    if (members.empty())
+      pushValue("{}");
+    else {
+      writeWithIndent("{");
+      indent();
+      Value::Members::iterator it = members.begin();
+      for (;;) {
+        const std::string &name = *it;
+        const Value &childValue = value[name];
+        writeCommentBeforeValue(childValue);
+        writeWithIndent(valueToQuotedString(name.c_str()));
+        document_ += " : ";
+        writeValue(childValue);
+        if (++it == members.end()) {
+          writeCommentAfterValueOnSameLine(childValue);
+          break;
+        }
+        document_ += ",";
+        writeCommentAfterValueOnSameLine(childValue);
       }
-      break;
-   }
+      unindent();
+      writeWithIndent("}");
+    }
+  } break;
+  }
 }
 
-
-void 
-StyledWriter::writeArrayValue( const Value &value )
-{
-   unsigned size = value.size();
-   if ( size == 0 )
-      pushValue( "[]" );
-   else
-   {
-      bool isArrayMultiLine = isMultineArray( value );
-      if ( isArrayMultiLine )
-      {
-         writeWithIndent( "[" );
-         indent();
-         bool hasChildValue = !childValues_.empty();
-         unsigned index =0;
-         for (;;)
-         {
-            const Value &childValue = value[index];
-            writeCommentBeforeValue( childValue );
-            if ( hasChildValue )
-               writeWithIndent( childValues_[index] );
-            else
-            {
-               writeIndent();
-               writeValue( childValue );
-            }
-            if ( ++index == size )
-            {
-               writeCommentAfterValueOnSameLine( childValue );
-               break;
-            }
-            document_ += ",";
-            writeCommentAfterValueOnSameLine( childValue );
-         }
-         unindent();
-         writeWithIndent( "]" );
+void StyledWriter::writeArrayValue(const Value &value) {
+  unsigned size = value.size();
+  if (size == 0)
+    pushValue("[]");
+  else {
+    bool isArrayMultiLine = isMultineArray(value);
+    if (isArrayMultiLine) {
+      writeWithIndent("[");
+      indent();
+      bool hasChildValue = !childValues_.empty();
+      unsigned index = 0;
+      for (;;) {
+        const Value &childValue = value[index];
+        writeCommentBeforeValue(childValue);
+        if (hasChildValue)
+          writeWithIndent(childValues_[index]);
+        else {
+          writeIndent();
+          writeValue(childValue);
+        }
+        if (++index == size) {
+          writeCommentAfterValueOnSameLine(childValue);
+          break;
+        }
+        document_ += ",";
+        writeCommentAfterValueOnSameLine(childValue);
       }
-      else // output on a single line
-      {
-         assert( childValues_.size() == size );
-         document_ += "[ ";
-         for ( unsigned index =0; index < size; ++index )
-         {
-            if ( index > 0 )
-               document_ += ", ";
-            document_ += childValues_[index];
-         }
-         document_ += " ]";
+      unindent();
+      writeWithIndent("]");
+    } else // output on a single line
+    {
+      assert(childValues_.size() == size);
+      document_ += "[ ";
+      for (unsigned index = 0; index < size; ++index) {
+        if (index > 0)
+          document_ += ", ";
+        document_ += childValues_[index];
       }
-   }
+      document_ += " ]";
+    }
+  }
 }
 
-
-bool 
-StyledWriter::isMultineArray( const Value &value )
-{
-   int size = value.size();
-   bool isMultiLine = size*3 >= rightMargin_ ;
-   childValues_.clear();
-   for ( int index =0; index < size  &&  !isMultiLine; ++index )
-   {
-      const Value &childValue = value[index];
-      isMultiLine = isMultiLine  ||
-                     ( (childValue.isArray()  ||  childValue.isObject())  &&  
-                        childValue.size() > 0 );
-   }
-   if ( !isMultiLine ) // check if line length > max line length
-   {
-      childValues_.reserve( size );
-      addChildValues_ = true;
-      int lineLength = 4 + (size-1)*2; // '[ ' + ', '*n + ' ]'
-      for ( int index =0; index < size  &&  !isMultiLine; ++index )
-      {
-         writeValue( value[index] );
-         lineLength += int( childValues_[index].length() );
-         isMultiLine = isMultiLine  &&  hasCommentForValue( value[index] );
-      }
-      addChildValues_ = false;
-      isMultiLine = isMultiLine  ||  lineLength >= rightMargin_;
-   }
-   return isMultiLine;
+bool StyledWriter::isMultineArray(const Value &value) {
+  int size = value.size();
+  bool isMultiLine = size * 3 >= rightMargin_;
+  childValues_.clear();
+  for (int index = 0; index < size && !isMultiLine; ++index) {
+    const Value &childValue = value[index];
+    isMultiLine =
+        isMultiLine || ((childValue.isArray() || childValue.isObject()) &&
+                        childValue.size() > 0);
+  }
+  if (!isMultiLine) // check if line length > max line length
+  {
+    childValues_.reserve(size);
+    addChildValues_ = true;
+    int lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]'
+    for (int index = 0; index < size && !isMultiLine; ++index) {
+      writeValue(value[index]);
+      lineLength += int(childValues_[index].length());
+      isMultiLine = isMultiLine && hasCommentForValue(value[index]);
+    }
+    addChildValues_ = false;
+    isMultiLine = isMultiLine || lineLength >= rightMargin_;
+  }
+  return isMultiLine;
 }
 
-
-void 
-StyledWriter::pushValue( const std::string &value )
-{
-   if ( addChildValues_ )
-      childValues_.push_back( value );
-   else
-      document_ += value;
+void StyledWriter::pushValue(const std::string &value) {
+  if (addChildValues_)
+    childValues_.push_back(value);
+  else
+    document_ += value;
 }
 
-
-void 
-StyledWriter::writeIndent()
-{
-   if ( !document_.empty() )
-   {
-      char last = document_[document_.length()-1];
-      if ( last == ' ' )     // already indented
-         return;
-      if ( last != '\n' )    // Comments may add new-line
-         document_ += '\n';
-   }
-   document_ += indentString_;
-}
-
-
-void 
-StyledWriter::writeWithIndent( const std::string &value )
-{
-   writeIndent();
-   document_ += value;
-}
-
-
-void 
-StyledWriter::indent()
-{
-   indentString_ += std::string( indentSize_, ' ' );
-}
-
-
-void 
-StyledWriter::unindent()
-{
-   assert( int(indentString_.size()) >= indentSize_ );
-   indentString_.resize( indentString_.size() - indentSize_ );
-}
-
-
-void 
-StyledWriter::writeCommentBeforeValue( const Value &root )
-{
-   if ( !root.hasComment( commentBefore ) )
+void StyledWriter::writeIndent() {
+  if (!document_.empty()) {
+    char last = document_[document_.length() - 1];
+    if (last == ' ') // already indented
       return;
-
-   document_ += "\n";
-   writeIndent();
-   std::string normalizedComment = normalizeEOL( root.getComment( commentBefore ) );
-   std::string::const_iterator iter = normalizedComment.begin();
-   while ( iter != normalizedComment.end() )
-   {
-      document_ += *iter;
-      if ( *iter == '\n' && *(iter+1) == '/' )
-         writeIndent();
-      ++iter;
-   }
-
-   // Comments are stripped of newlines, so add one here
-   document_ += "\n";
+    if (last != '\n') // Comments may add new-line
+      document_ += '\n';
+  }
+  document_ += indentString_;
 }
 
-
-void 
-StyledWriter::writeCommentAfterValueOnSameLine( const Value &root )
-{
-   if ( root.hasComment( commentAfterOnSameLine ) )
-      document_ += " " + normalizeEOL( root.getComment( commentAfterOnSameLine ) );
-
-   if ( root.hasComment( commentAfter ) )
-   {
-      document_ += "\n";
-      document_ += normalizeEOL( root.getComment( commentAfter ) );
-      document_ += "\n";
-   }
+void StyledWriter::writeWithIndent(const std::string &value) {
+  writeIndent();
+  document_ += value;
 }
 
+void StyledWriter::indent() { indentString_ += std::string(indentSize_, ' '); }
 
-bool 
-StyledWriter::hasCommentForValue( const Value &value )
-{
-   return value.hasComment( commentBefore )
-          ||  value.hasComment( commentAfterOnSameLine )
-          ||  value.hasComment( commentAfter );
+void StyledWriter::unindent() {
+  assert(int(indentString_.size()) >= indentSize_);
+  indentString_.resize(indentString_.size() - indentSize_);
 }
 
+void StyledWriter::writeCommentBeforeValue(const Value &root) {
+  if (!root.hasComment(commentBefore))
+    return;
 
-std::string 
-StyledWriter::normalizeEOL( const std::string &text )
-{
-   std::string normalized;
-   normalized.reserve( text.length() );
-   const char *begin = text.c_str();
-   const char *end = begin + text.length();
-   const char *current = begin;
-   while ( current != end )
-   {
-      char c = *current++;
-      if ( c == '\r' ) // mac or dos EOL
-      {
-         if ( *current == '\n' ) // convert dos EOL
-            ++current;
-         normalized += '\n';
-      }
-      else // handle unix EOL & other char
-         normalized += c;
-   }
-   return normalized;
+  document_ += "\n";
+  writeIndent();
+  std::string normalizedComment = normalizeEOL(root.getComment(commentBefore));
+  std::string::const_iterator iter = normalizedComment.begin();
+  while (iter != normalizedComment.end()) {
+    document_ += *iter;
+    if (*iter == '\n' && *(iter + 1) == '/')
+      writeIndent();
+    ++iter;
+  }
+
+  // Comments are stripped of newlines, so add one here
+  document_ += "\n";
 }
 
+void StyledWriter::writeCommentAfterValueOnSameLine(const Value &root) {
+  if (root.hasComment(commentAfterOnSameLine))
+    document_ += " " + normalizeEOL(root.getComment(commentAfterOnSameLine));
+
+  if (root.hasComment(commentAfter)) {
+    document_ += "\n";
+    document_ += normalizeEOL(root.getComment(commentAfter));
+    document_ += "\n";
+  }
+}
+
+bool StyledWriter::hasCommentForValue(const Value &value) {
+  return value.hasComment(commentBefore) ||
+         value.hasComment(commentAfterOnSameLine) ||
+         value.hasComment(commentAfter);
+}
+
+std::string StyledWriter::normalizeEOL(const std::string &text) {
+  std::string normalized;
+  normalized.reserve(text.length());
+  const char *begin = text.c_str();
+  const char *end = begin + text.length();
+  const char *current = begin;
+  while (current != end) {
+    char c = *current++;
+    if (c == '\r') // mac or dos EOL
+    {
+      if (*current == '\n') // convert dos EOL
+        ++current;
+      normalized += '\n';
+    } else // handle unix EOL & other char
+      normalized += c;
+  }
+  return normalized;
+}
 
 // Class StyledStreamWriter
 // //////////////////////////////////////////////////////////////////
 
-StyledStreamWriter::StyledStreamWriter( std::string indentation )
-   : document_(NULL)
-   , rightMargin_( 74 )
-   , indentation_( indentation )
-   , addChildValues_()
-{
+StyledStreamWriter::StyledStreamWriter(std::string indentation)
+    : document_(NULL), rightMargin_(74), indentation_(indentation),
+      addChildValues_() {}
+
+void StyledStreamWriter::write(std::ostream &out, const Value &root) {
+  document_ = &out;
+  addChildValues_ = false;
+  indentString_ = "";
+  writeCommentBeforeValue(root);
+  writeValue(root);
+  writeCommentAfterValueOnSameLine(root);
+  *document_ << "\n";
+  document_ = NULL; // Forget the stream, for safety.
 }
 
-
-void
-StyledStreamWriter::write( std::ostream &out, const Value &root )
-{
-   document_ = &out;
-   addChildValues_ = false;
-   indentString_ = "";
-   writeCommentBeforeValue( root );
-   writeValue( root );
-   writeCommentAfterValueOnSameLine( root );
-   *document_ << "\n";
-   document_ = NULL; // Forget the stream, for safety.
-}
-
-
-void 
-StyledStreamWriter::writeValue( const Value &value )
-{
-   switch ( value.type() )
-   {
-   case nullValue:
-      pushValue( "null" );
-      break;
-   case intValue:
-      pushValue( valueToString( value.asLargestInt() ) );
-      break;
-   case uintValue:
-      pushValue( valueToString( value.asLargestUInt() ) );
-      break;
-   case realValue:
-      pushValue( valueToString( value.asDouble() ) );
-      break;
-   case stringValue:
-      pushValue( valueToQuotedString( value.asCString() ) );
-      break;
-   case booleanValue:
-      pushValue( valueToString( value.asBool() ) );
-      break;
-   case arrayValue:
-      writeArrayValue( value);
-      break;
-   case objectValue:
-      {
-         Value::Members members( value.getMemberNames() );
-         if ( members.empty() )
-            pushValue( "{}" );
-         else
-         {
-            writeWithIndent( "{" );
-            indent();
-            Value::Members::iterator it = members.begin();
-            for (;;)
-            {
-               const std::string &name = *it;
-               const Value &childValue = value[name];
-               writeCommentBeforeValue( childValue );
-               writeWithIndent( valueToQuotedString( name.c_str() ) );
-               *document_ << " : ";
-               writeValue( childValue );
-               if ( ++it == members.end() )
-               {
-                  writeCommentAfterValueOnSameLine( childValue );
-                  break;
-               }
-               *document_ << ",";
-               writeCommentAfterValueOnSameLine( childValue );
-            }
-            unindent();
-            writeWithIndent( "}" );
-         }
+void StyledStreamWriter::writeValue(const Value &value) {
+  switch (value.type()) {
+  case nullValue:
+    pushValue("null");
+    break;
+  case intValue:
+    pushValue(valueToString(value.asLargestInt()));
+    break;
+  case uintValue:
+    pushValue(valueToString(value.asLargestUInt()));
+    break;
+  case realValue:
+    pushValue(valueToString(value.asDouble()));
+    break;
+  case stringValue:
+    pushValue(valueToQuotedString(value.asCString()));
+    break;
+  case booleanValue:
+    pushValue(valueToString(value.asBool()));
+    break;
+  case arrayValue:
+    writeArrayValue(value);
+    break;
+  case objectValue: {
+    Value::Members members(value.getMemberNames());
+    if (members.empty())
+      pushValue("{}");
+    else {
+      writeWithIndent("{");
+      indent();
+      Value::Members::iterator it = members.begin();
+      for (;;) {
+        const std::string &name = *it;
+        const Value &childValue = value[name];
+        writeCommentBeforeValue(childValue);
+        writeWithIndent(valueToQuotedString(name.c_str()));
+        *document_ << " : ";
+        writeValue(childValue);
+        if (++it == members.end()) {
+          writeCommentAfterValueOnSameLine(childValue);
+          break;
+        }
+        *document_ << ",";
+        writeCommentAfterValueOnSameLine(childValue);
       }
-      break;
-   }
+      unindent();
+      writeWithIndent("}");
+    }
+  } break;
+  }
 }
 
-
-void 
-StyledStreamWriter::writeArrayValue( const Value &value )
-{
-   unsigned size = value.size();
-   if ( size == 0 )
-      pushValue( "[]" );
-   else
-   {
-      bool isArrayMultiLine = isMultineArray( value );
-      if ( isArrayMultiLine )
-      {
-         writeWithIndent( "[" );
-         indent();
-         bool hasChildValue = !childValues_.empty();
-         unsigned index =0;
-         for (;;)
-         {
-            const Value &childValue = value[index];
-            writeCommentBeforeValue( childValue );
-            if ( hasChildValue )
-               writeWithIndent( childValues_[index] );
-            else
-            {
-               writeIndent();
-               writeValue( childValue );
-            }
-            if ( ++index == size )
-            {
-               writeCommentAfterValueOnSameLine( childValue );
-               break;
-            }
-            *document_ << ",";
-            writeCommentAfterValueOnSameLine( childValue );
-         }
-         unindent();
-         writeWithIndent( "]" );
+void StyledStreamWriter::writeArrayValue(const Value &value) {
+  unsigned size = value.size();
+  if (size == 0)
+    pushValue("[]");
+  else {
+    bool isArrayMultiLine = isMultineArray(value);
+    if (isArrayMultiLine) {
+      writeWithIndent("[");
+      indent();
+      bool hasChildValue = !childValues_.empty();
+      unsigned index = 0;
+      for (;;) {
+        const Value &childValue = value[index];
+        writeCommentBeforeValue(childValue);
+        if (hasChildValue)
+          writeWithIndent(childValues_[index]);
+        else {
+          writeIndent();
+          writeValue(childValue);
+        }
+        if (++index == size) {
+          writeCommentAfterValueOnSameLine(childValue);
+          break;
+        }
+        *document_ << ",";
+        writeCommentAfterValueOnSameLine(childValue);
       }
-      else // output on a single line
-      {
-         assert( childValues_.size() == size );
-         *document_ << "[ ";
-         for ( unsigned index =0; index < size; ++index )
-         {
-            if ( index > 0 )
-               *document_ << ", ";
-            *document_ << childValues_[index];
-         }
-         *document_ << " ]";
+      unindent();
+      writeWithIndent("]");
+    } else // output on a single line
+    {
+      assert(childValues_.size() == size);
+      *document_ << "[ ";
+      for (unsigned index = 0; index < size; ++index) {
+        if (index > 0)
+          *document_ << ", ";
+        *document_ << childValues_[index];
       }
-   }
+      *document_ << " ]";
+    }
+  }
 }
 
-
-bool 
-StyledStreamWriter::isMultineArray( const Value &value )
-{
-   int size = value.size();
-   bool isMultiLine = size*3 >= rightMargin_ ;
-   childValues_.clear();
-   for ( int index =0; index < size  &&  !isMultiLine; ++index )
-   {
-      const Value &childValue = value[index];
-      isMultiLine = isMultiLine  ||
-                     ( (childValue.isArray()  ||  childValue.isObject())  &&  
-                        childValue.size() > 0 );
-   }
-   if ( !isMultiLine ) // check if line length > max line length
-   {
-      childValues_.reserve( size );
-      addChildValues_ = true;
-      int lineLength = 4 + (size-1)*2; // '[ ' + ', '*n + ' ]'
-      for ( int index =0; index < size  &&  !isMultiLine; ++index )
-      {
-         writeValue( value[index] );
-         lineLength += int( childValues_[index].length() );
-         isMultiLine = isMultiLine  &&  hasCommentForValue( value[index] );
-      }
-      addChildValues_ = false;
-      isMultiLine = isMultiLine  ||  lineLength >= rightMargin_;
-   }
-   return isMultiLine;
+bool StyledStreamWriter::isMultineArray(const Value &value) {
+  int size = value.size();
+  bool isMultiLine = size * 3 >= rightMargin_;
+  childValues_.clear();
+  for (int index = 0; index < size && !isMultiLine; ++index) {
+    const Value &childValue = value[index];
+    isMultiLine =
+        isMultiLine || ((childValue.isArray() || childValue.isObject()) &&
+                        childValue.size() > 0);
+  }
+  if (!isMultiLine) // check if line length > max line length
+  {
+    childValues_.reserve(size);
+    addChildValues_ = true;
+    int lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]'
+    for (int index = 0; index < size && !isMultiLine; ++index) {
+      writeValue(value[index]);
+      lineLength += int(childValues_[index].length());
+      isMultiLine = isMultiLine && hasCommentForValue(value[index]);
+    }
+    addChildValues_ = false;
+    isMultiLine = isMultiLine || lineLength >= rightMargin_;
+  }
+  return isMultiLine;
 }
 
-
-void 
-StyledStreamWriter::pushValue( const std::string &value )
-{
-   if ( addChildValues_ )
-      childValues_.push_back( value );
-   else
-      *document_ << value;
+void StyledStreamWriter::pushValue(const std::string &value) {
+  if (addChildValues_)
+    childValues_.push_back(value);
+  else
+    *document_ << value;
 }
 
-
-void 
-StyledStreamWriter::writeIndent()
-{
+void StyledStreamWriter::writeIndent() {
   /*
     Some comments in this method would have been nice. ;-)
 
@@ -745,98 +596,69 @@
          *document_ << '\n';
    }
   */
-   *document_ << '\n' << indentString_;
+  *document_ << '\n' << indentString_;
 }
 
-
-void 
-StyledStreamWriter::writeWithIndent( const std::string &value )
-{
-   writeIndent();
-   *document_ << value;
+void StyledStreamWriter::writeWithIndent(const std::string &value) {
+  writeIndent();
+  *document_ << value;
 }
 
+void StyledStreamWriter::indent() { indentString_ += indentation_; }
 
-void 
-StyledStreamWriter::indent()
-{
-   indentString_ += indentation_;
+void StyledStreamWriter::unindent() {
+  assert(indentString_.size() >= indentation_.size());
+  indentString_.resize(indentString_.size() - indentation_.size());
 }
 
-
-void 
-StyledStreamWriter::unindent()
-{
-   assert( indentString_.size() >= indentation_.size() );
-   indentString_.resize( indentString_.size() - indentation_.size() );
+void StyledStreamWriter::writeCommentBeforeValue(const Value &root) {
+  if (!root.hasComment(commentBefore))
+    return;
+  *document_ << normalizeEOL(root.getComment(commentBefore));
+  *document_ << "\n";
 }
 
+void StyledStreamWriter::writeCommentAfterValueOnSameLine(const Value &root) {
+  if (root.hasComment(commentAfterOnSameLine))
+    *document_ << " " + normalizeEOL(root.getComment(commentAfterOnSameLine));
 
-void 
-StyledStreamWriter::writeCommentBeforeValue( const Value &root )
-{
-   if ( !root.hasComment( commentBefore ) )
-      return;
-   *document_ << normalizeEOL( root.getComment( commentBefore ) );
-   *document_ << "\n";
+  if (root.hasComment(commentAfter)) {
+    *document_ << "\n";
+    *document_ << normalizeEOL(root.getComment(commentAfter));
+    *document_ << "\n";
+  }
 }
 
-
-void 
-StyledStreamWriter::writeCommentAfterValueOnSameLine( const Value &root )
-{
-   if ( root.hasComment( commentAfterOnSameLine ) )
-      *document_ << " " + normalizeEOL( root.getComment( commentAfterOnSameLine ) );
-
-   if ( root.hasComment( commentAfter ) )
-   {
-      *document_ << "\n";
-      *document_ << normalizeEOL( root.getComment( commentAfter ) );
-      *document_ << "\n";
-   }
+bool StyledStreamWriter::hasCommentForValue(const Value &value) {
+  return value.hasComment(commentBefore) ||
+         value.hasComment(commentAfterOnSameLine) ||
+         value.hasComment(commentAfter);
 }
 
-
-bool 
-StyledStreamWriter::hasCommentForValue( const Value &value )
-{
-   return value.hasComment( commentBefore )
-          ||  value.hasComment( commentAfterOnSameLine )
-          ||  value.hasComment( commentAfter );
+std::string StyledStreamWriter::normalizeEOL(const std::string &text) {
+  std::string normalized;
+  normalized.reserve(text.length());
+  const char *begin = text.c_str();
+  const char *end = begin + text.length();
+  const char *current = begin;
+  while (current != end) {
+    char c = *current++;
+    if (c == '\r') // mac or dos EOL
+    {
+      if (*current == '\n') // convert dos EOL
+        ++current;
+      normalized += '\n';
+    } else // handle unix EOL & other char
+      normalized += c;
+  }
+  return normalized;
 }
 
-
-std::string 
-StyledStreamWriter::normalizeEOL( const std::string &text )
-{
-   std::string normalized;
-   normalized.reserve( text.length() );
-   const char *begin = text.c_str();
-   const char *end = begin + text.length();
-   const char *current = begin;
-   while ( current != end )
-   {
-      char c = *current++;
-      if ( c == '\r' ) // mac or dos EOL
-      {
-         if ( *current == '\n' ) // convert dos EOL
-            ++current;
-         normalized += '\n';
-      }
-      else // handle unix EOL & other char
-         normalized += c;
-   }
-   return normalized;
+std::ostream &operator<<(std::ostream &sout, const Value &root) {
+  Json::StyledStreamWriter writer;
+  writer.write(sout, root);
+  return sout;
 }
 
-
-std::ostream& operator<<( std::ostream &sout, const Value &root )
-{
-   Json::StyledStreamWriter writer;
-   writer.write(sout, root);
-   return sout;
-}
-
-
 } // namespace Json
 // vim: et ts=3 sts=3 sw=3 tw=0
diff --git a/src/test_lib_json/jsontest.cpp b/src/test_lib_json/jsontest.cpp
index c43e7b6..88a49e6 100644
--- a/src/test_lib_json/jsontest.cpp
+++ b/src/test_lib_json/jsontest.cpp
@@ -10,569 +10,435 @@
 
 #if defined(_MSC_VER)
 // Used to install a report hook that prevent dialog on assertion and error.
-# include <crtdbg.h>
+#include <crtdbg.h>
 #endif // if defined(_MSC_VER)
 
 #if defined(_WIN32)
 // Used to prevent dialog on memory fault.
 // Limits headers included by Windows.h
-# define WIN32_LEAN_AND_MEAN
-# define NOSERVICE
-# define NOMCX
-# define NOIME
-# define NOSOUND
-# define NOCOMM
-# define NORPC
-# define NOGDI
-# define NOUSER
-# define NODRIVERS
-# define NOLOGERROR
-# define NOPROFILER
-# define NOMEMMGR
-# define NOLFILEIO
-# define NOOPENFILE
-# define NORESOURCE
-# define NOATOM
-# define NOLANGUAGE
-# define NOLSTRING
-# define NODBCS
-# define NOKEYBOARDINFO
-# define NOGDICAPMASKS
-# define NOCOLOR
-# define NOGDIOBJ
-# define NODRAWTEXT
-# define NOTEXTMETRIC
-# define NOSCALABLEFONT
-# define NOBITMAP
-# define NORASTEROPS
-# define NOMETAFILE
-# define NOSYSMETRICS
-# define NOSYSTEMPARAMSINFO
-# define NOMSG
-# define NOWINSTYLES
-# define NOWINOFFSETS
-# define NOSHOWWINDOW
-# define NODEFERWINDOWPOS
-# define NOVIRTUALKEYCODES
-# define NOKEYSTATES
-# define NOWH
-# define NOMENUS
-# define NOSCROLL
-# define NOCLIPBOARD
-# define NOICONS
-# define NOMB
-# define NOSYSCOMMANDS
-# define NOMDI
-# define NOCTLMGR
-# define NOWINMESSAGES
-# include <windows.h>
+#define WIN32_LEAN_AND_MEAN
+#define NOSERVICE
+#define NOMCX
+#define NOIME
+#define NOSOUND
+#define NOCOMM
+#define NORPC
+#define NOGDI
+#define NOUSER
+#define NODRIVERS
+#define NOLOGERROR
+#define NOPROFILER
+#define NOMEMMGR
+#define NOLFILEIO
+#define NOOPENFILE
+#define NORESOURCE
+#define NOATOM
+#define NOLANGUAGE
+#define NOLSTRING
+#define NODBCS
+#define NOKEYBOARDINFO
+#define NOGDICAPMASKS
+#define NOCOLOR
+#define NOGDIOBJ
+#define NODRAWTEXT
+#define NOTEXTMETRIC
+#define NOSCALABLEFONT
+#define NOBITMAP
+#define NORASTEROPS
+#define NOMETAFILE
+#define NOSYSMETRICS
+#define NOSYSTEMPARAMSINFO
+#define NOMSG
+#define NOWINSTYLES
+#define NOWINOFFSETS
+#define NOSHOWWINDOW
+#define NODEFERWINDOWPOS
+#define NOVIRTUALKEYCODES
+#define NOKEYSTATES
+#define NOWH
+#define NOMENUS
+#define NOSCROLL
+#define NOCLIPBOARD
+#define NOICONS
+#define NOMB
+#define NOSYSCOMMANDS
+#define NOMDI
+#define NOCTLMGR
+#define NOWINMESSAGES
+#include <windows.h>
 #endif // if defined(_WIN32)
 
 namespace JsonTest {
 
-
 // class TestResult
 // //////////////////////////////////////////////////////////////////
 
 TestResult::TestResult()
-   : predicateId_( 1 )
-   , lastUsedPredicateId_( 0 )
-   , messageTarget_( 0 )
-{
-   // The root predicate has id 0
-   rootPredicateNode_.id_ = 0;
-   rootPredicateNode_.next_ = 0;
-   predicateStackTail_ = &rootPredicateNode_;
+    : predicateId_(1), lastUsedPredicateId_(0), messageTarget_(0) {
+  // The root predicate has id 0
+  rootPredicateNode_.id_ = 0;
+  rootPredicateNode_.next_ = 0;
+  predicateStackTail_ = &rootPredicateNode_;
 }
 
-
-void 
-TestResult::setTestName( const std::string &name )
-{
-   name_ = name;
-}
+void TestResult::setTestName(const std::string &name) { name_ = name; }
 
 TestResult &
-TestResult::addFailure( const char *file, unsigned int line,
-                        const char *expr )
-{
-   /// Walks the PredicateContext stack adding them to failures_ if not already added.
-   unsigned int nestingLevel = 0;
-   PredicateContext *lastNode = rootPredicateNode_.next_;
-   for ( ; lastNode != 0; lastNode = lastNode->next_ )
-   {
-      if ( lastNode->id_ > lastUsedPredicateId_ ) // new PredicateContext
-      {
-         lastUsedPredicateId_ = lastNode->id_;
-         addFailureInfo( lastNode->file_, lastNode->line_, lastNode->expr_,
-                         nestingLevel );
-         // Link the PredicateContext to the failure for message target when 
-         // popping the PredicateContext.
-         lastNode->failure_ = &( failures_.back() );
-      }
-      ++nestingLevel;
-   }
+TestResult::addFailure(const char *file, unsigned int line, const char *expr) {
+  /// Walks the PredicateContext stack adding them to failures_ if not already
+  /// added.
+  unsigned int nestingLevel = 0;
+  PredicateContext *lastNode = rootPredicateNode_.next_;
+  for (; lastNode != 0; lastNode = lastNode->next_) {
+    if (lastNode->id_ > lastUsedPredicateId_) // new PredicateContext
+    {
+      lastUsedPredicateId_ = lastNode->id_;
+      addFailureInfo(
+          lastNode->file_, lastNode->line_, lastNode->expr_, nestingLevel);
+      // Link the PredicateContext to the failure for message target when
+      // popping the PredicateContext.
+      lastNode->failure_ = &(failures_.back());
+    }
+    ++nestingLevel;
+  }
 
-   // Adds the failed assertion
-   addFailureInfo( file, line, expr, nestingLevel );
-   messageTarget_ = &( failures_.back() );
-   return *this;
+  // Adds the failed assertion
+  addFailureInfo(file, line, expr, nestingLevel);
+  messageTarget_ = &(failures_.back());
+  return *this;
 }
 
-
-void 
-TestResult::addFailureInfo( const char *file, unsigned int line,
-                            const char *expr, unsigned int nestingLevel )
-{
-   Failure failure;
-   failure.file_ = file;
-   failure.line_ = line;
-   if ( expr )
-   {
-      failure.expr_ = expr;
-   }
-   failure.nestingLevel_ = nestingLevel;
-   failures_.push_back( failure );
+void TestResult::addFailureInfo(const char *file,
+                                unsigned int line,
+                                const char *expr,
+                                unsigned int nestingLevel) {
+  Failure failure;
+  failure.file_ = file;
+  failure.line_ = line;
+  if (expr) {
+    failure.expr_ = expr;
+  }
+  failure.nestingLevel_ = nestingLevel;
+  failures_.push_back(failure);
 }
 
-
-TestResult &
-TestResult::popPredicateContext()
-{
-   PredicateContext *lastNode = &rootPredicateNode_;
-   while ( lastNode->next_ != 0  &&  lastNode->next_->next_ != 0 )
-   {
-      lastNode = lastNode->next_;
-   }
-   // Set message target to popped failure
-   PredicateContext *tail = lastNode->next_;
-   if ( tail != 0  &&  tail->failure_ != 0 )
-   {
-      messageTarget_ = tail->failure_;
-   }
-   // Remove tail from list
-   predicateStackTail_ = lastNode;
-   lastNode->next_ = 0;
-   return *this;
+TestResult &TestResult::popPredicateContext() {
+  PredicateContext *lastNode = &rootPredicateNode_;
+  while (lastNode->next_ != 0 && lastNode->next_->next_ != 0) {
+    lastNode = lastNode->next_;
+  }
+  // Set message target to popped failure
+  PredicateContext *tail = lastNode->next_;
+  if (tail != 0 && tail->failure_ != 0) {
+    messageTarget_ = tail->failure_;
+  }
+  // Remove tail from list
+  predicateStackTail_ = lastNode;
+  lastNode->next_ = 0;
+  return *this;
 }
 
+bool TestResult::failed() const { return !failures_.empty(); }
 
-bool 
-TestResult::failed() const
-{
-   return !failures_.empty();
+unsigned int TestResult::getAssertionNestingLevel() const {
+  unsigned int level = 0;
+  const PredicateContext *lastNode = &rootPredicateNode_;
+  while (lastNode->next_ != 0) {
+    lastNode = lastNode->next_;
+    ++level;
+  }
+  return level;
 }
 
+void TestResult::printFailure(bool printTestName) const {
+  if (failures_.empty()) {
+    return;
+  }
 
-unsigned int 
-TestResult::getAssertionNestingLevel() const
-{
-   unsigned int level = 0;
-   const PredicateContext *lastNode = &rootPredicateNode_;
-   while ( lastNode->next_ != 0 )
-   {
-      lastNode = lastNode->next_;
-      ++level;
-   }
-   return level;
+  if (printTestName) {
+    printf("* Detail of %s test failure:\n", name_.c_str());
+  }
+
+  // Print in reverse to display the callstack in the right order
+  Failures::const_iterator itEnd = failures_.end();
+  for (Failures::const_iterator it = failures_.begin(); it != itEnd; ++it) {
+    const Failure &failure = *it;
+    std::string indent(failure.nestingLevel_ * 2, ' ');
+    if (failure.file_) {
+      printf("%s%s(%d): ", indent.c_str(), failure.file_, failure.line_);
+    }
+    if (!failure.expr_.empty()) {
+      printf("%s\n", failure.expr_.c_str());
+    } else if (failure.file_) {
+      printf("\n");
+    }
+    if (!failure.message_.empty()) {
+      std::string reindented = indentText(failure.message_, indent + "  ");
+      printf("%s\n", reindented.c_str());
+    }
+  }
 }
 
-
-void 
-TestResult::printFailure( bool printTestName ) const
-{
-   if ( failures_.empty() )
-   {
-      return;
-   }
-
-   if ( printTestName )
-   {
-      printf( "* Detail of %s test failure:\n", name_.c_str() );
-   }
-
-   // Print in reverse to display the callstack in the right order
-   Failures::const_iterator itEnd = failures_.end();
-   for ( Failures::const_iterator it = failures_.begin(); it != itEnd; ++it )
-   {
-      const Failure &failure = *it;
-      std::string indent( failure.nestingLevel_ * 2, ' ' );
-      if ( failure.file_ )
-      {
-         printf( "%s%s(%d): ", indent.c_str(), failure.file_, failure.line_ );
-      }
-      if ( !failure.expr_.empty() )
-      {
-         printf( "%s\n", failure.expr_.c_str() );
-      }
-      else if ( failure.file_ )
-      {
-         printf( "\n" );
-      }
-      if ( !failure.message_.empty() )
-      {
-         std::string reindented = indentText( failure.message_, indent + "  " );
-         printf( "%s\n", reindented.c_str() );
-      }
-   }
+std::string TestResult::indentText(const std::string &text,
+                                   const std::string &indent) {
+  std::string reindented;
+  std::string::size_type lastIndex = 0;
+  while (lastIndex < text.size()) {
+    std::string::size_type nextIndex = text.find('\n', lastIndex);
+    if (nextIndex == std::string::npos) {
+      nextIndex = text.size() - 1;
+    }
+    reindented += indent;
+    reindented += text.substr(lastIndex, nextIndex - lastIndex + 1);
+    lastIndex = nextIndex + 1;
+  }
+  return reindented;
 }
 
-
-std::string 
-TestResult::indentText( const std::string &text, 
-                        const std::string &indent )
-{
-   std::string reindented;
-   std::string::size_type lastIndex = 0;
-   while ( lastIndex < text.size() )
-   {
-      std::string::size_type nextIndex = text.find( '\n', lastIndex );
-      if ( nextIndex == std::string::npos )
-      {
-         nextIndex = text.size() - 1;
-      }
-      reindented += indent;
-      reindented += text.substr( lastIndex, nextIndex - lastIndex + 1 );
-      lastIndex = nextIndex + 1;
-   }
-   return reindented;
+TestResult &TestResult::addToLastFailure(const std::string &message) {
+  if (messageTarget_ != 0) {
+    messageTarget_->message_ += message;
+  }
+  return *this;
 }
 
-
-TestResult &
-TestResult::addToLastFailure( const std::string &message )
-{
-   if ( messageTarget_ != 0 )
-   {
-      messageTarget_->message_ += message;
-   }
-   return *this;
+TestResult &TestResult::operator<<(Json::Int64 value) {
+  return addToLastFailure(Json::valueToString(value));
 }
 
-TestResult &
-TestResult::operator << ( Json::Int64 value ) {
-   return addToLastFailure( Json::valueToString(value) );
+TestResult &TestResult::operator<<(Json::UInt64 value) {
+  return addToLastFailure(Json::valueToString(value));
 }
 
-
-TestResult &
-TestResult::operator << ( Json::UInt64 value ) {
-   return addToLastFailure( Json::valueToString(value) );
+TestResult &TestResult::operator<<(bool value) {
+  return addToLastFailure(value ? "true" : "false");
 }
 
-
-TestResult &
-TestResult::operator << ( bool value ) {
-   return addToLastFailure(value ? "true" : "false");
-}
-
-
 // class TestCase
 // //////////////////////////////////////////////////////////////////
 
-TestCase::TestCase()
-   : result_( 0 )
-{
+TestCase::TestCase() : result_(0) {}
+
+TestCase::~TestCase() {}
+
+void TestCase::run(TestResult &result) {
+  result_ = &result;
+  runTestCase();
 }
 
-
-TestCase::~TestCase()
-{
-}
-
-
-void 
-TestCase::run( TestResult &result )
-{
-   result_ = &result;
-   runTestCase();
-}
-
-
-
 // class Runner
 // //////////////////////////////////////////////////////////////////
 
-Runner::Runner()
-{
+Runner::Runner() {}
+
+Runner &Runner::add(TestCaseFactory factory) {
+  tests_.push_back(factory);
+  return *this;
 }
 
-
-Runner &
-Runner::add( TestCaseFactory factory )
-{
-   tests_.push_back( factory );
-   return *this;
+unsigned int Runner::testCount() const {
+  return static_cast<unsigned int>(tests_.size());
 }
 
-
-unsigned int 
-Runner::testCount() const
-{
-   return static_cast<unsigned int>( tests_.size() );
+std::string Runner::testNameAt(unsigned int index) const {
+  TestCase *test = tests_[index]();
+  std::string name = test->testName();
+  delete test;
+  return name;
 }
 
-
-std::string 
-Runner::testNameAt( unsigned int index ) const
-{
-   TestCase *test = tests_[index]();
-   std::string name = test->testName();
-   delete test;
-   return name;
-}
-
-
-void 
-Runner::runTestAt( unsigned int index, TestResult &result ) const
-{
-   TestCase *test = tests_[index]();
-   result.setTestName( test->testName() );
-   printf( "Testing %s: ", test->testName() );
-   fflush( stdout );
+void Runner::runTestAt(unsigned int index, TestResult &result) const {
+  TestCase *test = tests_[index]();
+  result.setTestName(test->testName());
+  printf("Testing %s: ", test->testName());
+  fflush(stdout);
 #if JSON_USE_EXCEPTION
-   try 
-   {
+  try {
 #endif // if JSON_USE_EXCEPTION
-      test->run( result );
+    test->run(result);
 #if JSON_USE_EXCEPTION
-   } 
-   catch ( const std::exception &e ) 
-   {
-      result.addFailure( __FILE__, __LINE__, 
-         "Unexpected exception caught:" ) << e.what();
-   }
+  }
+  catch (const std::exception &e) {
+    result.addFailure(__FILE__, __LINE__, "Unexpected exception caught:")
+        << e.what();
+  }
 #endif // if JSON_USE_EXCEPTION
-   delete test;
-   const char *status = result.failed() ? "FAILED" 
-                                        : "OK";
-   printf( "%s\n", status );
-   fflush( stdout );
+  delete test;
+  const char *status = result.failed() ? "FAILED" : "OK";
+  printf("%s\n", status);
+  fflush(stdout);
 }
 
+bool Runner::runAllTest(bool printSummary) const {
+  unsigned int count = testCount();
+  std::deque<TestResult> failures;
+  for (unsigned int index = 0; index < count; ++index) {
+    TestResult result;
+    runTestAt(index, result);
+    if (result.failed()) {
+      failures.push_back(result);
+    }
+  }
 
-bool 
-Runner::runAllTest( bool printSummary ) const
-{
-   unsigned int count = testCount();
-   std::deque<TestResult> failures;
-   for ( unsigned int index = 0; index < count; ++index )
-   {
-      TestResult result;
-      runTestAt( index, result );
-      if ( result.failed() )
-      {
-         failures.push_back( result );
-      }
-   }
+  if (failures.empty()) {
+    if (printSummary) {
+      printf("All %d tests passed\n", count);
+    }
+    return true;
+  } else {
+    for (unsigned int index = 0; index < failures.size(); ++index) {
+      TestResult &result = failures[index];
+      result.printFailure(count > 1);
+    }
 
-   if ( failures.empty() )
-   {
-      if ( printSummary )
-      {
-         printf( "All %d tests passed\n", count );
-      }
+    if (printSummary) {
+      unsigned int failedCount = static_cast<unsigned int>(failures.size());
+      unsigned int passedCount = count - failedCount;
+      printf("%d/%d tests passed (%d failure(s))\n",
+             passedCount,
+             count,
+             failedCount);
+    }
+    return false;
+  }
+}
+
+bool Runner::testIndex(const std::string &testName,
+                       unsigned int &indexOut) const {
+  unsigned int count = testCount();
+  for (unsigned int index = 0; index < count; ++index) {
+    if (testNameAt(index) == testName) {
+      indexOut = index;
       return true;
-   }
-   else
-   {
-      for ( unsigned int index = 0; index < failures.size(); ++index )
-      {
-         TestResult &result = failures[index];
-         result.printFailure( count > 1 );
-      }
-
-      if ( printSummary )
-      {
-         unsigned int failedCount = static_cast<unsigned int>( failures.size() );
-         unsigned int passedCount = count - failedCount;
-         printf( "%d/%d tests passed (%d failure(s))\n", passedCount, count, failedCount );
-      }
-      return false;
-   }
+    }
+  }
+  return false;
 }
 
-
-bool 
-Runner::testIndex( const std::string &testName, 
-                   unsigned int &indexOut ) const
-{
-   unsigned int count = testCount();
-   for ( unsigned int index = 0; index < count; ++index )
-   {
-      if ( testNameAt(index) == testName )
-      {
-         indexOut = index;
-         return true;
-      }
-   }
-   return false;
+void Runner::listTests() const {
+  unsigned int count = testCount();
+  for (unsigned int index = 0; index < count; ++index) {
+    printf("%s\n", testNameAt(index).c_str());
+  }
 }
 
-
-void 
-Runner::listTests() const
-{
-   unsigned int count = testCount();
-   for ( unsigned int index = 0; index < count; ++index )
-   {
-      printf( "%s\n", testNameAt( index ).c_str() );
-   }
+int Runner::runCommandLine(int argc, const char *argv[]) const {
+  typedef std::deque<std::string> TestNames;
+  Runner subrunner;
+  for (int index = 1; index < argc; ++index) {
+    std::string opt = argv[index];
+    if (opt == "--list-tests") {
+      listTests();
+      return 0;
+    } else if (opt == "--test-auto") {
+      preventDialogOnCrash();
+    } else if (opt == "--test") {
+      ++index;
+      if (index < argc) {
+        unsigned int testNameIndex;
+        if (testIndex(argv[index], testNameIndex)) {
+          subrunner.add(tests_[testNameIndex]);
+        } else {
+          fprintf(stderr, "Test '%s' does not exist!\n", argv[index]);
+          return 2;
+        }
+      } else {
+        printUsage(argv[0]);
+        return 2;
+      }
+    } else {
+      printUsage(argv[0]);
+      return 2;
+    }
+  }
+  bool succeeded;
+  if (subrunner.testCount() > 0) {
+    succeeded = subrunner.runAllTest(subrunner.testCount() > 1);
+  } else {
+    succeeded = runAllTest(true);
+  }
+  return succeeded ? 0 : 1;
 }
 
-
-int 
-Runner::runCommandLine( int argc, const char *argv[] ) const
-{
-   typedef std::deque<std::string> TestNames;
-   Runner subrunner;
-   for ( int index = 1; index < argc; ++index )
-   {
-      std::string opt = argv[index];
-      if ( opt == "--list-tests" )
-      {
-         listTests();
-         return 0;
-      }
-      else if ( opt == "--test-auto" )
-      {
-         preventDialogOnCrash();
-      }
-      else if ( opt == "--test" )
-      {
-         ++index;
-         if ( index < argc )
-         {
-            unsigned int testNameIndex;
-            if ( testIndex( argv[index], testNameIndex ) )
-            {
-               subrunner.add( tests_[testNameIndex] );
-            }
-            else
-            {
-               fprintf( stderr, "Test '%s' does not exist!\n", argv[index] );
-               return 2;
-            }
-         }
-         else
-         {
-            printUsage( argv[0] );
-            return 2;
-         }
-      }
-      else
-      {
-         printUsage( argv[0] );
-         return 2;
-      }
-   }
-   bool succeeded;
-   if ( subrunner.testCount() > 0 )
-   {
-      succeeded = subrunner.runAllTest( subrunner.testCount() > 1 );
-   }
-   else
-   {
-      succeeded = runAllTest( true );
-   }
-   return succeeded ? 0 
-                    : 1;
-}
-
-
-#if defined(_MSC_VER)  &&  defined(_DEBUG)
+#if defined(_MSC_VER) && defined(_DEBUG)
 // Hook MSVCRT assertions to prevent dialog from appearing
-static int 
-msvcrtSilentReportHook( int reportType, char *message, int * /*returnValue*/ )
-{
-   // The default CRT handling of error and assertion is to display
-   // an error dialog to the user.
-   // Instead, when an error or an assertion occurs, we force the 
-   // application to terminate using abort() after display
-   // the message on stderr. 
-   if ( reportType == _CRT_ERROR  ||  
-        reportType == _CRT_ASSERT )
-   {
-      // calling abort() cause the ReportHook to be called
-      // The following is used to detect this case and let's the
-      // error handler fallback on its default behaviour (
-      // display a warning message)
-      static volatile bool isAborting = false;
-      if ( isAborting ) 
-      {
-         return TRUE;
-      }
-      isAborting = true;
+static int
+msvcrtSilentReportHook(int reportType, char *message, int * /*returnValue*/) {
+  // The default CRT handling of error and assertion is to display
+  // an error dialog to the user.
+  // Instead, when an error or an assertion occurs, we force the
+  // application to terminate using abort() after display
+  // the message on stderr.
+  if (reportType == _CRT_ERROR || reportType == _CRT_ASSERT) {
+    // calling abort() cause the ReportHook to be called
+    // The following is used to detect this case and let's the
+    // error handler fallback on its default behaviour (
+    // display a warning message)
+    static volatile bool isAborting = false;
+    if (isAborting) {
+      return TRUE;
+    }
+    isAborting = true;
 
-      fprintf( stderr, "CRT Error/Assert:\n%s\n", message );
-      fflush( stderr );
-      abort();
-   }
-   // Let's other reportType (_CRT_WARNING) be handled as they would by default
-   return FALSE;
+    fprintf(stderr, "CRT Error/Assert:\n%s\n", message);
+    fflush(stderr);
+    abort();
+  }
+  // Let's other reportType (_CRT_WARNING) be handled as they would by default
+  return FALSE;
 }
 #endif // if defined(_MSC_VER)
 
-
-void 
-Runner::preventDialogOnCrash()
-{
-#if defined(_MSC_VER)  &&  defined(_DEBUG)
-   // Install a hook to prevent MSVCRT error and assertion from
-   // popping a dialog
-   // This function a NO-OP in release configuration 
-   // (which cause warning since msvcrtSilentReportHook is not referenced)
-   _CrtSetReportHook( &msvcrtSilentReportHook );
+void Runner::preventDialogOnCrash() {
+#if defined(_MSC_VER) && defined(_DEBUG)
+  // Install a hook to prevent MSVCRT error and assertion from
+  // popping a dialog
+  // This function a NO-OP in release configuration
+  // (which cause warning since msvcrtSilentReportHook is not referenced)
+  _CrtSetReportHook(&msvcrtSilentReportHook);
 #endif // if defined(_MSC_VER)
 
-   // @todo investiguate this handler (for buffer overflow)
-   // _set_security_error_handler
+// @todo investiguate this handler (for buffer overflow)
+// _set_security_error_handler
 
 #if defined(_WIN32)
-   // Prevents the system from popping a dialog for debugging if the
-   // application fails due to invalid memory access.
-   SetErrorMode( SEM_FAILCRITICALERRORS 
-                 | SEM_NOGPFAULTERRORBOX 
-                 | SEM_NOOPENFILEERRORBOX );
+  // Prevents the system from popping a dialog for debugging if the
+  // application fails due to invalid memory access.
+  SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX |
+               SEM_NOOPENFILEERRORBOX);
 #endif // if defined(_WIN32)
 }
 
-void 
-Runner::printUsage( const char *appName )
-{
-   printf( 
-      "Usage: %s [options]\n"
-      "\n"
-      "If --test is not specified, then all the test cases be run.\n"
-      "\n"
-      "Valid options:\n"
-      "--list-tests: print the name of all test cases on the standard\n"
-      "              output and exit.\n"
-      "--test TESTNAME: executes the test case with the specified name.\n"
-      "                 May be repeated.\n"
-      "--test-auto: prevent dialog prompting for debugging on crash.\n"
-      , appName );
+void Runner::printUsage(const char *appName) {
+  printf("Usage: %s [options]\n"
+         "\n"
+         "If --test is not specified, then all the test cases be run.\n"
+         "\n"
+         "Valid options:\n"
+         "--list-tests: print the name of all test cases on the standard\n"
+         "              output and exit.\n"
+         "--test TESTNAME: executes the test case with the specified name.\n"
+         "                 May be repeated.\n"
+         "--test-auto: prevent dialog prompting for debugging on crash.\n",
+         appName);
 }
 
-
-
 // Assertion functions
 // //////////////////////////////////////////////////////////////////
 
-TestResult &
-checkStringEqual( TestResult &result, 
-                  const std::string &expected, const std::string &actual,
-                  const char *file, unsigned int line, const char *expr )
-{
-   if ( expected != actual )
-   {
-      result.addFailure( file, line, expr );
-      result << "Expected: '" << expected << "'\n";
-      result << "Actual  : '" << actual << "'";
-   }
-   return result;
+TestResult &checkStringEqual(TestResult &result,
+                             const std::string &expected,
+                             const std::string &actual,
+                             const char *file,
+                             unsigned int line,
+                             const char *expr) {
+  if (expected != actual) {
+    result.addFailure(file, line, expr);
+    result << "Expected: '" << expected << "'\n";
+    result << "Actual  : '" << actual << "'";
+  }
+  return result;
 }
 
-
 } // namespace JsonTest
 // vim: et ts=4 sts=4 sw=4 tw=0
diff --git a/src/test_lib_json/jsontest.h b/src/test_lib_json/jsontest.h
index 70a5c2c..6c893a2 100644
--- a/src/test_lib_json/jsontest.h
+++ b/src/test_lib_json/jsontest.h
@@ -4,15 +4,15 @@
 // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
 
 #ifndef JSONTEST_H_INCLUDED
-# define JSONTEST_H_INCLUDED
+#define JSONTEST_H_INCLUDED
 
-# include <json/config.h>
-# include <json/value.h>
-# include <json/writer.h>
-# include <stdio.h>
-# include <deque>
-# include <sstream>
-# include <string>
+#include <json/config.h>
+#include <json/value.h>
+#include <json/writer.h>
+#include <stdio.h>
+#include <deque>
+#include <sstream>
+#include <string>
 
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
@@ -20,8 +20,6 @@
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
 
-
-
 /** \brief Unit testing framework.
  * \warning: all assertions are non-aborting, test case execution will continue
  *           even if an assertion namespace.
@@ -30,244 +28,239 @@
  */
 namespace JsonTest {
 
+class Failure {
+public:
+  const char *file_;
+  unsigned int line_;
+  std::string expr_;
+  std::string message_;
+  unsigned int nestingLevel_;
+};
 
-   class Failure
-   {
-   public:
-      const char *file_;
-      unsigned int line_;
-      std::string expr_;
-      std::string message_;
-      unsigned int nestingLevel_;
-   };
+/// Context used to create the assertion callstack on failure.
+/// Must be a POD to allow inline initialisation without stepping
+/// into the debugger.
+struct PredicateContext {
+  typedef unsigned int Id;
+  Id id_;
+  const char *file_;
+  unsigned int line_;
+  const char *expr_;
+  PredicateContext *next_;
+  /// Related Failure, set when the PredicateContext is converted
+  /// into a Failure.
+  Failure *failure_;
+};
 
+class TestResult {
+public:
+  TestResult();
 
-   /// Context used to create the assertion callstack on failure.
-   /// Must be a POD to allow inline initialisation without stepping 
-   /// into the debugger.
-   struct PredicateContext
-   {
-      typedef unsigned int Id;
-      Id id_;
-      const char *file_;
-      unsigned int line_;
-      const char *expr_;
-      PredicateContext *next_;
-      /// Related Failure, set when the PredicateContext is converted
-      /// into a Failure.
-      Failure *failure_;
-   };
+  /// \internal Implementation detail for assertion macros
+  /// Not encapsulated to prevent step into when debugging failed assertions
+  /// Incremented by one on assertion predicate entry, decreased by one
+  /// by addPredicateContext().
+  PredicateContext::Id predicateId_;
 
-   class TestResult
-   {
-   public:
-      TestResult();
+  /// \internal Implementation detail for predicate macros
+  PredicateContext *predicateStackTail_;
 
-      /// \internal Implementation detail for assertion macros
-      /// Not encapsulated to prevent step into when debugging failed assertions
-      /// Incremented by one on assertion predicate entry, decreased by one
-      /// by addPredicateContext().
-      PredicateContext::Id predicateId_;
+  void setTestName(const std::string &name);
 
-      /// \internal Implementation detail for predicate macros
-      PredicateContext *predicateStackTail_;
+  /// Adds an assertion failure.
+  TestResult &
+  addFailure(const char *file, unsigned int line, const char *expr = 0);
 
-      void setTestName( const std::string &name );
+  /// Removes the last PredicateContext added to the predicate stack
+  /// chained list.
+  /// Next messages will be targed at the PredicateContext that was removed.
+  TestResult &popPredicateContext();
 
-      /// Adds an assertion failure.
-      TestResult &addFailure( const char *file, unsigned int line,
-                              const char *expr = 0 );
+  bool failed() const;
 
-      /// Removes the last PredicateContext added to the predicate stack
-      /// chained list.
-      /// Next messages will be targed at the PredicateContext that was removed.
-      TestResult &popPredicateContext();
+  void printFailure(bool printTestName) const;
 
-      bool failed() const;
+  // Generic operator that will work with anything ostream can deal with.
+  template <typename T> TestResult &operator<<(const T &value) {
+    std::ostringstream oss;
+    oss.precision(16);
+    oss.setf(std::ios_base::floatfield);
+    oss << value;
+    return addToLastFailure(oss.str());
+  }
 
-      void printFailure( bool printTestName ) const;
+  // Specialized versions.
+  TestResult &operator<<(bool value);
+  // std:ostream does not support 64bits integers on all STL implementation
+  TestResult &operator<<(Json::Int64 value);
+  TestResult &operator<<(Json::UInt64 value);
 
-      // Generic operator that will work with anything ostream can deal with.
-      template <typename T>
-      TestResult &operator << ( const T& value ) {
-         std::ostringstream oss;
-         oss.precision( 16 );
-         oss.setf( std::ios_base::floatfield );
-         oss << value;
-         return addToLastFailure(oss.str());
-      }
+private:
+  TestResult &addToLastFailure(const std::string &message);
+  unsigned int getAssertionNestingLevel() const;
+  /// Adds a failure or a predicate context
+  void addFailureInfo(const char *file,
+                      unsigned int line,
+                      const char *expr,
+                      unsigned int nestingLevel);
+  static std::string indentText(const std::string &text,
+                                const std::string &indent);
 
-      // Specialized versions.
-      TestResult &operator << ( bool value );
-      // std:ostream does not support 64bits integers on all STL implementation
-      TestResult &operator << ( Json::Int64 value );
-      TestResult &operator << ( Json::UInt64 value );
+  typedef std::deque<Failure> Failures;
+  Failures failures_;
+  std::string name_;
+  PredicateContext rootPredicateNode_;
+  PredicateContext::Id lastUsedPredicateId_;
+  /// Failure which is the target of the messages added using operator <<
+  Failure *messageTarget_;
+};
 
-   private:
-      TestResult &addToLastFailure( const std::string &message );
-      unsigned int getAssertionNestingLevel() const;
-      /// Adds a failure or a predicate context
-      void addFailureInfo( const char *file, unsigned int line,
-                           const char *expr, unsigned int nestingLevel  );
-      static std::string indentText( const std::string &text, 
-                                     const std::string &indent );
+class TestCase {
+public:
+  TestCase();
 
-      typedef std::deque<Failure> Failures;
-      Failures failures_;
-      std::string name_;
-      PredicateContext rootPredicateNode_;
-      PredicateContext::Id lastUsedPredicateId_;
-      /// Failure which is the target of the messages added using operator <<
-      Failure *messageTarget_;
-   };
+  virtual ~TestCase();
 
+  void run(TestResult &result);
 
-   class TestCase
-   {
-   public:
-      TestCase();
+  virtual const char *testName() const = 0;
 
-      virtual ~TestCase();
+protected:
+  TestResult *result_;
 
-      void run( TestResult &result );
+private:
+  virtual void runTestCase() = 0;
+};
 
-      virtual const char *testName() const = 0;
+/// Function pointer type for TestCase factory
+typedef TestCase *(*TestCaseFactory)();
 
-   protected:
-      TestResult *result_;
+class Runner {
+public:
+  Runner();
 
-   private:
-      virtual void runTestCase() = 0;
-   };
+  /// Adds a test to the suite
+  Runner &add(TestCaseFactory factory);
 
-   /// Function pointer type for TestCase factory
-   typedef TestCase *(*TestCaseFactory)();
+  /// Runs test as specified on the command-line
+  /// If no command-line arguments are provided, run all tests.
+  /// If --list-tests is provided, then print the list of all test cases
+  /// If --test <testname> is provided, then run test testname.
+  int runCommandLine(int argc, const char *argv[]) const;
 
-   class Runner
-   {
-   public:
-      Runner();
+  /// Runs all the test cases
+  bool runAllTest(bool printSummary) const;
 
-      /// Adds a test to the suite
-      Runner &add( TestCaseFactory factory );
+  /// Returns the number of test case in the suite
+  unsigned int testCount() const;
 
-      /// Runs test as specified on the command-line
-      /// If no command-line arguments are provided, run all tests.
-      /// If --list-tests is provided, then print the list of all test cases
-      /// If --test <testname> is provided, then run test testname.
-      int runCommandLine( int argc, const char *argv[] ) const;
+  /// Returns the name of the test case at the specified index
+  std::string testNameAt(unsigned int index) const;
 
-      /// Runs all the test cases
-      bool runAllTest( bool printSummary ) const;
+  /// Runs the test case at the specified index using the specified TestResult
+  void runTestAt(unsigned int index, TestResult &result) const;
 
-      /// Returns the number of test case in the suite
-      unsigned int testCount() const;
+  static void printUsage(const char *appName);
 
-      /// Returns the name of the test case at the specified index
-      std::string testNameAt( unsigned int index ) const;
+private: // prevents copy construction and assignment
+  Runner(const Runner &other);
+  Runner &operator=(const Runner &other);
 
-      /// Runs the test case at the specified index using the specified TestResult
-      void runTestAt( unsigned int index, TestResult &result ) const;
+private:
+  void listTests() const;
+  bool testIndex(const std::string &testName, unsigned int &index) const;
+  static void preventDialogOnCrash();
 
-      static void printUsage( const char *appName );
+private:
+  typedef std::deque<TestCaseFactory> Factories;
+  Factories tests_;
+};
 
-   private: // prevents copy construction and assignment
-      Runner( const Runner &other );
-      Runner &operator =( const Runner &other );
+template <typename T, typename U>
+TestResult &checkEqual(TestResult &result,
+                       const T &expected,
+                       const U &actual,
+                       const char *file,
+                       unsigned int line,
+                       const char *expr) {
+  if (static_cast<U>(expected) != actual) {
+    result.addFailure(file, line, expr);
+    result << "Expected: " << static_cast<U>(expected) << "\n";
+    result << "Actual  : " << actual;
+  }
+  return result;
+}
 
-   private:
-      void listTests() const;
-      bool testIndex( const std::string &testName, unsigned int &index ) const;
-      static void preventDialogOnCrash();
-
-   private:
-      typedef std::deque<TestCaseFactory> Factories;
-      Factories tests_;
-   };
-
-   template<typename T, typename U>
-   TestResult &
-   checkEqual( TestResult &result, const T &expected, const U &actual, 
-               const char *file, unsigned int line, const char *expr )
-   {
-      if ( static_cast< U >( expected ) != actual )
-      {
-         result.addFailure( file, line, expr );
-         result << "Expected: " << static_cast< U >( expected ) << "\n";
-         result << "Actual  : " << actual;
-      }
-      return result;
-   }
-
-
-   TestResult &
-   checkStringEqual( TestResult &result, 
-                     const std::string &expected, const std::string &actual,
-                     const char *file, unsigned int line, const char *expr );
+TestResult &checkStringEqual(TestResult &result,
+                             const std::string &expected,
+                             const std::string &actual,
+                             const char *file,
+                             unsigned int line,
+                             const char *expr);
 
 } // namespace JsonTest
 
-
 /// \brief Asserts that the given expression is true.
 /// JSONTEST_ASSERT( x == y ) << "x=" << x << ", y=" << y;
 /// JSONTEST_ASSERT( x == y );
-#define JSONTEST_ASSERT( expr )                                               \
-   if ( expr )                                                                \
-   {                                                                          \
-   }                                                                          \
-   else                                                                       \
-      result_->addFailure( __FILE__, __LINE__, #expr )
+#define JSONTEST_ASSERT(expr)                                                  \
+  if (expr) {                                                                  \
+  } else                                                                       \
+  result_->addFailure(__FILE__, __LINE__, #expr)
 
 /// \brief Asserts that the given predicate is true.
-/// The predicate may do other assertions and be a member function of the fixture.
-#define JSONTEST_ASSERT_PRED( expr )                                    \
-   {                                                                    \
-      JsonTest::PredicateContext _minitest_Context = {                  \
-         result_->predicateId_, __FILE__, __LINE__, #expr };            \
-      result_->predicateStackTail_->next_ = &_minitest_Context;         \
-      result_->predicateId_ += 1;                                       \
-      result_->predicateStackTail_ = &_minitest_Context;                \
-      (expr);                                                           \
-      result_->popPredicateContext();                                   \
-   }
+/// The predicate may do other assertions and be a member function of the
+/// fixture.
+#define JSONTEST_ASSERT_PRED(expr)                                             \
+  {                                                                            \
+    JsonTest::PredicateContext _minitest_Context = {                           \
+      result_->predicateId_, __FILE__, __LINE__, #expr                         \
+    };                                                                         \
+    result_->predicateStackTail_->next_ = &_minitest_Context;                  \
+    result_->predicateId_ += 1;                                                \
+    result_->predicateStackTail_ = &_minitest_Context;                         \
+    (expr);                                                                    \
+    result_->popPredicateContext();                                            \
+  }
 
 /// \brief Asserts that two values are equals.
-#define JSONTEST_ASSERT_EQUAL( expected, actual )          \
-   JsonTest::checkEqual( *result_, expected, actual,       \
-                         __FILE__, __LINE__,               \
-                         #expected " == " #actual )
+#define JSONTEST_ASSERT_EQUAL(expected, actual)                                \
+  JsonTest::checkEqual(*result_,                                               \
+                       expected,                                               \
+                       actual,                                                 \
+                       __FILE__,                                               \
+                       __LINE__,                                               \
+                       #expected " == " #actual)
 
 /// \brief Asserts that two values are equals.
-#define JSONTEST_ASSERT_STRING_EQUAL( expected, actual ) \
-   JsonTest::checkStringEqual( *result_,                 \
-      std::string(expected), std::string(actual),        \
-      __FILE__, __LINE__,                                \
-      #expected " == " #actual )
+#define JSONTEST_ASSERT_STRING_EQUAL(expected, actual)                         \
+  JsonTest::checkStringEqual(*result_,                                         \
+                             std::string(expected),                            \
+                             std::string(actual),                              \
+                             __FILE__,                                         \
+                             __LINE__,                                         \
+                             #expected " == " #actual)
 
 /// \brief Begin a fixture test case.
-#define JSONTEST_FIXTURE( FixtureType, name )                  \
-   class Test##FixtureType##name : public FixtureType          \
-   {                                                           \
-   public:                                                     \
-      static JsonTest::TestCase *factory()                     \
-      {                                                        \
-         return new Test##FixtureType##name();                 \
-      }                                                        \
-   public: /* overidden from TestCase */                       \
-      virtual const char *testName() const                     \
-      {                                                        \
-         return #FixtureType "/" #name;                        \
-      }                                                        \
-      virtual void runTestCase();                              \
-   };                                                          \
-                                                               \
-   void Test##FixtureType##name::runTestCase()
+#define JSONTEST_FIXTURE(FixtureType, name)                                    \
+  class Test##FixtureType##name : public FixtureType {                         \
+  public:                                                                      \
+    static JsonTest::TestCase *factory() {                                     \
+      return new Test##FixtureType##name();                                    \
+    }                                                                          \
+                                                                               \
+  public: /* overidden from TestCase */                                        \
+    virtual const char *testName() const { return #FixtureType "/" #name; }    \
+    virtual void runTestCase();                                                \
+  };                                                                           \
+                                                                               \
+  void Test##FixtureType##name::runTestCase()
 
-#define JSONTEST_FIXTURE_FACTORY( FixtureType, name ) \
-   &Test##FixtureType##name::factory
+#define JSONTEST_FIXTURE_FACTORY(FixtureType, name)                            \
+  &Test##FixtureType##name::factory
 
-#define JSONTEST_REGISTER_FIXTURE( runner, FixtureType, name ) \
-   (runner).add( JSONTEST_FIXTURE_FACTORY( FixtureType, name ) )
+#define JSONTEST_REGISTER_FIXTURE(runner, FixtureType, name)                   \
+  (runner).add(JSONTEST_FIXTURE_FACTORY(FixtureType, name))
 
 #endif // ifndef JSONTEST_H_INCLUDED
 // vim: et ts=4 sts=4 sw=4 tw=0
diff --git a/src/test_lib_json/main.cpp b/src/test_lib_json/main.cpp
index 8eb4996..10810c2 100644
--- a/src/test_lib_json/main.cpp
+++ b/src/test_lib_json/main.cpp
@@ -22,7 +22,6 @@
 static const float kfint32max = float(kint32max);
 static const float kfuint32max = float(kuint32max);
 
-
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
 // Json Library test cases
@@ -30,1629 +29,1557 @@
 // //////////////////////////////////////////////////////////////////
 
 #if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
-static inline double uint64ToDouble( Json::UInt64 value )
-{
-    return static_cast<double>( value );
+static inline double uint64ToDouble(Json::UInt64 value) {
+  return static_cast<double>(value);
 }
-#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
-static inline double uint64ToDouble( Json::UInt64 value )
-{
-    return static_cast<double>( Json::Int64(value/2) ) * 2.0 + Json::Int64(value & 1);
+#else  // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+static inline double uint64ToDouble(Json::UInt64 value) {
+  return static_cast<double>(Json::Int64(value / 2)) * 2.0 +
+         Json::Int64(value & 1);
 }
 #endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
 
-struct ValueTest : JsonTest::TestCase
-{
-   Json::Value null_;
-   Json::Value emptyArray_;
-   Json::Value emptyObject_;
-   Json::Value integer_;
-   Json::Value unsignedInteger_;
-   Json::Value smallUnsignedInteger_;
-   Json::Value real_;
-   Json::Value float_;
-   Json::Value array1_;
-   Json::Value object1_;
-   Json::Value emptyString_;
-   Json::Value string1_;
-   Json::Value string_;
-   Json::Value true_;
-   Json::Value false_;
+struct ValueTest : JsonTest::TestCase {
+  Json::Value null_;
+  Json::Value emptyArray_;
+  Json::Value emptyObject_;
+  Json::Value integer_;
+  Json::Value unsignedInteger_;
+  Json::Value smallUnsignedInteger_;
+  Json::Value real_;
+  Json::Value float_;
+  Json::Value array1_;
+  Json::Value object1_;
+  Json::Value emptyString_;
+  Json::Value string1_;
+  Json::Value string_;
+  Json::Value true_;
+  Json::Value false_;
 
+  ValueTest()
+      : emptyArray_(Json::arrayValue), emptyObject_(Json::objectValue),
+        integer_(123456789), unsignedInteger_(34567890u),
+        smallUnsignedInteger_(Json::Value::UInt(Json::Value::maxInt)),
+        real_(1234.56789), float_(0.00390625f), emptyString_(""), string1_("a"),
+        string_("sometext with space"), true_(true), false_(false) {
+    array1_.append(1234);
+    object1_["id"] = 1234;
+  }
 
-   ValueTest()
-      : emptyArray_( Json::arrayValue )
-      , emptyObject_( Json::objectValue )
-      , integer_( 123456789 )
-      , unsignedInteger_( 34567890u )
-      , smallUnsignedInteger_( Json::Value::UInt( Json::Value::maxInt ) )
-      , real_( 1234.56789 )
-      , float_( 0.00390625f )
-      , emptyString_( "" )
-      , string1_( "a" )
-      , string_( "sometext with space" )
-      , true_( true )
-      , false_( false )
-   {
-      array1_.append( 1234 );
-      object1_["id"] = 1234;
-   }
+  struct IsCheck {
+    /// Initialize all checks to \c false by default.
+    IsCheck();
 
-   struct IsCheck
-   {
-      /// Initialize all checks to \c false by default.
-      IsCheck();
+    bool isObject_;
+    bool isArray_;
+    bool isBool_;
+    bool isString_;
+    bool isNull_;
 
-      bool isObject_;
-      bool isArray_;
-      bool isBool_;
-      bool isString_;
-      bool isNull_;
+    bool isInt_;
+    bool isInt64_;
+    bool isUInt_;
+    bool isUInt64_;
+    bool isIntegral_;
+    bool isDouble_;
+    bool isNumeric_;
+  };
 
-      bool isInt_;
-      bool isInt64_;
-      bool isUInt_;
-      bool isUInt64_;
-      bool isIntegral_;
-      bool isDouble_;
-      bool isNumeric_;
-   };
+  void checkConstMemberCount(const Json::Value &value,
+                             unsigned int expectedCount);
 
-   void checkConstMemberCount( const Json::Value &value, unsigned int expectedCount );
+  void checkMemberCount(Json::Value &value, unsigned int expectedCount);
 
-   void checkMemberCount( Json::Value &value, unsigned int expectedCount );
+  void checkIs(const Json::Value &value, const IsCheck &check);
 
-   void checkIs( const Json::Value &value, const IsCheck &check );
+  void checkIsLess(const Json::Value &x, const Json::Value &y);
 
-   void checkIsLess( const Json::Value &x, const Json::Value &y );
+  void checkIsEqual(const Json::Value &x, const Json::Value &y);
 
-   void checkIsEqual( const Json::Value &x, const Json::Value &y );
-
-   /// Normalize the representation of floating-point number by stripped leading 0 in exponent.
-   static std::string normalizeFloatingPointStr( const std::string &s );
+  /// Normalize the representation of floating-point number by stripped leading
+  /// 0 in exponent.
+  static std::string normalizeFloatingPointStr(const std::string &s);
 };
 
-
-std::string 
-ValueTest::normalizeFloatingPointStr( const std::string &s )
-{
-    std::string::size_type index = s.find_last_of( "eE" );
-    if ( index != std::string::npos )
+std::string ValueTest::normalizeFloatingPointStr(const std::string &s) {
+  std::string::size_type index = s.find_last_of("eE");
+  if (index != std::string::npos) {
+    std::string::size_type hasSign =
+        (s[index + 1] == '+' || s[index + 1] == '-') ? 1 : 0;
+    std::string::size_type exponentStartIndex = index + 1 + hasSign;
+    std::string normalized = s.substr(0, exponentStartIndex);
+    std::string::size_type indexDigit =
+        s.find_first_not_of('0', exponentStartIndex);
+    std::string exponent = "0";
+    if (indexDigit !=
+        std::string::npos) // There is an exponent different from 0
     {
-        std::string::size_type hasSign = (s[index+1] == '+' || s[index+1] == '-') ? 1 : 0;
-        std::string::size_type exponentStartIndex = index + 1 + hasSign;
-        std::string normalized = s.substr( 0, exponentStartIndex );
-        std::string::size_type indexDigit = s.find_first_not_of( '0', exponentStartIndex );
-        std::string exponent = "0";
-        if ( indexDigit != std::string::npos ) // There is an exponent different from 0
-        {
-            exponent = s.substr( indexDigit );
-        }
-        return normalized + exponent;
+      exponent = s.substr(indexDigit);
     }
-    return s;
+    return normalized + exponent;
+  }
+  return s;
 }
 
-
-JSONTEST_FIXTURE( ValueTest, checkNormalizeFloatingPointStr )
-{
-    JSONTEST_ASSERT_STRING_EQUAL( "0.0", normalizeFloatingPointStr("0.0") );
-    JSONTEST_ASSERT_STRING_EQUAL( "0e0", normalizeFloatingPointStr("0e0") );
-    JSONTEST_ASSERT_STRING_EQUAL( "1234.0", normalizeFloatingPointStr("1234.0") );
-    JSONTEST_ASSERT_STRING_EQUAL( "1234.0e0", normalizeFloatingPointStr("1234.0e0") );
-    JSONTEST_ASSERT_STRING_EQUAL( "1234.0e+0", normalizeFloatingPointStr("1234.0e+0") );
-    JSONTEST_ASSERT_STRING_EQUAL( "1234e-1", normalizeFloatingPointStr("1234e-1") );
-    JSONTEST_ASSERT_STRING_EQUAL( "1234e10", normalizeFloatingPointStr("1234e10") );
-    JSONTEST_ASSERT_STRING_EQUAL( "1234e10", normalizeFloatingPointStr("1234e010") );
-    JSONTEST_ASSERT_STRING_EQUAL( "1234e+10", normalizeFloatingPointStr("1234e+010") );
-    JSONTEST_ASSERT_STRING_EQUAL( "1234e-10", normalizeFloatingPointStr("1234e-010") );
-    JSONTEST_ASSERT_STRING_EQUAL( "1234e+100", normalizeFloatingPointStr("1234e+100") );
-    JSONTEST_ASSERT_STRING_EQUAL( "1234e-100", normalizeFloatingPointStr("1234e-100") );
-    JSONTEST_ASSERT_STRING_EQUAL( "1234e+1", normalizeFloatingPointStr("1234e+001") );
+JSONTEST_FIXTURE(ValueTest, checkNormalizeFloatingPointStr) {
+  JSONTEST_ASSERT_STRING_EQUAL("0.0", normalizeFloatingPointStr("0.0"));
+  JSONTEST_ASSERT_STRING_EQUAL("0e0", normalizeFloatingPointStr("0e0"));
+  JSONTEST_ASSERT_STRING_EQUAL("1234.0", normalizeFloatingPointStr("1234.0"));
+  JSONTEST_ASSERT_STRING_EQUAL("1234.0e0",
+                               normalizeFloatingPointStr("1234.0e0"));
+  JSONTEST_ASSERT_STRING_EQUAL("1234.0e+0",
+                               normalizeFloatingPointStr("1234.0e+0"));
+  JSONTEST_ASSERT_STRING_EQUAL("1234e-1", normalizeFloatingPointStr("1234e-1"));
+  JSONTEST_ASSERT_STRING_EQUAL("1234e10", normalizeFloatingPointStr("1234e10"));
+  JSONTEST_ASSERT_STRING_EQUAL("1234e10",
+                               normalizeFloatingPointStr("1234e010"));
+  JSONTEST_ASSERT_STRING_EQUAL("1234e+10",
+                               normalizeFloatingPointStr("1234e+010"));
+  JSONTEST_ASSERT_STRING_EQUAL("1234e-10",
+                               normalizeFloatingPointStr("1234e-010"));
+  JSONTEST_ASSERT_STRING_EQUAL("1234e+100",
+                               normalizeFloatingPointStr("1234e+100"));
+  JSONTEST_ASSERT_STRING_EQUAL("1234e-100",
+                               normalizeFloatingPointStr("1234e-100"));
+  JSONTEST_ASSERT_STRING_EQUAL("1234e+1",
+                               normalizeFloatingPointStr("1234e+001"));
 }
 
-
-JSONTEST_FIXTURE( ValueTest, memberCount )
-{
-   JSONTEST_ASSERT_PRED( checkMemberCount(emptyArray_, 0) );
-   JSONTEST_ASSERT_PRED( checkMemberCount(emptyObject_, 0) );
-   JSONTEST_ASSERT_PRED( checkMemberCount(array1_, 1) );
-   JSONTEST_ASSERT_PRED( checkMemberCount(object1_, 1) );
-   JSONTEST_ASSERT_PRED( checkMemberCount(null_, 0) );
-   JSONTEST_ASSERT_PRED( checkMemberCount(integer_, 0) );
-   JSONTEST_ASSERT_PRED( checkMemberCount(unsignedInteger_, 0) );
-   JSONTEST_ASSERT_PRED( checkMemberCount(smallUnsignedInteger_, 0) );
-   JSONTEST_ASSERT_PRED( checkMemberCount(real_, 0) );
-   JSONTEST_ASSERT_PRED( checkMemberCount(emptyString_, 0) );
-   JSONTEST_ASSERT_PRED( checkMemberCount(string_, 0) );
-   JSONTEST_ASSERT_PRED( checkMemberCount(true_, 0) );
+JSONTEST_FIXTURE(ValueTest, memberCount) {
+  JSONTEST_ASSERT_PRED(checkMemberCount(emptyArray_, 0));
+  JSONTEST_ASSERT_PRED(checkMemberCount(emptyObject_, 0));
+  JSONTEST_ASSERT_PRED(checkMemberCount(array1_, 1));
+  JSONTEST_ASSERT_PRED(checkMemberCount(object1_, 1));
+  JSONTEST_ASSERT_PRED(checkMemberCount(null_, 0));
+  JSONTEST_ASSERT_PRED(checkMemberCount(integer_, 0));
+  JSONTEST_ASSERT_PRED(checkMemberCount(unsignedInteger_, 0));
+  JSONTEST_ASSERT_PRED(checkMemberCount(smallUnsignedInteger_, 0));
+  JSONTEST_ASSERT_PRED(checkMemberCount(real_, 0));
+  JSONTEST_ASSERT_PRED(checkMemberCount(emptyString_, 0));
+  JSONTEST_ASSERT_PRED(checkMemberCount(string_, 0));
+  JSONTEST_ASSERT_PRED(checkMemberCount(true_, 0));
 }
 
+JSONTEST_FIXTURE(ValueTest, objects) {
+  // Types
+  IsCheck checks;
+  checks.isObject_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(emptyObject_, checks));
+  JSONTEST_ASSERT_PRED(checkIs(object1_, checks));
 
-JSONTEST_FIXTURE( ValueTest, objects )
-{
-   // Types
-   IsCheck checks;
-   checks.isObject_ = true;
-   JSONTEST_ASSERT_PRED( checkIs( emptyObject_, checks ) );
-   JSONTEST_ASSERT_PRED( checkIs( object1_, checks ) );
+  JSONTEST_ASSERT_EQUAL(Json::objectValue, emptyObject_.type());
 
-   JSONTEST_ASSERT_EQUAL(Json::objectValue, emptyObject_.type());
+  // Empty object okay
+  JSONTEST_ASSERT(emptyObject_.isConvertibleTo(Json::nullValue));
 
-   // Empty object okay
-   JSONTEST_ASSERT(emptyObject_.isConvertibleTo(Json::nullValue));
+  // Non-empty object not okay
+  JSONTEST_ASSERT(!object1_.isConvertibleTo(Json::nullValue));
 
-   // Non-empty object not okay
-   JSONTEST_ASSERT(!object1_.isConvertibleTo(Json::nullValue));
+  // Always okay
+  JSONTEST_ASSERT(emptyObject_.isConvertibleTo(Json::objectValue));
 
-   // Always okay
-   JSONTEST_ASSERT(emptyObject_.isConvertibleTo(Json::objectValue));
+  // Never okay
+  JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::arrayValue));
+  JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::realValue));
+  JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::booleanValue));
+  JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::stringValue));
 
-   // Never okay
-   JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::arrayValue));
-   JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::intValue));
-   JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::uintValue));
-   JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::realValue));
-   JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::booleanValue));
-   JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::stringValue));
+  // Access through const reference
+  const Json::Value &constObject = object1_;
 
-   // Access through const reference
-   const Json::Value &constObject = object1_;
+  JSONTEST_ASSERT_EQUAL(Json::Value(1234), constObject["id"]);
+  JSONTEST_ASSERT_EQUAL(Json::Value(), constObject["unknown id"]);
 
-   JSONTEST_ASSERT_EQUAL(Json::Value(1234), constObject["id"]);
-   JSONTEST_ASSERT_EQUAL(Json::Value(), constObject["unknown id"]);
+  // Access through non-const reference
+  JSONTEST_ASSERT_EQUAL(Json::Value(1234), object1_["id"]);
+  JSONTEST_ASSERT_EQUAL(Json::Value(), object1_["unknown id"]);
 
-   // Access through non-const reference
-   JSONTEST_ASSERT_EQUAL(Json::Value(1234), object1_["id"]);
-   JSONTEST_ASSERT_EQUAL(Json::Value(), object1_["unknown id"]);
-
-   object1_["some other id"] = "foo";
-   JSONTEST_ASSERT_EQUAL(Json::Value("foo"), object1_["some other id"]);
+  object1_["some other id"] = "foo";
+  JSONTEST_ASSERT_EQUAL(Json::Value("foo"), object1_["some other id"]);
 }
 
+JSONTEST_FIXTURE(ValueTest, arrays) {
+  const unsigned int index0 = 0;
 
-JSONTEST_FIXTURE( ValueTest, arrays )
-{
-   const unsigned int index0 = 0;
+  // Types
+  IsCheck checks;
+  checks.isArray_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(emptyArray_, checks));
+  JSONTEST_ASSERT_PRED(checkIs(array1_, checks));
 
-   // Types
-   IsCheck checks;
-   checks.isArray_ = true;
-   JSONTEST_ASSERT_PRED( checkIs( emptyArray_, checks ) );
-   JSONTEST_ASSERT_PRED( checkIs( array1_, checks ) );
+  JSONTEST_ASSERT_EQUAL(Json::arrayValue, array1_.type());
 
-   JSONTEST_ASSERT_EQUAL(Json::arrayValue, array1_.type());
+  // Empty array okay
+  JSONTEST_ASSERT(emptyArray_.isConvertibleTo(Json::nullValue));
 
-   // Empty array okay
-   JSONTEST_ASSERT(emptyArray_.isConvertibleTo(Json::nullValue));
+  // Non-empty array not okay
+  JSONTEST_ASSERT(!array1_.isConvertibleTo(Json::nullValue));
 
-   // Non-empty array not okay
-   JSONTEST_ASSERT(!array1_.isConvertibleTo(Json::nullValue));
+  // Always okay
+  JSONTEST_ASSERT(emptyArray_.isConvertibleTo(Json::arrayValue));
 
-   // Always okay
-   JSONTEST_ASSERT(emptyArray_.isConvertibleTo(Json::arrayValue));
+  // Never okay
+  JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::objectValue));
+  JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::realValue));
+  JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::booleanValue));
+  JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::stringValue));
 
-   // Never okay
-   JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::objectValue));
-   JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::intValue));
-   JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::uintValue));
-   JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::realValue));
-   JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::booleanValue));
-   JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::stringValue));
+  // Access through const reference
+  const Json::Value &constArray = array1_;
+  JSONTEST_ASSERT_EQUAL(Json::Value(1234), constArray[index0]);
+  JSONTEST_ASSERT_EQUAL(Json::Value(1234), constArray[0]);
 
-   // Access through const reference
-   const Json::Value &constArray = array1_;
-   JSONTEST_ASSERT_EQUAL(Json::Value(1234), constArray[index0]);
-   JSONTEST_ASSERT_EQUAL(Json::Value(1234), constArray[0]);
+  // Access through non-const reference
+  JSONTEST_ASSERT_EQUAL(Json::Value(1234), array1_[index0]);
+  JSONTEST_ASSERT_EQUAL(Json::Value(1234), array1_[0]);
 
-   // Access through non-const reference
-   JSONTEST_ASSERT_EQUAL(Json::Value(1234), array1_[index0]);
-   JSONTEST_ASSERT_EQUAL(Json::Value(1234), array1_[0]);
-
-   array1_[2] = Json::Value(17);
-   JSONTEST_ASSERT_EQUAL(Json::Value(), array1_[1]);
-   JSONTEST_ASSERT_EQUAL(Json::Value(17), array1_[2]);
+  array1_[2] = Json::Value(17);
+  JSONTEST_ASSERT_EQUAL(Json::Value(), array1_[1]);
+  JSONTEST_ASSERT_EQUAL(Json::Value(17), array1_[2]);
 }
 
+JSONTEST_FIXTURE(ValueTest, null) {
+  JSONTEST_ASSERT_EQUAL(Json::nullValue, null_.type());
 
-JSONTEST_FIXTURE( ValueTest, null )
-{
-   JSONTEST_ASSERT_EQUAL(Json::nullValue, null_.type());
+  IsCheck checks;
+  checks.isNull_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(null_, checks));
 
-   IsCheck checks;
-   checks.isNull_ = true;
-   JSONTEST_ASSERT_PRED( checkIs( null_, checks ) );
+  JSONTEST_ASSERT(null_.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(null_.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(null_.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(null_.isConvertibleTo(Json::realValue));
+  JSONTEST_ASSERT(null_.isConvertibleTo(Json::booleanValue));
+  JSONTEST_ASSERT(null_.isConvertibleTo(Json::stringValue));
+  JSONTEST_ASSERT(null_.isConvertibleTo(Json::arrayValue));
+  JSONTEST_ASSERT(null_.isConvertibleTo(Json::objectValue));
 
-   JSONTEST_ASSERT(null_.isConvertibleTo(Json::nullValue));
-   JSONTEST_ASSERT(null_.isConvertibleTo(Json::intValue));
-   JSONTEST_ASSERT(null_.isConvertibleTo(Json::uintValue));
-   JSONTEST_ASSERT(null_.isConvertibleTo(Json::realValue));
-   JSONTEST_ASSERT(null_.isConvertibleTo(Json::booleanValue));
-   JSONTEST_ASSERT(null_.isConvertibleTo(Json::stringValue));
-   JSONTEST_ASSERT(null_.isConvertibleTo(Json::arrayValue));
-   JSONTEST_ASSERT(null_.isConvertibleTo(Json::objectValue));
-
-   JSONTEST_ASSERT_EQUAL(Json::Int(0), null_.asInt());
-   JSONTEST_ASSERT_EQUAL(Json::LargestInt(0), null_.asLargestInt());
-   JSONTEST_ASSERT_EQUAL(Json::UInt(0), null_.asUInt());
-   JSONTEST_ASSERT_EQUAL(Json::LargestUInt(0), null_.asLargestUInt());
-   JSONTEST_ASSERT_EQUAL(0.0, null_.asDouble());
-   JSONTEST_ASSERT_EQUAL(0.0, null_.asFloat());
-   JSONTEST_ASSERT_STRING_EQUAL("", null_.asString());
+  JSONTEST_ASSERT_EQUAL(Json::Int(0), null_.asInt());
+  JSONTEST_ASSERT_EQUAL(Json::LargestInt(0), null_.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(Json::UInt(0), null_.asUInt());
+  JSONTEST_ASSERT_EQUAL(Json::LargestUInt(0), null_.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL(0.0, null_.asDouble());
+  JSONTEST_ASSERT_EQUAL(0.0, null_.asFloat());
+  JSONTEST_ASSERT_STRING_EQUAL("", null_.asString());
 }
 
+JSONTEST_FIXTURE(ValueTest, strings) {
+  JSONTEST_ASSERT_EQUAL(Json::stringValue, string1_.type());
 
-JSONTEST_FIXTURE( ValueTest, strings )
-{
-   JSONTEST_ASSERT_EQUAL(Json::stringValue, string1_.type());
+  IsCheck checks;
+  checks.isString_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(emptyString_, checks));
+  JSONTEST_ASSERT_PRED(checkIs(string_, checks));
+  JSONTEST_ASSERT_PRED(checkIs(string1_, checks));
 
-   IsCheck checks;
-   checks.isString_ = true;
-   JSONTEST_ASSERT_PRED( checkIs( emptyString_, checks ) );
-   JSONTEST_ASSERT_PRED( checkIs( string_, checks ) );
-   JSONTEST_ASSERT_PRED( checkIs( string1_, checks ) );
+  // Empty string okay
+  JSONTEST_ASSERT(emptyString_.isConvertibleTo(Json::nullValue));
 
-   // Empty string okay
-   JSONTEST_ASSERT(emptyString_.isConvertibleTo(Json::nullValue));
+  // Non-empty string not okay
+  JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::nullValue));
 
-   // Non-empty string not okay
-   JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::nullValue));
+  // Always okay
+  JSONTEST_ASSERT(string1_.isConvertibleTo(Json::stringValue));
 
-   // Always okay
-   JSONTEST_ASSERT(string1_.isConvertibleTo(Json::stringValue));
+  // Never okay
+  JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::objectValue));
+  JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::arrayValue));
+  JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::realValue));
 
-   // Never okay
-   JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::objectValue));
-   JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::arrayValue));
-   JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::intValue));
-   JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::uintValue));
-   JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::realValue));
-
-   JSONTEST_ASSERT_STRING_EQUAL("a", string1_.asString());
-   JSONTEST_ASSERT_STRING_EQUAL("a", string1_.asCString());
+  JSONTEST_ASSERT_STRING_EQUAL("a", string1_.asString());
+  JSONTEST_ASSERT_STRING_EQUAL("a", string1_.asCString());
 }
 
+JSONTEST_FIXTURE(ValueTest, bools) {
+  JSONTEST_ASSERT_EQUAL(Json::booleanValue, false_.type());
 
-JSONTEST_FIXTURE( ValueTest, bools )
-{
-   JSONTEST_ASSERT_EQUAL(Json::booleanValue, false_.type());
+  IsCheck checks;
+  checks.isBool_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(false_, checks));
+  JSONTEST_ASSERT_PRED(checkIs(true_, checks));
 
-   IsCheck checks;
-   checks.isBool_ = true;
-   JSONTEST_ASSERT_PRED( checkIs( false_, checks ) );
-   JSONTEST_ASSERT_PRED( checkIs( true_, checks ) );
+  // False okay
+  JSONTEST_ASSERT(false_.isConvertibleTo(Json::nullValue));
 
-   // False okay
-   JSONTEST_ASSERT(false_.isConvertibleTo(Json::nullValue));
+  // True not okay
+  JSONTEST_ASSERT(!true_.isConvertibleTo(Json::nullValue));
 
-   // True not okay
-   JSONTEST_ASSERT(!true_.isConvertibleTo(Json::nullValue));
+  // Always okay
+  JSONTEST_ASSERT(true_.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(true_.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(true_.isConvertibleTo(Json::realValue));
+  JSONTEST_ASSERT(true_.isConvertibleTo(Json::booleanValue));
+  JSONTEST_ASSERT(true_.isConvertibleTo(Json::stringValue));
 
-   // Always okay
-   JSONTEST_ASSERT(true_.isConvertibleTo(Json::intValue));
-   JSONTEST_ASSERT(true_.isConvertibleTo(Json::uintValue));
-   JSONTEST_ASSERT(true_.isConvertibleTo(Json::realValue));
-   JSONTEST_ASSERT(true_.isConvertibleTo(Json::booleanValue));
-   JSONTEST_ASSERT(true_.isConvertibleTo(Json::stringValue));
+  // Never okay
+  JSONTEST_ASSERT(!true_.isConvertibleTo(Json::arrayValue));
+  JSONTEST_ASSERT(!true_.isConvertibleTo(Json::objectValue));
 
-   // Never okay
-   JSONTEST_ASSERT(!true_.isConvertibleTo(Json::arrayValue));
-   JSONTEST_ASSERT(!true_.isConvertibleTo(Json::objectValue));
+  JSONTEST_ASSERT_EQUAL(true, true_.asBool());
+  JSONTEST_ASSERT_EQUAL(1, true_.asInt());
+  JSONTEST_ASSERT_EQUAL(1, true_.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(1, true_.asUInt());
+  JSONTEST_ASSERT_EQUAL(1, true_.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL(1.0, true_.asDouble());
+  JSONTEST_ASSERT_EQUAL(1.0, true_.asFloat());
 
-   JSONTEST_ASSERT_EQUAL(true, true_.asBool());
-   JSONTEST_ASSERT_EQUAL(1, true_.asInt());
-   JSONTEST_ASSERT_EQUAL(1, true_.asLargestInt());
-   JSONTEST_ASSERT_EQUAL(1, true_.asUInt());
-   JSONTEST_ASSERT_EQUAL(1, true_.asLargestUInt());
-   JSONTEST_ASSERT_EQUAL(1.0, true_.asDouble());
-   JSONTEST_ASSERT_EQUAL(1.0, true_.asFloat());
-
-   JSONTEST_ASSERT_EQUAL(false, false_.asBool());
-   JSONTEST_ASSERT_EQUAL(0, false_.asInt());
-   JSONTEST_ASSERT_EQUAL(0, false_.asLargestInt());
-   JSONTEST_ASSERT_EQUAL(0, false_.asUInt());
-   JSONTEST_ASSERT_EQUAL(0, false_.asLargestUInt());
-   JSONTEST_ASSERT_EQUAL(0.0, false_.asDouble());
-   JSONTEST_ASSERT_EQUAL(0.0, false_.asFloat());
+  JSONTEST_ASSERT_EQUAL(false, false_.asBool());
+  JSONTEST_ASSERT_EQUAL(0, false_.asInt());
+  JSONTEST_ASSERT_EQUAL(0, false_.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(0, false_.asUInt());
+  JSONTEST_ASSERT_EQUAL(0, false_.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL(0.0, false_.asDouble());
+  JSONTEST_ASSERT_EQUAL(0.0, false_.asFloat());
 }
 
+JSONTEST_FIXTURE(ValueTest, integers) {
+  IsCheck checks;
+  Json::Value val;
 
-JSONTEST_FIXTURE( ValueTest, integers )
-{
-   IsCheck checks;
-   Json::Value val;
+  // Conversions that don't depend on the value.
+  JSONTEST_ASSERT(Json::Value(17).isConvertibleTo(Json::realValue));
+  JSONTEST_ASSERT(Json::Value(17).isConvertibleTo(Json::stringValue));
+  JSONTEST_ASSERT(Json::Value(17).isConvertibleTo(Json::booleanValue));
+  JSONTEST_ASSERT(!Json::Value(17).isConvertibleTo(Json::arrayValue));
+  JSONTEST_ASSERT(!Json::Value(17).isConvertibleTo(Json::objectValue));
 
-   // Conversions that don't depend on the value.
-   JSONTEST_ASSERT(Json::Value(17).isConvertibleTo(Json::realValue));
-   JSONTEST_ASSERT(Json::Value(17).isConvertibleTo(Json::stringValue));
-   JSONTEST_ASSERT(Json::Value(17).isConvertibleTo(Json::booleanValue));
-   JSONTEST_ASSERT(!Json::Value(17).isConvertibleTo(Json::arrayValue));
-   JSONTEST_ASSERT(!Json::Value(17).isConvertibleTo(Json::objectValue));
+  JSONTEST_ASSERT(Json::Value(17U).isConvertibleTo(Json::realValue));
+  JSONTEST_ASSERT(Json::Value(17U).isConvertibleTo(Json::stringValue));
+  JSONTEST_ASSERT(Json::Value(17U).isConvertibleTo(Json::booleanValue));
+  JSONTEST_ASSERT(!Json::Value(17U).isConvertibleTo(Json::arrayValue));
+  JSONTEST_ASSERT(!Json::Value(17U).isConvertibleTo(Json::objectValue));
 
-   JSONTEST_ASSERT(Json::Value(17U).isConvertibleTo(Json::realValue));
-   JSONTEST_ASSERT(Json::Value(17U).isConvertibleTo(Json::stringValue));
-   JSONTEST_ASSERT(Json::Value(17U).isConvertibleTo(Json::booleanValue));
-   JSONTEST_ASSERT(!Json::Value(17U).isConvertibleTo(Json::arrayValue));
-   JSONTEST_ASSERT(!Json::Value(17U).isConvertibleTo(Json::objectValue));
+  JSONTEST_ASSERT(Json::Value(17.0).isConvertibleTo(Json::realValue));
+  JSONTEST_ASSERT(Json::Value(17.0).isConvertibleTo(Json::stringValue));
+  JSONTEST_ASSERT(Json::Value(17.0).isConvertibleTo(Json::booleanValue));
+  JSONTEST_ASSERT(!Json::Value(17.0).isConvertibleTo(Json::arrayValue));
+  JSONTEST_ASSERT(!Json::Value(17.0).isConvertibleTo(Json::objectValue));
 
-   JSONTEST_ASSERT(Json::Value(17.0).isConvertibleTo(Json::realValue));
-   JSONTEST_ASSERT(Json::Value(17.0).isConvertibleTo(Json::stringValue));
-   JSONTEST_ASSERT(Json::Value(17.0).isConvertibleTo(Json::booleanValue));
-   JSONTEST_ASSERT(!Json::Value(17.0).isConvertibleTo(Json::arrayValue));
-   JSONTEST_ASSERT(!Json::Value(17.0).isConvertibleTo(Json::objectValue));
+  // Default int
+  val = Json::Value(Json::intValue);
 
-   // Default int
-   val = Json::Value(Json::intValue);
+  JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
 
-   JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+  checks = IsCheck();
+  checks.isInt_ = true;
+  checks.isInt64_ = true;
+  checks.isUInt_ = true;
+  checks.isUInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
 
-   checks = IsCheck();
-   checks.isInt_ = true;
-   checks.isInt64_ = true;
-   checks.isUInt_ = true;
-   checks.isUInt64_ = true;
-   checks.isIntegral_ = true;
-   checks.isDouble_ = true;
-   checks.isNumeric_ = true;
-   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
 
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT_EQUAL(0, val.asInt());
+  JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(0, val.asUInt());
+  JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
+  JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
+  JSONTEST_ASSERT_EQUAL(false, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
 
-   JSONTEST_ASSERT_EQUAL(0, val.asInt());
-   JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
-   JSONTEST_ASSERT_EQUAL(0, val.asUInt());
-   JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
-   JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
-   JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
-   JSONTEST_ASSERT_EQUAL(false, val.asBool());
-   JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
+  // Default uint
+  val = Json::Value(Json::uintValue);
 
-   // Default uint
-   val = Json::Value(Json::uintValue);
+  JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
 
-   JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
+  checks = IsCheck();
+  checks.isInt_ = true;
+  checks.isInt64_ = true;
+  checks.isUInt_ = true;
+  checks.isUInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
 
-   checks = IsCheck();
-   checks.isInt_ = true;
-   checks.isInt64_ = true;
-   checks.isUInt_ = true;
-   checks.isUInt64_ = true;
-   checks.isIntegral_ = true;
-   checks.isDouble_ = true;
-   checks.isNumeric_ = true;
-   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
 
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT_EQUAL(0, val.asInt());
+  JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(0, val.asUInt());
+  JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
+  JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
+  JSONTEST_ASSERT_EQUAL(false, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
 
-   JSONTEST_ASSERT_EQUAL(0, val.asInt());
-   JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
-   JSONTEST_ASSERT_EQUAL(0, val.asUInt());
-   JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
-   JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
-   JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
-   JSONTEST_ASSERT_EQUAL(false, val.asBool());
-   JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
+  // Default real
+  val = Json::Value(Json::realValue);
 
-   // Default real
-   val = Json::Value(Json::realValue);
+  JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
 
-   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
 
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+  checks = IsCheck();
+  checks.isInt_ = true;
+  checks.isInt64_ = true;
+  checks.isUInt_ = true;
+  checks.isUInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
 
-   checks = IsCheck();
-   checks.isInt_ = true;
-   checks.isInt64_ = true;
-   checks.isUInt_ = true;
-   checks.isUInt64_ = true;
-   checks.isIntegral_ = true;
-   checks.isDouble_ = true;
-   checks.isNumeric_ = true;
-   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+  JSONTEST_ASSERT_EQUAL(0, val.asInt());
+  JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(0, val.asUInt());
+  JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
+  JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
+  JSONTEST_ASSERT_EQUAL(false, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
 
-   JSONTEST_ASSERT_EQUAL(0, val.asInt());
-   JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
-   JSONTEST_ASSERT_EQUAL(0, val.asUInt());
-   JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
-   JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
-   JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
-   JSONTEST_ASSERT_EQUAL(false, val.asBool());
-   JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
+  // Zero (signed constructor arg)
+  val = Json::Value(0);
 
-   // Zero (signed constructor arg)
-   val = Json::Value(0);
+  JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
 
-   JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+  checks = IsCheck();
+  checks.isInt_ = true;
+  checks.isInt64_ = true;
+  checks.isUInt_ = true;
+  checks.isUInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
 
-   checks = IsCheck();
-   checks.isInt_ = true;
-   checks.isInt64_ = true;
-   checks.isUInt_ = true;
-   checks.isUInt64_ = true;
-   checks.isIntegral_ = true;
-   checks.isDouble_ = true;
-   checks.isNumeric_ = true;
-   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
 
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT_EQUAL(0, val.asInt());
+  JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(0, val.asUInt());
+  JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
+  JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
+  JSONTEST_ASSERT_EQUAL(false, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
 
-   JSONTEST_ASSERT_EQUAL(0, val.asInt());
-   JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
-   JSONTEST_ASSERT_EQUAL(0, val.asUInt());
-   JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
-   JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
-   JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
-   JSONTEST_ASSERT_EQUAL(false, val.asBool());
-   JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
+  // Zero (unsigned constructor arg)
+  val = Json::Value(0u);
 
-   // Zero (unsigned constructor arg)
-   val = Json::Value(0u);
+  JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
 
-   JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
+  checks = IsCheck();
+  checks.isInt_ = true;
+  checks.isInt64_ = true;
+  checks.isUInt_ = true;
+  checks.isUInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
 
-   checks = IsCheck();
-   checks.isInt_ = true;
-   checks.isInt64_ = true;
-   checks.isUInt_ = true;
-   checks.isUInt64_ = true;
-   checks.isIntegral_ = true;
-   checks.isDouble_ = true;
-   checks.isNumeric_ = true;
-   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
 
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT_EQUAL(0, val.asInt());
+  JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(0, val.asUInt());
+  JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
+  JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
+  JSONTEST_ASSERT_EQUAL(false, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
 
-   JSONTEST_ASSERT_EQUAL(0, val.asInt());
-   JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
-   JSONTEST_ASSERT_EQUAL(0, val.asUInt());
-   JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
-   JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
-   JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
-   JSONTEST_ASSERT_EQUAL(false, val.asBool());
-   JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
+  // Zero (floating-point constructor arg)
+  val = Json::Value(0.0);
 
-   // Zero (floating-point constructor arg)
-   val = Json::Value(0.0);
+  JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
 
-   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+  checks = IsCheck();
+  checks.isInt_ = true;
+  checks.isInt64_ = true;
+  checks.isUInt_ = true;
+  checks.isUInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
 
-   checks = IsCheck();
-   checks.isInt_ = true;
-   checks.isInt64_ = true;
-   checks.isUInt_ = true;
-   checks.isUInt64_ = true;
-   checks.isIntegral_ = true;
-   checks.isDouble_ = true;
-   checks.isNumeric_ = true;
-   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
 
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
-
-   JSONTEST_ASSERT_EQUAL(0, val.asInt());
-   JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
-   JSONTEST_ASSERT_EQUAL(0, val.asUInt());
-   JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
-   JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
-   JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
-   JSONTEST_ASSERT_EQUAL(false, val.asBool());
-   JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
+  JSONTEST_ASSERT_EQUAL(0, val.asInt());
+  JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(0, val.asUInt());
+  JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
+  JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
+  JSONTEST_ASSERT_EQUAL(false, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
 
-   // 2^20 (signed constructor arg)
-   val = Json::Value(1 << 20);
+  // 2^20 (signed constructor arg)
+  val = Json::Value(1 << 20);
 
-   JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
-   checks = IsCheck();
-   checks.isInt_ = true;
-   checks.isInt64_ = true;
-   checks.isUInt_ = true;
-   checks.isUInt64_ = true;
-   checks.isIntegral_ = true;
-   checks.isDouble_ = true;
-   checks.isNumeric_ = true;
-   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+  JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+  checks = IsCheck();
+  checks.isInt_ = true;
+  checks.isInt64_ = true;
+  checks.isUInt_ = true;
+  checks.isUInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
 
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
 
-   JSONTEST_ASSERT_EQUAL((1 << 20), val.asInt());
-   JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestInt());
-   JSONTEST_ASSERT_EQUAL((1 << 20), val.asUInt());
-   JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestUInt());
-   JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());
-   JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());
-   JSONTEST_ASSERT_EQUAL(true, val.asBool());
-   JSONTEST_ASSERT_STRING_EQUAL("1048576", val.asString());
+  JSONTEST_ASSERT_EQUAL((1 << 20), val.asInt());
+  JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL((1 << 20), val.asUInt());
+  JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());
+  JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("1048576", val.asString());
 
-   // 2^20 (unsigned constructor arg)
-   val = Json::Value(Json::UInt(1 << 20));
+  // 2^20 (unsigned constructor arg)
+  val = Json::Value(Json::UInt(1 << 20));
 
-   JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
+  JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
 
-   checks = IsCheck();
-   checks.isInt_ = true;
-   checks.isInt64_ = true;
-   checks.isUInt_ = true;
-   checks.isUInt64_ = true;
-   checks.isIntegral_ = true;
-   checks.isDouble_ = true;
-   checks.isNumeric_ = true;
-   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+  checks = IsCheck();
+  checks.isInt_ = true;
+  checks.isInt64_ = true;
+  checks.isUInt_ = true;
+  checks.isUInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
 
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
 
-   JSONTEST_ASSERT_EQUAL((1 << 20), val.asInt());
-   JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestInt());
-   JSONTEST_ASSERT_EQUAL((1 << 20), val.asUInt());
-   JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestUInt());
-   JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());
-   JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());
-   JSONTEST_ASSERT_EQUAL(true, val.asBool());
-   JSONTEST_ASSERT_STRING_EQUAL("1048576", val.asString());
+  JSONTEST_ASSERT_EQUAL((1 << 20), val.asInt());
+  JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL((1 << 20), val.asUInt());
+  JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());
+  JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("1048576", val.asString());
 
-   // 2^20 (floating-point constructor arg)
-   val = Json::Value((1 << 20) / 1.0);
+  // 2^20 (floating-point constructor arg)
+  val = Json::Value((1 << 20) / 1.0);
 
-   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+  JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
 
-   checks = IsCheck();
-   checks.isInt_ = true;
-   checks.isInt64_ = true;
-   checks.isUInt_ = true;
-   checks.isUInt64_ = true;
-   checks.isIntegral_ = true;
-   checks.isDouble_ = true;
-   checks.isNumeric_ = true;
-   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+  checks = IsCheck();
+  checks.isInt_ = true;
+  checks.isInt64_ = true;
+  checks.isUInt_ = true;
+  checks.isUInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
 
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
 
-   JSONTEST_ASSERT_EQUAL((1 << 20), val.asInt());
-   JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestInt());
-   JSONTEST_ASSERT_EQUAL((1 << 20), val.asUInt());
-   JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestUInt());
-   JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());
-   JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());
-   JSONTEST_ASSERT_EQUAL(true, val.asBool());
-   JSONTEST_ASSERT_STRING_EQUAL("1048576", normalizeFloatingPointStr(val.asString()));
+  JSONTEST_ASSERT_EQUAL((1 << 20), val.asInt());
+  JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL((1 << 20), val.asUInt());
+  JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());
+  JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("1048576",
+                               normalizeFloatingPointStr(val.asString()));
 
-   // -2^20
-   val = Json::Value(-(1 << 20));
+  // -2^20
+  val = Json::Value(-(1 << 20));
 
-   JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+  JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
 
-   checks = IsCheck();
-   checks.isInt_ = true;
-   checks.isInt64_ = true;
-   checks.isIntegral_ = true;
-   checks.isDouble_ = true;
-   checks.isNumeric_ = true;
-   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+  checks = IsCheck();
+  checks.isInt_ = true;
+  checks.isInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
 
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
 
-   JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asInt());
-   JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asLargestInt());
-   JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asDouble());
-   JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asFloat());
-   JSONTEST_ASSERT_EQUAL(true, val.asBool());
-   JSONTEST_ASSERT_STRING_EQUAL("-1048576", val.asString());
+  JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asInt());
+  JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asDouble());
+  JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("-1048576", val.asString());
 
-   // int32 max
-   val = Json::Value(kint32max);
+  // int32 max
+  val = Json::Value(kint32max);
 
-   JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+  JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
 
-   checks = IsCheck();
-   checks.isInt_ = true;
-   checks.isInt64_ = true;
-   checks.isUInt_ = true;
-   checks.isUInt64_ = true;
-   checks.isIntegral_ = true;
-   checks.isDouble_ = true;
-   checks.isNumeric_ = true;
-   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+  checks = IsCheck();
+  checks.isInt_ = true;
+  checks.isInt64_ = true;
+  checks.isUInt_ = true;
+  checks.isUInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
 
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
 
-   JSONTEST_ASSERT_EQUAL(kint32max, val.asInt());
-   JSONTEST_ASSERT_EQUAL(kint32max, val.asLargestInt());
-   JSONTEST_ASSERT_EQUAL(kint32max, val.asUInt());
-   JSONTEST_ASSERT_EQUAL(kint32max, val.asLargestUInt());
-   JSONTEST_ASSERT_EQUAL(kint32max, val.asDouble());
-   JSONTEST_ASSERT_EQUAL(kfint32max, val.asFloat());
-   JSONTEST_ASSERT_EQUAL(true, val.asBool());
-   JSONTEST_ASSERT_STRING_EQUAL("2147483647", val.asString());
+  JSONTEST_ASSERT_EQUAL(kint32max, val.asInt());
+  JSONTEST_ASSERT_EQUAL(kint32max, val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(kint32max, val.asUInt());
+  JSONTEST_ASSERT_EQUAL(kint32max, val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL(kint32max, val.asDouble());
+  JSONTEST_ASSERT_EQUAL(kfint32max, val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("2147483647", val.asString());
 
-   // int32 min
-   val = Json::Value(kint32min);
+  // int32 min
+  val = Json::Value(kint32min);
 
-   JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+  JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
 
-   checks = IsCheck();
-   checks.isInt_ = true;
-   checks.isInt64_ = true;
-   checks.isIntegral_ = true;
-   checks.isDouble_ = true;
-   checks.isNumeric_ = true;
-   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+  checks = IsCheck();
+  checks.isInt_ = true;
+  checks.isInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
 
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
 
-   JSONTEST_ASSERT_EQUAL(kint32min, val.asInt());
-   JSONTEST_ASSERT_EQUAL(kint32min, val.asLargestInt());
-   JSONTEST_ASSERT_EQUAL(kint32min, val.asDouble());
-   JSONTEST_ASSERT_EQUAL(kint32min, val.asFloat());
-   JSONTEST_ASSERT_EQUAL(true, val.asBool());
-   JSONTEST_ASSERT_STRING_EQUAL("-2147483648", val.asString());
+  JSONTEST_ASSERT_EQUAL(kint32min, val.asInt());
+  JSONTEST_ASSERT_EQUAL(kint32min, val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(kint32min, val.asDouble());
+  JSONTEST_ASSERT_EQUAL(kint32min, val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("-2147483648", val.asString());
 
-   // uint32 max
-   val = Json::Value(kuint32max);
+  // uint32 max
+  val = Json::Value(kuint32max);
 
-   JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
+  JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
 
-   checks = IsCheck();
-   checks.isInt64_ = true;
-   checks.isUInt_ = true;
-   checks.isUInt64_ = true;
-   checks.isIntegral_ = true;
-   checks.isDouble_ = true;
-   checks.isNumeric_ = true;
-   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+  checks = IsCheck();
+  checks.isInt64_ = true;
+  checks.isUInt_ = true;
+  checks.isUInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
 
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
 
 #ifndef JSON_NO_INT64
-   JSONTEST_ASSERT_EQUAL(kuint32max, val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(kuint32max, val.asLargestInt());
 #endif
-   JSONTEST_ASSERT_EQUAL(kuint32max, val.asUInt());
-   JSONTEST_ASSERT_EQUAL(kuint32max, val.asLargestUInt());
-   JSONTEST_ASSERT_EQUAL(kuint32max, val.asDouble());
-   JSONTEST_ASSERT_EQUAL(kfuint32max, val.asFloat());
-   JSONTEST_ASSERT_EQUAL(true, val.asBool());
-   JSONTEST_ASSERT_STRING_EQUAL("4294967295", val.asString());
+  JSONTEST_ASSERT_EQUAL(kuint32max, val.asUInt());
+  JSONTEST_ASSERT_EQUAL(kuint32max, val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL(kuint32max, val.asDouble());
+  JSONTEST_ASSERT_EQUAL(kfuint32max, val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("4294967295", val.asString());
 
 #ifdef JSON_NO_INT64
-   // int64 max
-   val = Json::Value(double(kint64max));
+  // int64 max
+  val = Json::Value(double(kint64max));
 
-   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+  JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
 
-   checks = IsCheck();
-   checks.isDouble_ = true;
-   checks.isNumeric_ = true;
-   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+  checks = IsCheck();
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
 
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
 
-   JSONTEST_ASSERT_EQUAL(double(kint64max), val.asDouble());
-   JSONTEST_ASSERT_EQUAL(float(kint64max), val.asFloat());
-   JSONTEST_ASSERT_EQUAL(true, val.asBool());
-   JSONTEST_ASSERT_STRING_EQUAL("9.22337e+18", val.asString());
+  JSONTEST_ASSERT_EQUAL(double(kint64max), val.asDouble());
+  JSONTEST_ASSERT_EQUAL(float(kint64max), val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("9.22337e+18", val.asString());
 
-   // int64 min
-   val = Json::Value(double(kint64min));
+  // int64 min
+  val = Json::Value(double(kint64min));
 
-   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+  JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
 
-   checks = IsCheck();
-   checks.isDouble_ = true;
-   checks.isNumeric_ = true;
-   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+  checks = IsCheck();
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
 
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
 
-   JSONTEST_ASSERT_EQUAL(double(kint64min), val.asDouble());
-   JSONTEST_ASSERT_EQUAL(float(kint64min), val.asFloat());
-   JSONTEST_ASSERT_EQUAL(true, val.asBool());
-   JSONTEST_ASSERT_STRING_EQUAL("-9.22337e+18", val.asString());
+  JSONTEST_ASSERT_EQUAL(double(kint64min), val.asDouble());
+  JSONTEST_ASSERT_EQUAL(float(kint64min), val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("-9.22337e+18", val.asString());
 
-   // uint64 max
-   val = Json::Value(double(kuint64max));
+  // uint64 max
+  val = Json::Value(double(kuint64max));
 
-   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+  JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
 
-   checks = IsCheck();
-   checks.isDouble_ = true;
-   checks.isNumeric_ = true;
-   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+  checks = IsCheck();
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
 
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
 
-   JSONTEST_ASSERT_EQUAL(double(kuint64max), val.asDouble());
-   JSONTEST_ASSERT_EQUAL(float(kuint64max), val.asFloat());
-   JSONTEST_ASSERT_EQUAL(true, val.asBool());
-   JSONTEST_ASSERT_STRING_EQUAL("1.84467e+19", val.asString());
-#else  // ifdef JSON_NO_INT64
-   // 2^40 (signed constructor arg)
-   val = Json::Value(Json::Int64(1) << 40);
+  JSONTEST_ASSERT_EQUAL(double(kuint64max), val.asDouble());
+  JSONTEST_ASSERT_EQUAL(float(kuint64max), val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("1.84467e+19", val.asString());
+#else // ifdef JSON_NO_INT64
+  // 2^40 (signed constructor arg)
+  val = Json::Value(Json::Int64(1) << 40);
 
-   JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+  JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
 
-   checks = IsCheck();
-   checks.isInt64_ = true;
-   checks.isUInt64_ = true;
-   checks.isIntegral_ = true;
-   checks.isDouble_ = true;
-   checks.isNumeric_ = true;
-   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+  checks = IsCheck();
+  checks.isInt64_ = true;
+  checks.isUInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
 
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
 
-   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asInt64());
-   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestInt());
-   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asUInt64());
-   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestUInt());
-   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asDouble());
-   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asFloat());
-   JSONTEST_ASSERT_EQUAL(true, val.asBool());
-   JSONTEST_ASSERT_STRING_EQUAL("1099511627776", val.asString());
+  JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asInt64());
+  JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asUInt64());
+  JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asDouble());
+  JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("1099511627776", val.asString());
 
-   // 2^40 (unsigned constructor arg)
-   val = Json::Value(Json::UInt64(1) << 40);
+  // 2^40 (unsigned constructor arg)
+  val = Json::Value(Json::UInt64(1) << 40);
 
-   JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
+  JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
 
-   checks = IsCheck();
-   checks.isInt64_ = true;
-   checks.isUInt64_ = true;
-   checks.isIntegral_ = true;
-   checks.isDouble_ = true;
-   checks.isNumeric_ = true;
-   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+  checks = IsCheck();
+  checks.isInt64_ = true;
+  checks.isUInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
 
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
 
-   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asInt64());
-   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestInt());
-   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asUInt64());
-   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestUInt());
-   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asDouble());
-   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asFloat());
-   JSONTEST_ASSERT_EQUAL(true, val.asBool());
-   JSONTEST_ASSERT_STRING_EQUAL("1099511627776", val.asString());
+  JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asInt64());
+  JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asUInt64());
+  JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asDouble());
+  JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("1099511627776", val.asString());
 
-   // 2^40 (floating-point constructor arg)
-   val = Json::Value((Json::Int64(1) << 40) / 1.0);
+  // 2^40 (floating-point constructor arg)
+  val = Json::Value((Json::Int64(1) << 40) / 1.0);
 
-   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+  JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
 
-   checks = IsCheck();
-   checks.isInt64_ = true;
-   checks.isUInt64_ = true;
-   checks.isIntegral_ = true;
-   checks.isDouble_ = true;
-   checks.isNumeric_ = true;
-   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+  checks = IsCheck();
+  checks.isInt64_ = true;
+  checks.isUInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
 
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
 
-   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asInt64());
-   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestInt());
-   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asUInt64());
-   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestUInt());
-   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asDouble());
-   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asFloat());
-   JSONTEST_ASSERT_EQUAL(true, val.asBool());
-   JSONTEST_ASSERT_STRING_EQUAL("1099511627776", normalizeFloatingPointStr(val.asString()));
+  JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asInt64());
+  JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asUInt64());
+  JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asDouble());
+  JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("1099511627776",
+                               normalizeFloatingPointStr(val.asString()));
 
-   // -2^40
-   val = Json::Value(-(Json::Int64(1) << 40));
+  // -2^40
+  val = Json::Value(-(Json::Int64(1) << 40));
 
-   JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+  JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
 
-   checks = IsCheck();
-   checks.isInt64_ = true;
-   checks.isIntegral_ = true;
-   checks.isDouble_ = true;
-   checks.isNumeric_ = true;
-   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+  checks = IsCheck();
+  checks.isInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
 
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
 
-   JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asInt64());
-   JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asLargestInt());
-   JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asDouble());
-   JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asFloat());
-   JSONTEST_ASSERT_EQUAL(true, val.asBool());
-   JSONTEST_ASSERT_STRING_EQUAL("-1099511627776", val.asString());
+  JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asInt64());
+  JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asDouble());
+  JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("-1099511627776", val.asString());
 
-   // int64 max
-   val = Json::Value(Json::Int64(kint64max));
+  // int64 max
+  val = Json::Value(Json::Int64(kint64max));
 
-   JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+  JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
 
-   checks = IsCheck();
-   checks.isInt64_ = true;
-   checks.isUInt64_ = true;
-   checks.isIntegral_ = true;
-   checks.isDouble_ = true;
-   checks.isNumeric_ = true;
-   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+  checks = IsCheck();
+  checks.isInt64_ = true;
+  checks.isUInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
 
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
 
-   JSONTEST_ASSERT_EQUAL(kint64max, val.asInt64());
-   JSONTEST_ASSERT_EQUAL(kint64max, val.asLargestInt());
-   JSONTEST_ASSERT_EQUAL(kint64max, val.asUInt64());
-   JSONTEST_ASSERT_EQUAL(kint64max, val.asLargestUInt());
-   JSONTEST_ASSERT_EQUAL(double(kint64max), val.asDouble());
-   JSONTEST_ASSERT_EQUAL(float(kint64max), val.asFloat());
-   JSONTEST_ASSERT_EQUAL(true, val.asBool());
-   JSONTEST_ASSERT_STRING_EQUAL("9223372036854775807", val.asString());
+  JSONTEST_ASSERT_EQUAL(kint64max, val.asInt64());
+  JSONTEST_ASSERT_EQUAL(kint64max, val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(kint64max, val.asUInt64());
+  JSONTEST_ASSERT_EQUAL(kint64max, val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL(double(kint64max), val.asDouble());
+  JSONTEST_ASSERT_EQUAL(float(kint64max), val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("9223372036854775807", val.asString());
 
-   // int64 max (floating point constructor). Note that kint64max is not exactly
-   // representable as a double, and will be rounded up to be higher.
-   val = Json::Value(double(kint64max));
+  // int64 max (floating point constructor). Note that kint64max is not exactly
+  // representable as a double, and will be rounded up to be higher.
+  val = Json::Value(double(kint64max));
 
-   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+  JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
 
-   checks = IsCheck();
-   checks.isUInt64_ = true;
-   checks.isIntegral_ = true;
-   checks.isDouble_ = true;
-   checks.isNumeric_ = true;
-   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+  checks = IsCheck();
+  checks.isUInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
 
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
 
-   JSONTEST_ASSERT_EQUAL(Json::UInt64(1) << 63, val.asUInt64());
-   JSONTEST_ASSERT_EQUAL(Json::UInt64(1) << 63, val.asLargestUInt());
-   JSONTEST_ASSERT_EQUAL(uint64ToDouble(Json::UInt64(1) << 63), val.asDouble());
-   JSONTEST_ASSERT_EQUAL(float(uint64ToDouble(Json::UInt64(1) << 63)), val.asFloat());
-   JSONTEST_ASSERT_EQUAL(true, val.asBool());
-   JSONTEST_ASSERT_STRING_EQUAL("9.223372036854776e+18", normalizeFloatingPointStr(val.asString()));
+  JSONTEST_ASSERT_EQUAL(Json::UInt64(1) << 63, val.asUInt64());
+  JSONTEST_ASSERT_EQUAL(Json::UInt64(1) << 63, val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL(uint64ToDouble(Json::UInt64(1) << 63), val.asDouble());
+  JSONTEST_ASSERT_EQUAL(float(uint64ToDouble(Json::UInt64(1) << 63)),
+                        val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("9.223372036854776e+18",
+                               normalizeFloatingPointStr(val.asString()));
 
-   // int64 min
-   val = Json::Value(Json::Int64(kint64min));
+  // int64 min
+  val = Json::Value(Json::Int64(kint64min));
 
-   JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+  JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
 
-   checks = IsCheck();
-   checks.isInt64_ = true;
-   checks.isIntegral_ = true;
-   checks.isDouble_ = true;
-   checks.isNumeric_ = true;
-   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+  checks = IsCheck();
+  checks.isInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
 
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
 
-   JSONTEST_ASSERT_EQUAL(kint64min, val.asInt64());
-   JSONTEST_ASSERT_EQUAL(kint64min, val.asLargestInt());
-   JSONTEST_ASSERT_EQUAL(double(kint64min), val.asDouble());
-   JSONTEST_ASSERT_EQUAL(float(kint64min), val.asFloat());
-   JSONTEST_ASSERT_EQUAL(true, val.asBool());
-   JSONTEST_ASSERT_STRING_EQUAL("-9223372036854775808", val.asString());
+  JSONTEST_ASSERT_EQUAL(kint64min, val.asInt64());
+  JSONTEST_ASSERT_EQUAL(kint64min, val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(double(kint64min), val.asDouble());
+  JSONTEST_ASSERT_EQUAL(float(kint64min), val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("-9223372036854775808", val.asString());
 
-   // int64 min (floating point constructor). Note that kint64min *is* exactly
-   // representable as a double.
-   val = Json::Value(double(kint64min));
+  // int64 min (floating point constructor). Note that kint64min *is* exactly
+  // representable as a double.
+  val = Json::Value(double(kint64min));
 
-   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+  JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
 
-   checks = IsCheck();
-   checks.isInt64_ = true;
-   checks.isIntegral_ = true;
-   checks.isDouble_ = true;
-   checks.isNumeric_ = true;
-   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+  checks = IsCheck();
+  checks.isInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
 
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
 
-   JSONTEST_ASSERT_EQUAL(kint64min, val.asInt64());
-   JSONTEST_ASSERT_EQUAL(kint64min, val.asLargestInt());
-   JSONTEST_ASSERT_EQUAL(-9223372036854775808.0, val.asDouble());
-   JSONTEST_ASSERT_EQUAL(-9223372036854775808.0, val.asFloat());
-   JSONTEST_ASSERT_EQUAL(true, val.asBool());
-   JSONTEST_ASSERT_STRING_EQUAL("-9.223372036854776e+18", normalizeFloatingPointStr(val.asString()));
+  JSONTEST_ASSERT_EQUAL(kint64min, val.asInt64());
+  JSONTEST_ASSERT_EQUAL(kint64min, val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(-9223372036854775808.0, val.asDouble());
+  JSONTEST_ASSERT_EQUAL(-9223372036854775808.0, val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("-9.223372036854776e+18",
+                               normalizeFloatingPointStr(val.asString()));
 
-   // 10^19
-   const Json::UInt64 ten_to_19 = static_cast<Json::UInt64>( 1e19 );
-   val = Json::Value(Json::UInt64(ten_to_19));
+  // 10^19
+  const Json::UInt64 ten_to_19 = static_cast<Json::UInt64>(1e19);
+  val = Json::Value(Json::UInt64(ten_to_19));
 
-   JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
+  JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
 
-   checks = IsCheck();
-   checks.isUInt64_ = true;
-   checks.isIntegral_ = true;
-   checks.isDouble_ = true;
-   checks.isNumeric_ = true;
-   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+  checks = IsCheck();
+  checks.isUInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
 
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
 
-   JSONTEST_ASSERT_EQUAL(ten_to_19, val.asUInt64());
-   JSONTEST_ASSERT_EQUAL(ten_to_19, val.asLargestUInt());
-   JSONTEST_ASSERT_EQUAL(uint64ToDouble(ten_to_19), val.asDouble());
-   JSONTEST_ASSERT_EQUAL(float(uint64ToDouble(ten_to_19)), val.asFloat());
-   JSONTEST_ASSERT_EQUAL(true, val.asBool());
-   JSONTEST_ASSERT_STRING_EQUAL("10000000000000000000", val.asString());
+  JSONTEST_ASSERT_EQUAL(ten_to_19, val.asUInt64());
+  JSONTEST_ASSERT_EQUAL(ten_to_19, val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL(uint64ToDouble(ten_to_19), val.asDouble());
+  JSONTEST_ASSERT_EQUAL(float(uint64ToDouble(ten_to_19)), val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("10000000000000000000", val.asString());
 
-   // 10^19 (double constructor). Note that 10^19 is not exactly representable
-   // as a double.
-   val = Json::Value(uint64ToDouble(ten_to_19));
+  // 10^19 (double constructor). Note that 10^19 is not exactly representable
+  // as a double.
+  val = Json::Value(uint64ToDouble(ten_to_19));
 
-   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+  JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
 
-   checks = IsCheck();
-   checks.isUInt64_ = true;
-   checks.isIntegral_ = true;
-   checks.isDouble_ = true;
-   checks.isNumeric_ = true;
-   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+  checks = IsCheck();
+  checks.isUInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
 
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
 
-   JSONTEST_ASSERT_EQUAL(1e19, val.asDouble());
-   JSONTEST_ASSERT_EQUAL(1e19, val.asFloat());
-   JSONTEST_ASSERT_EQUAL(true, val.asBool());
-   JSONTEST_ASSERT_STRING_EQUAL("1e+19", normalizeFloatingPointStr(val.asString()));
+  JSONTEST_ASSERT_EQUAL(1e19, val.asDouble());
+  JSONTEST_ASSERT_EQUAL(1e19, val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("1e+19",
+                               normalizeFloatingPointStr(val.asString()));
 
-   // uint64 max
-   val = Json::Value(Json::UInt64(kuint64max));
+  // uint64 max
+  val = Json::Value(Json::UInt64(kuint64max));
 
-   JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
+  JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
 
-   checks = IsCheck();
-   checks.isUInt64_ = true;
-   checks.isIntegral_ = true;
-   checks.isDouble_ = true;
-   checks.isNumeric_ = true;
-   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+  checks = IsCheck();
+  checks.isUInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
 
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
 
-   JSONTEST_ASSERT_EQUAL(kuint64max, val.asUInt64());
-   JSONTEST_ASSERT_EQUAL(kuint64max, val.asLargestUInt());
-   JSONTEST_ASSERT_EQUAL(uint64ToDouble(kuint64max), val.asDouble());
-   JSONTEST_ASSERT_EQUAL(float(uint64ToDouble(kuint64max)), val.asFloat());
-   JSONTEST_ASSERT_EQUAL(true, val.asBool());
-   JSONTEST_ASSERT_STRING_EQUAL("18446744073709551615", val.asString());
+  JSONTEST_ASSERT_EQUAL(kuint64max, val.asUInt64());
+  JSONTEST_ASSERT_EQUAL(kuint64max, val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL(uint64ToDouble(kuint64max), val.asDouble());
+  JSONTEST_ASSERT_EQUAL(float(uint64ToDouble(kuint64max)), val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("18446744073709551615", val.asString());
 
-   // uint64 max (floating point constructor). Note that kuint64max is not
-   // exactly representable as a double, and will be rounded up to be higher.
-   val = Json::Value(uint64ToDouble(kuint64max));
+  // uint64 max (floating point constructor). Note that kuint64max is not
+  // exactly representable as a double, and will be rounded up to be higher.
+  val = Json::Value(uint64ToDouble(kuint64max));
 
-   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+  JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
 
-   checks = IsCheck();
-   checks.isDouble_ = true;
-   checks.isNumeric_ = true;
-   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+  checks = IsCheck();
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
 
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
 
-   JSONTEST_ASSERT_EQUAL(18446744073709551616.0, val.asDouble());
-   JSONTEST_ASSERT_EQUAL(18446744073709551616.0, val.asFloat());
-   JSONTEST_ASSERT_EQUAL(true, val.asBool());
-   JSONTEST_ASSERT_STRING_EQUAL("1.844674407370955e+19", normalizeFloatingPointStr(val.asString()));
+  JSONTEST_ASSERT_EQUAL(18446744073709551616.0, val.asDouble());
+  JSONTEST_ASSERT_EQUAL(18446744073709551616.0, val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("1.844674407370955e+19",
+                               normalizeFloatingPointStr(val.asString()));
 #endif
 }
 
+JSONTEST_FIXTURE(ValueTest, nonIntegers) {
+  IsCheck checks;
+  Json::Value val;
 
-JSONTEST_FIXTURE( ValueTest, nonIntegers )
-{
-   IsCheck checks;
-   Json::Value val;
+  // Small positive number
+  val = Json::Value(1.5);
 
-   // Small positive number
-   val = Json::Value(1.5);
+  JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
 
-   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+  checks = IsCheck();
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
 
-   checks = IsCheck();
-   checks.isDouble_ = true;
-   checks.isNumeric_ = true;
-   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
 
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
+  JSONTEST_ASSERT_EQUAL(1.5, val.asDouble());
+  JSONTEST_ASSERT_EQUAL(1.5, val.asFloat());
+  JSONTEST_ASSERT_EQUAL(1, val.asInt());
+  JSONTEST_ASSERT_EQUAL(1, val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(1, val.asUInt());
+  JSONTEST_ASSERT_EQUAL(1, val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_EQUAL("1.5", val.asString());
 
-   JSONTEST_ASSERT_EQUAL(1.5, val.asDouble());
-   JSONTEST_ASSERT_EQUAL(1.5, val.asFloat());
-   JSONTEST_ASSERT_EQUAL(1, val.asInt());
-   JSONTEST_ASSERT_EQUAL(1, val.asLargestInt());
-   JSONTEST_ASSERT_EQUAL(1, val.asUInt());
-   JSONTEST_ASSERT_EQUAL(1, val.asLargestUInt());
-   JSONTEST_ASSERT_EQUAL(true, val.asBool());
-   JSONTEST_ASSERT_EQUAL("1.5", val.asString());
+  // Small negative number
+  val = Json::Value(-1.5);
 
-   // Small negative number
-   val = Json::Value(-1.5);
+  JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
 
-   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+  checks = IsCheck();
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
 
-   checks = IsCheck();
-   checks.isDouble_ = true;
-   checks.isNumeric_ = true;
-   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
 
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
+  JSONTEST_ASSERT_EQUAL(-1.5, val.asDouble());
+  JSONTEST_ASSERT_EQUAL(-1.5, val.asFloat());
+  JSONTEST_ASSERT_EQUAL(-1, val.asInt());
+  JSONTEST_ASSERT_EQUAL(-1, val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_EQUAL("-1.5", val.asString());
 
-   JSONTEST_ASSERT_EQUAL(-1.5, val.asDouble());
-   JSONTEST_ASSERT_EQUAL(-1.5, val.asFloat());
-   JSONTEST_ASSERT_EQUAL(-1, val.asInt());
-   JSONTEST_ASSERT_EQUAL(-1, val.asLargestInt());
-   JSONTEST_ASSERT_EQUAL(true, val.asBool());
-   JSONTEST_ASSERT_EQUAL("-1.5", val.asString());
+  // A bit over int32 max
+  val = Json::Value(kint32max + 0.5);
 
-   // A bit over int32 max
-   val = Json::Value(kint32max + 0.5);
+  JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
 
-   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+  checks = IsCheck();
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
 
-   checks = IsCheck();
-   checks.isDouble_ = true;
-   checks.isNumeric_ = true;
-   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
 
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
-
-   JSONTEST_ASSERT_EQUAL(2147483647.5, val.asDouble());
-   JSONTEST_ASSERT_EQUAL(float(2147483647.5), val.asFloat());
-   JSONTEST_ASSERT_EQUAL(2147483647U, val.asUInt());
+  JSONTEST_ASSERT_EQUAL(2147483647.5, val.asDouble());
+  JSONTEST_ASSERT_EQUAL(float(2147483647.5), val.asFloat());
+  JSONTEST_ASSERT_EQUAL(2147483647U, val.asUInt());
 #ifdef JSON_HAS_INT64
-   JSONTEST_ASSERT_EQUAL(2147483647L, val.asLargestInt());
-   JSONTEST_ASSERT_EQUAL(2147483647U, val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL(2147483647L, val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(2147483647U, val.asLargestUInt());
 #endif
-   JSONTEST_ASSERT_EQUAL(true, val.asBool());
-   JSONTEST_ASSERT_EQUAL("2147483647.5", normalizeFloatingPointStr(val.asString()));
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_EQUAL("2147483647.5",
+                        normalizeFloatingPointStr(val.asString()));
 
-   // A bit under int32 min
-   val = Json::Value(kint32min - 0.5);
+  // A bit under int32 min
+  val = Json::Value(kint32min - 0.5);
 
-   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+  JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
 
-   checks = IsCheck();
-   checks.isDouble_ = true;
-   checks.isNumeric_ = true;
-   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+  checks = IsCheck();
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
 
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
 
-   JSONTEST_ASSERT_EQUAL(-2147483648.5, val.asDouble());
-   JSONTEST_ASSERT_EQUAL(float(-2147483648.5), val.asFloat());
+  JSONTEST_ASSERT_EQUAL(-2147483648.5, val.asDouble());
+  JSONTEST_ASSERT_EQUAL(float(-2147483648.5), val.asFloat());
 #ifdef JSON_HAS_INT64
-   JSONTEST_ASSERT_EQUAL(-Json::Int64(1)<< 31, val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(-Json::Int64(1) << 31, val.asLargestInt());
 #endif
-   JSONTEST_ASSERT_EQUAL(true, val.asBool());
-   JSONTEST_ASSERT_EQUAL("-2147483648.5", normalizeFloatingPointStr(val.asString()));
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_EQUAL("-2147483648.5",
+                        normalizeFloatingPointStr(val.asString()));
 
-   // A bit over uint32 max
-   val = Json::Value(kuint32max + 0.5);
+  // A bit over uint32 max
+  val = Json::Value(kuint32max + 0.5);
 
-   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+  JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
 
-   checks = IsCheck();
-   checks.isDouble_ = true;
-   checks.isNumeric_ = true;
-   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+  checks = IsCheck();
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
 
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
-   JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
-   JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
 
-   JSONTEST_ASSERT_EQUAL(4294967295.5, val.asDouble());
-   JSONTEST_ASSERT_EQUAL(float(4294967295.5), val.asFloat());
+  JSONTEST_ASSERT_EQUAL(4294967295.5, val.asDouble());
+  JSONTEST_ASSERT_EQUAL(float(4294967295.5), val.asFloat());
 #ifdef JSON_HAS_INT64
-   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 32)-1, val.asLargestInt());
-   JSONTEST_ASSERT_EQUAL((Json::UInt64(1) << 32)-Json::UInt64(1), val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 32) - 1, val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL((Json::UInt64(1) << 32) - Json::UInt64(1),
+                        val.asLargestUInt());
 #endif
-   JSONTEST_ASSERT_EQUAL(true, val.asBool());
-   JSONTEST_ASSERT_EQUAL("4294967295.5", normalizeFloatingPointStr(val.asString()));
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_EQUAL("4294967295.5",
+                        normalizeFloatingPointStr(val.asString()));
 
-   val = Json::Value(1.2345678901234);
-   JSONTEST_ASSERT_STRING_EQUAL( "1.2345678901234", normalizeFloatingPointStr(val.asString()));
+  val = Json::Value(1.2345678901234);
+  JSONTEST_ASSERT_STRING_EQUAL("1.2345678901234",
+                               normalizeFloatingPointStr(val.asString()));
 
-   // A 16-digit floating point number.
-   val = Json::Value(2199023255552000.0f);
-   JSONTEST_ASSERT_EQUAL(float(2199023255552000), val.asFloat());
-   JSONTEST_ASSERT_STRING_EQUAL("2199023255552000", normalizeFloatingPointStr(val.asString()));
+  // A 16-digit floating point number.
+  val = Json::Value(2199023255552000.0f);
+  JSONTEST_ASSERT_EQUAL(float(2199023255552000), val.asFloat());
+  JSONTEST_ASSERT_STRING_EQUAL("2199023255552000",
+                               normalizeFloatingPointStr(val.asString()));
 
-   // A very large floating point number.
-   val = Json::Value(3.402823466385289e38);
-   JSONTEST_ASSERT_EQUAL(float(3.402823466385289e38), val.asFloat());
-   JSONTEST_ASSERT_STRING_EQUAL("3.402823466385289e+38", normalizeFloatingPointStr(val.asString()));
+  // A very large floating point number.
+  val = Json::Value(3.402823466385289e38);
+  JSONTEST_ASSERT_EQUAL(float(3.402823466385289e38), val.asFloat());
+  JSONTEST_ASSERT_STRING_EQUAL("3.402823466385289e+38",
+                               normalizeFloatingPointStr(val.asString()));
 
-   // An even larger floating point number.
-   val = Json::Value(1.2345678e300);
-   JSONTEST_ASSERT_EQUAL(double(1.2345678e300), val.asDouble());
-   JSONTEST_ASSERT_STRING_EQUAL("1.2345678e+300", normalizeFloatingPointStr(val.asString()));
+  // An even larger floating point number.
+  val = Json::Value(1.2345678e300);
+  JSONTEST_ASSERT_EQUAL(double(1.2345678e300), val.asDouble());
+  JSONTEST_ASSERT_STRING_EQUAL("1.2345678e+300",
+                               normalizeFloatingPointStr(val.asString()));
 }
 
-
-void
-ValueTest::checkConstMemberCount( const Json::Value &value, unsigned int expectedCount )
-{
-   unsigned int count = 0;
-   Json::Value::const_iterator itEnd = value.end();
-   for ( Json::Value::const_iterator it = value.begin(); it != itEnd; ++it )
-   {
-      ++count;
-   }
-   JSONTEST_ASSERT_EQUAL( expectedCount, count ) << "Json::Value::const_iterator";
+void ValueTest::checkConstMemberCount(const Json::Value &value,
+                                      unsigned int expectedCount) {
+  unsigned int count = 0;
+  Json::Value::const_iterator itEnd = value.end();
+  for (Json::Value::const_iterator it = value.begin(); it != itEnd; ++it) {
+    ++count;
+  }
+  JSONTEST_ASSERT_EQUAL(expectedCount, count) << "Json::Value::const_iterator";
 }
 
-void
-ValueTest::checkMemberCount( Json::Value &value, unsigned int expectedCount )
-{
-   JSONTEST_ASSERT_EQUAL(expectedCount, value.size() );
+void ValueTest::checkMemberCount(Json::Value &value,
+                                 unsigned int expectedCount) {
+  JSONTEST_ASSERT_EQUAL(expectedCount, value.size());
 
-   unsigned int count = 0;
-   Json::Value::iterator itEnd = value.end();
-   for ( Json::Value::iterator it = value.begin(); it != itEnd; ++it )
-   {
-      ++count;
-   }
-   JSONTEST_ASSERT_EQUAL( expectedCount, count ) << "Json::Value::iterator";
+  unsigned int count = 0;
+  Json::Value::iterator itEnd = value.end();
+  for (Json::Value::iterator it = value.begin(); it != itEnd; ++it) {
+    ++count;
+  }
+  JSONTEST_ASSERT_EQUAL(expectedCount, count) << "Json::Value::iterator";
 
-   JSONTEST_ASSERT_PRED( checkConstMemberCount(value, expectedCount) );
+  JSONTEST_ASSERT_PRED(checkConstMemberCount(value, expectedCount));
 }
 
-
 ValueTest::IsCheck::IsCheck()
-   : isObject_( false )
-   , isArray_( false )
-   , isBool_( false )
-   , isString_( false )
-   , isNull_( false )
-   , isInt_( false )
-   , isInt64_( false )
-   , isUInt_( false )
-   , isUInt64_( false )
-   , isIntegral_( false )
-   , isDouble_( false )
-   , isNumeric_( false )
-{
-}
+    : isObject_(false), isArray_(false), isBool_(false), isString_(false),
+      isNull_(false), isInt_(false), isInt64_(false), isUInt_(false),
+      isUInt64_(false), isIntegral_(false), isDouble_(false),
+      isNumeric_(false) {}
 
-
-void 
-ValueTest::checkIs( const Json::Value &value, const IsCheck &check )
-{
-   JSONTEST_ASSERT_EQUAL(check.isObject_, value.isObject() );
-   JSONTEST_ASSERT_EQUAL(check.isArray_, value.isArray() );
-   JSONTEST_ASSERT_EQUAL(check.isBool_, value.isBool() );
-   JSONTEST_ASSERT_EQUAL(check.isDouble_, value.isDouble() );
-   JSONTEST_ASSERT_EQUAL(check.isInt_, value.isInt() );
-   JSONTEST_ASSERT_EQUAL(check.isUInt_, value.isUInt() );
-   JSONTEST_ASSERT_EQUAL(check.isIntegral_, value.isIntegral() );
-   JSONTEST_ASSERT_EQUAL(check.isNumeric_, value.isNumeric() );
-   JSONTEST_ASSERT_EQUAL(check.isString_, value.isString() );
-   JSONTEST_ASSERT_EQUAL(check.isNull_, value.isNull() );
+void ValueTest::checkIs(const Json::Value &value, const IsCheck &check) {
+  JSONTEST_ASSERT_EQUAL(check.isObject_, value.isObject());
+  JSONTEST_ASSERT_EQUAL(check.isArray_, value.isArray());
+  JSONTEST_ASSERT_EQUAL(check.isBool_, value.isBool());
+  JSONTEST_ASSERT_EQUAL(check.isDouble_, value.isDouble());
+  JSONTEST_ASSERT_EQUAL(check.isInt_, value.isInt());
+  JSONTEST_ASSERT_EQUAL(check.isUInt_, value.isUInt());
+  JSONTEST_ASSERT_EQUAL(check.isIntegral_, value.isIntegral());
+  JSONTEST_ASSERT_EQUAL(check.isNumeric_, value.isNumeric());
+  JSONTEST_ASSERT_EQUAL(check.isString_, value.isString());
+  JSONTEST_ASSERT_EQUAL(check.isNull_, value.isNull());
 
 #ifdef JSON_HAS_INT64
-   JSONTEST_ASSERT_EQUAL(check.isInt64_, value.isInt64() );
-   JSONTEST_ASSERT_EQUAL(check.isUInt64_, value.isUInt64() );
+  JSONTEST_ASSERT_EQUAL(check.isInt64_, value.isInt64());
+  JSONTEST_ASSERT_EQUAL(check.isUInt64_, value.isUInt64());
 #else
-   JSONTEST_ASSERT_EQUAL(false, value.isInt64() );
-   JSONTEST_ASSERT_EQUAL(false, value.isUInt64() );
+  JSONTEST_ASSERT_EQUAL(false, value.isInt64());
+  JSONTEST_ASSERT_EQUAL(false, value.isUInt64());
 #endif
 }
 
-JSONTEST_FIXTURE( ValueTest, compareNull )
-{
-    JSONTEST_ASSERT_PRED( checkIsEqual( Json::Value(), Json::Value() ) );
+JSONTEST_FIXTURE(ValueTest, compareNull) {
+  JSONTEST_ASSERT_PRED(checkIsEqual(Json::Value(), Json::Value()));
 }
 
-
-JSONTEST_FIXTURE( ValueTest, compareInt )
-{
-    JSONTEST_ASSERT_PRED( checkIsLess( 0, 10 ) );
-    JSONTEST_ASSERT_PRED( checkIsEqual( 10, 10 ) );
-    JSONTEST_ASSERT_PRED( checkIsEqual( -10, -10 ) );
-    JSONTEST_ASSERT_PRED( checkIsLess( -10, 0 ) );
+JSONTEST_FIXTURE(ValueTest, compareInt) {
+  JSONTEST_ASSERT_PRED(checkIsLess(0, 10));
+  JSONTEST_ASSERT_PRED(checkIsEqual(10, 10));
+  JSONTEST_ASSERT_PRED(checkIsEqual(-10, -10));
+  JSONTEST_ASSERT_PRED(checkIsLess(-10, 0));
 }
 
-
-JSONTEST_FIXTURE( ValueTest, compareUInt )
-{
-    JSONTEST_ASSERT_PRED( checkIsLess( 0u, 10u ) );
-    JSONTEST_ASSERT_PRED( checkIsLess( 0u, Json::Value::maxUInt ) );
-    JSONTEST_ASSERT_PRED( checkIsEqual( 10u, 10u ) );
+JSONTEST_FIXTURE(ValueTest, compareUInt) {
+  JSONTEST_ASSERT_PRED(checkIsLess(0u, 10u));
+  JSONTEST_ASSERT_PRED(checkIsLess(0u, Json::Value::maxUInt));
+  JSONTEST_ASSERT_PRED(checkIsEqual(10u, 10u));
 }
 
-
-JSONTEST_FIXTURE( ValueTest, compareDouble )
-{
-    JSONTEST_ASSERT_PRED( checkIsLess( 0.0, 10.0 ) );
-    JSONTEST_ASSERT_PRED( checkIsEqual( 10.0, 10.0 ) );
-    JSONTEST_ASSERT_PRED( checkIsEqual( -10.0, -10.0 ) );
-    JSONTEST_ASSERT_PRED( checkIsLess( -10.0, 0.0 ) );
+JSONTEST_FIXTURE(ValueTest, compareDouble) {
+  JSONTEST_ASSERT_PRED(checkIsLess(0.0, 10.0));
+  JSONTEST_ASSERT_PRED(checkIsEqual(10.0, 10.0));
+  JSONTEST_ASSERT_PRED(checkIsEqual(-10.0, -10.0));
+  JSONTEST_ASSERT_PRED(checkIsLess(-10.0, 0.0));
 }
 
-
-JSONTEST_FIXTURE( ValueTest, compareString )
-{
-    JSONTEST_ASSERT_PRED( checkIsLess( "", " " ) );
-    JSONTEST_ASSERT_PRED( checkIsLess( "", "a" ) );
-    JSONTEST_ASSERT_PRED( checkIsLess( "abcd", "zyui" ) );
-    JSONTEST_ASSERT_PRED( checkIsLess( "abc", "abcd" ) );
-    JSONTEST_ASSERT_PRED( checkIsEqual( "abcd", "abcd" ) );
-    JSONTEST_ASSERT_PRED( checkIsEqual( " ", " " ) );
-    JSONTEST_ASSERT_PRED( checkIsLess( "ABCD", "abcd" ) );
-    JSONTEST_ASSERT_PRED( checkIsEqual( "ABCD", "ABCD" ) );
+JSONTEST_FIXTURE(ValueTest, compareString) {
+  JSONTEST_ASSERT_PRED(checkIsLess("", " "));
+  JSONTEST_ASSERT_PRED(checkIsLess("", "a"));
+  JSONTEST_ASSERT_PRED(checkIsLess("abcd", "zyui"));
+  JSONTEST_ASSERT_PRED(checkIsLess("abc", "abcd"));
+  JSONTEST_ASSERT_PRED(checkIsEqual("abcd", "abcd"));
+  JSONTEST_ASSERT_PRED(checkIsEqual(" ", " "));
+  JSONTEST_ASSERT_PRED(checkIsLess("ABCD", "abcd"));
+  JSONTEST_ASSERT_PRED(checkIsEqual("ABCD", "ABCD"));
 }
 
-
-JSONTEST_FIXTURE( ValueTest, compareBoolean )
-{
-    JSONTEST_ASSERT_PRED( checkIsLess( false, true ) );
-    JSONTEST_ASSERT_PRED( checkIsEqual( false, false ) );
-    JSONTEST_ASSERT_PRED( checkIsEqual( true, true ) );
+JSONTEST_FIXTURE(ValueTest, compareBoolean) {
+  JSONTEST_ASSERT_PRED(checkIsLess(false, true));
+  JSONTEST_ASSERT_PRED(checkIsEqual(false, false));
+  JSONTEST_ASSERT_PRED(checkIsEqual(true, true));
 }
 
-
-JSONTEST_FIXTURE( ValueTest, compareArray )
-{
-    // array compare size then content
-    Json::Value emptyArray(Json::arrayValue);
-    Json::Value l1aArray;
-    l1aArray.append( 0 );
-    Json::Value l1bArray;
-    l1bArray.append( 10 );
-    Json::Value l2aArray;
-    l2aArray.append( 0 );
-    l2aArray.append( 0 );
-    Json::Value l2bArray;
-    l2bArray.append( 0 );
-    l2bArray.append( 10 );
-    JSONTEST_ASSERT_PRED( checkIsLess( emptyArray, l1aArray ) );
-    JSONTEST_ASSERT_PRED( checkIsLess( emptyArray, l2aArray ) );
-    JSONTEST_ASSERT_PRED( checkIsLess( l1aArray, l2aArray ) );
-    JSONTEST_ASSERT_PRED( checkIsLess( l2aArray, l2bArray ) );
-    JSONTEST_ASSERT_PRED( checkIsEqual( emptyArray, Json::Value( emptyArray ) ) );
-    JSONTEST_ASSERT_PRED( checkIsEqual( l1aArray, Json::Value( l1aArray) ) );
-    JSONTEST_ASSERT_PRED( checkIsEqual( l2bArray, Json::Value( l2bArray) ) );
+JSONTEST_FIXTURE(ValueTest, compareArray) {
+  // array compare size then content
+  Json::Value emptyArray(Json::arrayValue);
+  Json::Value l1aArray;
+  l1aArray.append(0);
+  Json::Value l1bArray;
+  l1bArray.append(10);
+  Json::Value l2aArray;
+  l2aArray.append(0);
+  l2aArray.append(0);
+  Json::Value l2bArray;
+  l2bArray.append(0);
+  l2bArray.append(10);
+  JSONTEST_ASSERT_PRED(checkIsLess(emptyArray, l1aArray));
+  JSONTEST_ASSERT_PRED(checkIsLess(emptyArray, l2aArray));
+  JSONTEST_ASSERT_PRED(checkIsLess(l1aArray, l2aArray));
+  JSONTEST_ASSERT_PRED(checkIsLess(l2aArray, l2bArray));
+  JSONTEST_ASSERT_PRED(checkIsEqual(emptyArray, Json::Value(emptyArray)));
+  JSONTEST_ASSERT_PRED(checkIsEqual(l1aArray, Json::Value(l1aArray)));
+  JSONTEST_ASSERT_PRED(checkIsEqual(l2bArray, Json::Value(l2bArray)));
 }
 
-
-JSONTEST_FIXTURE( ValueTest, compareObject )
-{
-    // object compare size then content
-    Json::Value emptyObject(Json::objectValue);
-    Json::Value l1aObject;
-    l1aObject["key1"] = 0;
-    Json::Value l1bObject;
-    l1aObject["key1"] = 10;
-    Json::Value l2aObject;
-    l2aObject["key1"] = 0;
-    l2aObject["key2"] = 0;
-    JSONTEST_ASSERT_PRED( checkIsLess( emptyObject, l1aObject ) );
-    JSONTEST_ASSERT_PRED( checkIsLess( emptyObject, l2aObject ) );
-    JSONTEST_ASSERT_PRED( checkIsLess( l1aObject, l2aObject ) );
-    JSONTEST_ASSERT_PRED( checkIsEqual( emptyObject, Json::Value( emptyObject ) ) );
-    JSONTEST_ASSERT_PRED( checkIsEqual( l1aObject, Json::Value( l1aObject ) ) );
-    JSONTEST_ASSERT_PRED( checkIsEqual( l2aObject, Json::Value( l2aObject ) ) );
+JSONTEST_FIXTURE(ValueTest, compareObject) {
+  // object compare size then content
+  Json::Value emptyObject(Json::objectValue);
+  Json::Value l1aObject;
+  l1aObject["key1"] = 0;
+  Json::Value l1bObject;
+  l1aObject["key1"] = 10;
+  Json::Value l2aObject;
+  l2aObject["key1"] = 0;
+  l2aObject["key2"] = 0;
+  JSONTEST_ASSERT_PRED(checkIsLess(emptyObject, l1aObject));
+  JSONTEST_ASSERT_PRED(checkIsLess(emptyObject, l2aObject));
+  JSONTEST_ASSERT_PRED(checkIsLess(l1aObject, l2aObject));
+  JSONTEST_ASSERT_PRED(checkIsEqual(emptyObject, Json::Value(emptyObject)));
+  JSONTEST_ASSERT_PRED(checkIsEqual(l1aObject, Json::Value(l1aObject)));
+  JSONTEST_ASSERT_PRED(checkIsEqual(l2aObject, Json::Value(l2aObject)));
 }
 
-
-JSONTEST_FIXTURE( ValueTest, compareType )
-{
-    // object of different type are ordered according to their type
-    JSONTEST_ASSERT_PRED( checkIsLess( Json::Value(), Json::Value(1) ) );
-    JSONTEST_ASSERT_PRED( checkIsLess( Json::Value(1), Json::Value(1u) ) );
-    JSONTEST_ASSERT_PRED( checkIsLess( Json::Value(1u), Json::Value(1.0) ) );
-    JSONTEST_ASSERT_PRED( checkIsLess( Json::Value(1.0), Json::Value("a") ) );
-    JSONTEST_ASSERT_PRED( checkIsLess( Json::Value("a"), Json::Value(true) ) );
-    JSONTEST_ASSERT_PRED( checkIsLess( Json::Value(true), Json::Value(Json::arrayValue) ) );
-    JSONTEST_ASSERT_PRED( checkIsLess( Json::Value(Json::arrayValue), Json::Value(Json::objectValue) ) );
+JSONTEST_FIXTURE(ValueTest, compareType) {
+  // object of different type are ordered according to their type
+  JSONTEST_ASSERT_PRED(checkIsLess(Json::Value(), Json::Value(1)));
+  JSONTEST_ASSERT_PRED(checkIsLess(Json::Value(1), Json::Value(1u)));
+  JSONTEST_ASSERT_PRED(checkIsLess(Json::Value(1u), Json::Value(1.0)));
+  JSONTEST_ASSERT_PRED(checkIsLess(Json::Value(1.0), Json::Value("a")));
+  JSONTEST_ASSERT_PRED(checkIsLess(Json::Value("a"), Json::Value(true)));
+  JSONTEST_ASSERT_PRED(
+      checkIsLess(Json::Value(true), Json::Value(Json::arrayValue)));
+  JSONTEST_ASSERT_PRED(checkIsLess(Json::Value(Json::arrayValue),
+                                   Json::Value(Json::objectValue)));
 }
 
-
-void 
-ValueTest::checkIsLess( const Json::Value &x, const Json::Value &y )
-{
-    JSONTEST_ASSERT( x < y );
-    JSONTEST_ASSERT( y > x );
-    JSONTEST_ASSERT( x <= y );
-    JSONTEST_ASSERT( y >= x );
-    JSONTEST_ASSERT( !(x == y) );
-    JSONTEST_ASSERT( !(y == x) );
-    JSONTEST_ASSERT( !(x >= y) );
-    JSONTEST_ASSERT( !(y <= x) );
-    JSONTEST_ASSERT( !(x > y) );
-    JSONTEST_ASSERT( !(y < x) );
-    JSONTEST_ASSERT( x.compare( y ) < 0 );
-    JSONTEST_ASSERT( y.compare( x ) >= 0 );
+void ValueTest::checkIsLess(const Json::Value &x, const Json::Value &y) {
+  JSONTEST_ASSERT(x < y);
+  JSONTEST_ASSERT(y > x);
+  JSONTEST_ASSERT(x <= y);
+  JSONTEST_ASSERT(y >= x);
+  JSONTEST_ASSERT(!(x == y));
+  JSONTEST_ASSERT(!(y == x));
+  JSONTEST_ASSERT(!(x >= y));
+  JSONTEST_ASSERT(!(y <= x));
+  JSONTEST_ASSERT(!(x > y));
+  JSONTEST_ASSERT(!(y < x));
+  JSONTEST_ASSERT(x.compare(y) < 0);
+  JSONTEST_ASSERT(y.compare(x) >= 0);
 }
 
-
-void 
-ValueTest::checkIsEqual( const Json::Value &x, const Json::Value &y )
-{
-    JSONTEST_ASSERT( x == y );
-    JSONTEST_ASSERT( y == x );
-    JSONTEST_ASSERT( x <= y );
-    JSONTEST_ASSERT( y <= x );
-    JSONTEST_ASSERT( x >= y );
-    JSONTEST_ASSERT( y >= x );
-    JSONTEST_ASSERT( !(x < y) );
-    JSONTEST_ASSERT( !(y < x) );
-    JSONTEST_ASSERT( !(x > y) );
-    JSONTEST_ASSERT( !(y > x) );
-    JSONTEST_ASSERT( x.compare( y ) == 0 );
-    JSONTEST_ASSERT( y.compare( x ) == 0 );
+void ValueTest::checkIsEqual(const Json::Value &x, const Json::Value &y) {
+  JSONTEST_ASSERT(x == y);
+  JSONTEST_ASSERT(y == x);
+  JSONTEST_ASSERT(x <= y);
+  JSONTEST_ASSERT(y <= x);
+  JSONTEST_ASSERT(x >= y);
+  JSONTEST_ASSERT(y >= x);
+  JSONTEST_ASSERT(!(x < y));
+  JSONTEST_ASSERT(!(y < x));
+  JSONTEST_ASSERT(!(x > y));
+  JSONTEST_ASSERT(!(y > x));
+  JSONTEST_ASSERT(x.compare(y) == 0);
+  JSONTEST_ASSERT(y.compare(x) == 0);
 }
 
-
-JSONTEST_FIXTURE( ValueTest, checkInteger )
-{
+JSONTEST_FIXTURE(ValueTest, checkInteger) {
 #if JSON_USE_EXCEPTION
   try {
     Json::Value x = 1;
     x["key"]; // SIGABRT?
     // regression for https://sourceforge.net/p/jsoncpp/bugs/67/
-    JSONTEST_ASSERT( 0 );
-  } catch (std::runtime_error const&) {
-    JSONTEST_ASSERT( 1 );  // good
+    JSONTEST_ASSERT(0);
   }
-#endif  // JSON_USE_EXCEPTION
+  catch (std::runtime_error const &) {
+    JSONTEST_ASSERT(1); // good
+  }
+#endif // JSON_USE_EXCEPTION
 }
 
-
-JSONTEST_FIXTURE( ValueTest, offsetAccessors )
-{
-    Json::Value x;
-    JSONTEST_ASSERT( x.getOffsetStart() == 0 );
-    JSONTEST_ASSERT( x.getOffsetLimit() == 0 );
-    x.setOffsetStart(10);
-    x.setOffsetLimit(20);
-    JSONTEST_ASSERT( x.getOffsetStart() == 10 );
-    JSONTEST_ASSERT( x.getOffsetLimit() == 20 );
-    Json::Value y(x);
-    JSONTEST_ASSERT( y.getOffsetStart() == 10 );
-    JSONTEST_ASSERT( y.getOffsetLimit() == 20 );
-    Json::Value z;
-    z.swap(y);
-    JSONTEST_ASSERT( z.getOffsetStart() == 10 );
-    JSONTEST_ASSERT( z.getOffsetLimit() == 20 );
-    JSONTEST_ASSERT( y.getOffsetStart() == 0 );
-    JSONTEST_ASSERT( y.getOffsetLimit() == 0 );
+JSONTEST_FIXTURE(ValueTest, offsetAccessors) {
+  Json::Value x;
+  JSONTEST_ASSERT(x.getOffsetStart() == 0);
+  JSONTEST_ASSERT(x.getOffsetLimit() == 0);
+  x.setOffsetStart(10);
+  x.setOffsetLimit(20);
+  JSONTEST_ASSERT(x.getOffsetStart() == 10);
+  JSONTEST_ASSERT(x.getOffsetLimit() == 20);
+  Json::Value y(x);
+  JSONTEST_ASSERT(y.getOffsetStart() == 10);
+  JSONTEST_ASSERT(y.getOffsetLimit() == 20);
+  Json::Value z;
+  z.swap(y);
+  JSONTEST_ASSERT(z.getOffsetStart() == 10);
+  JSONTEST_ASSERT(z.getOffsetLimit() == 20);
+  JSONTEST_ASSERT(y.getOffsetStart() == 0);
+  JSONTEST_ASSERT(y.getOffsetLimit() == 0);
 }
 
-struct WriterTest : JsonTest::TestCase
-{
-};
+struct WriterTest : JsonTest::TestCase {};
 
+JSONTEST_FIXTURE(WriterTest, dropNullPlaceholders) {
+  Json::FastWriter writer;
+  Json::Value nullValue;
+  JSONTEST_ASSERT(writer.write(nullValue) == "null\n");
 
-JSONTEST_FIXTURE( WriterTest, dropNullPlaceholders )
-{
-    Json::FastWriter writer;
-    Json::Value nullValue;
-    JSONTEST_ASSERT( writer.write(nullValue) == "null\n" );
-
-    writer.dropNullPlaceholders();
-    JSONTEST_ASSERT( writer.write(nullValue) == "\n" );
+  writer.dropNullPlaceholders();
+  JSONTEST_ASSERT(writer.write(nullValue) == "\n");
 }
 
+struct ReaderTest : JsonTest::TestCase {};
 
-struct ReaderTest : JsonTest::TestCase
-{
-};
-
-
-JSONTEST_FIXTURE( ReaderTest, parseWithNoErrors )
-{
-    Json::Reader reader;
-    Json::Value root;
-    bool ok = reader.parse(
-        "{ \"property\" : \"value\" }",
-        root);
-    JSONTEST_ASSERT( ok );
-    JSONTEST_ASSERT( reader.getFormattedErrorMessages().size() == 0 );
-    JSONTEST_ASSERT( reader.getStructuredErrors().size() == 0 );
+JSONTEST_FIXTURE(ReaderTest, parseWithNoErrors) {
+  Json::Reader reader;
+  Json::Value root;
+  bool ok = reader.parse("{ \"property\" : \"value\" }", root);
+  JSONTEST_ASSERT(ok);
+  JSONTEST_ASSERT(reader.getFormattedErrorMessages().size() == 0);
+  JSONTEST_ASSERT(reader.getStructuredErrors().size() == 0);
 }
 
-
-JSONTEST_FIXTURE( ReaderTest, parseWithNoErrorsTestingOffsets )
-{
-    Json::Reader reader;
-    Json::Value root;
-    bool ok = reader.parse(
-        "{ \"property\" : [\"value\", \"value2\"], \"obj\" : { \"nested\" : 123, \"bool\" : true}, \"null\" : null, \"false\" : false }",
-        root);
-    JSONTEST_ASSERT( ok );
-    JSONTEST_ASSERT( reader.getFormattedErrorMessages().size() == 0 );
-    JSONTEST_ASSERT( reader.getStructuredErrors().size() == 0 );
-    JSONTEST_ASSERT( root["property"].getOffsetStart() == 15 );
-    JSONTEST_ASSERT( root["property"].getOffsetLimit() == 34 );
-    JSONTEST_ASSERT( root["property"][0].getOffsetStart() == 16 );
-    JSONTEST_ASSERT( root["property"][0].getOffsetLimit() == 23 );
-    JSONTEST_ASSERT( root["property"][1].getOffsetStart() == 25 );
-    JSONTEST_ASSERT( root["property"][1].getOffsetLimit() == 33 );
-    JSONTEST_ASSERT( root["obj"].getOffsetStart() == 44 );
-    JSONTEST_ASSERT( root["obj"].getOffsetLimit() == 76 );
-    JSONTEST_ASSERT( root["obj"]["nested"].getOffsetStart() == 57 );
-    JSONTEST_ASSERT( root["obj"]["nested"].getOffsetLimit() == 60 );
-    JSONTEST_ASSERT( root["obj"]["bool"].getOffsetStart() == 71 );
-    JSONTEST_ASSERT( root["obj"]["bool"].getOffsetLimit() == 75 );
-    JSONTEST_ASSERT( root["null"].getOffsetStart() == 87 );
-    JSONTEST_ASSERT( root["null"].getOffsetLimit() == 91 );
-    JSONTEST_ASSERT( root["false"].getOffsetStart() == 103 );
-    JSONTEST_ASSERT( root["false"].getOffsetLimit() == 108 );
-    JSONTEST_ASSERT( root.getOffsetStart() == 0 );
-    JSONTEST_ASSERT( root.getOffsetLimit() == 110 );
+JSONTEST_FIXTURE(ReaderTest, parseWithNoErrorsTestingOffsets) {
+  Json::Reader reader;
+  Json::Value root;
+  bool ok = reader.parse("{ \"property\" : [\"value\", \"value2\"], \"obj\" : "
+                         "{ \"nested\" : 123, \"bool\" : true}, \"null\" : "
+                         "null, \"false\" : false }",
+                         root);
+  JSONTEST_ASSERT(ok);
+  JSONTEST_ASSERT(reader.getFormattedErrorMessages().size() == 0);
+  JSONTEST_ASSERT(reader.getStructuredErrors().size() == 0);
+  JSONTEST_ASSERT(root["property"].getOffsetStart() == 15);
+  JSONTEST_ASSERT(root["property"].getOffsetLimit() == 34);
+  JSONTEST_ASSERT(root["property"][0].getOffsetStart() == 16);
+  JSONTEST_ASSERT(root["property"][0].getOffsetLimit() == 23);
+  JSONTEST_ASSERT(root["property"][1].getOffsetStart() == 25);
+  JSONTEST_ASSERT(root["property"][1].getOffsetLimit() == 33);
+  JSONTEST_ASSERT(root["obj"].getOffsetStart() == 44);
+  JSONTEST_ASSERT(root["obj"].getOffsetLimit() == 76);
+  JSONTEST_ASSERT(root["obj"]["nested"].getOffsetStart() == 57);
+  JSONTEST_ASSERT(root["obj"]["nested"].getOffsetLimit() == 60);
+  JSONTEST_ASSERT(root["obj"]["bool"].getOffsetStart() == 71);
+  JSONTEST_ASSERT(root["obj"]["bool"].getOffsetLimit() == 75);
+  JSONTEST_ASSERT(root["null"].getOffsetStart() == 87);
+  JSONTEST_ASSERT(root["null"].getOffsetLimit() == 91);
+  JSONTEST_ASSERT(root["false"].getOffsetStart() == 103);
+  JSONTEST_ASSERT(root["false"].getOffsetLimit() == 108);
+  JSONTEST_ASSERT(root.getOffsetStart() == 0);
+  JSONTEST_ASSERT(root.getOffsetLimit() == 110);
 }
 
-
-JSONTEST_FIXTURE( ReaderTest, parseWithOneError )
-{
-    Json::Reader reader;
-    Json::Value root;
-    bool ok = reader.parse(
-        "{ \"property\" :: \"value\" }",
-        root);
-    JSONTEST_ASSERT( !ok );
-    JSONTEST_ASSERT( reader.getFormattedErrorMessages() ==
-        "* Line 1, Column 15\n  Syntax error: value, object or array expected.\n" );
-    std::vector<Json::Reader::StructuredError> errors =
-        reader.getStructuredErrors();
-    JSONTEST_ASSERT( errors.size() == 1 );
-    JSONTEST_ASSERT( errors.at(0).offset_start == 14 );
-    JSONTEST_ASSERT( errors.at(0).offset_limit == 15 );
-    JSONTEST_ASSERT( errors.at(0).message ==
-        "Syntax error: value, object or array expected." );
+JSONTEST_FIXTURE(ReaderTest, parseWithOneError) {
+  Json::Reader reader;
+  Json::Value root;
+  bool ok = reader.parse("{ \"property\" :: \"value\" }", root);
+  JSONTEST_ASSERT(!ok);
+  JSONTEST_ASSERT(reader.getFormattedErrorMessages() ==
+                  "* Line 1, Column 15\n  Syntax error: value, object or array "
+                  "expected.\n");
+  std::vector<Json::Reader::StructuredError> errors =
+      reader.getStructuredErrors();
+  JSONTEST_ASSERT(errors.size() == 1);
+  JSONTEST_ASSERT(errors.at(0).offset_start == 14);
+  JSONTEST_ASSERT(errors.at(0).offset_limit == 15);
+  JSONTEST_ASSERT(errors.at(0).message ==
+                  "Syntax error: value, object or array expected.");
 }
 
-
-JSONTEST_FIXTURE( ReaderTest, parseChineseWithOneError )
-{
-    Json::Reader reader;
-    Json::Value root;
-    bool ok = reader.parse(
-        "{ \"pr佐藤erty\" :: \"value\" }",
-        root);
-    JSONTEST_ASSERT( !ok );
-    JSONTEST_ASSERT( reader.getFormattedErrorMessages() ==
-        "* Line 1, Column 19\n  Syntax error: value, object or array expected.\n" );
-    std::vector<Json::Reader::StructuredError> errors =
-        reader.getStructuredErrors();
-    JSONTEST_ASSERT( errors.size() == 1 );
-    JSONTEST_ASSERT( errors.at(0).offset_start == 18 );
-    JSONTEST_ASSERT( errors.at(0).offset_limit == 19 );
-    JSONTEST_ASSERT( errors.at(0).message ==
-        "Syntax error: value, object or array expected." );
+JSONTEST_FIXTURE(ReaderTest, parseChineseWithOneError) {
+  Json::Reader reader;
+  Json::Value root;
+  bool ok = reader.parse("{ \"pr佐藤erty\" :: \"value\" }", root);
+  JSONTEST_ASSERT(!ok);
+  JSONTEST_ASSERT(reader.getFormattedErrorMessages() ==
+                  "* Line 1, Column 19\n  Syntax error: value, object or array "
+                  "expected.\n");
+  std::vector<Json::Reader::StructuredError> errors =
+      reader.getStructuredErrors();
+  JSONTEST_ASSERT(errors.size() == 1);
+  JSONTEST_ASSERT(errors.at(0).offset_start == 18);
+  JSONTEST_ASSERT(errors.at(0).offset_limit == 19);
+  JSONTEST_ASSERT(errors.at(0).message ==
+                  "Syntax error: value, object or array expected.");
 }
 
-
-JSONTEST_FIXTURE( ReaderTest, parseWithDetailError )
-{
-    Json::Reader reader;
-    Json::Value root;
-    bool ok = reader.parse(
-        "{ \"property\" : \"v\\alue\" }",
-        root);
-    JSONTEST_ASSERT( !ok );
-    JSONTEST_ASSERT( reader.getFormattedErrorMessages() ==
-        "* Line 1, Column 16\n  Bad escape sequence in string\nSee Line 1, Column 20 for detail.\n" );
-    std::vector<Json::Reader::StructuredError> errors =
-        reader.getStructuredErrors();
-    JSONTEST_ASSERT( errors.size() == 1 );
-    JSONTEST_ASSERT( errors.at(0).offset_start == 15 );
-    JSONTEST_ASSERT( errors.at(0).offset_limit == 23 );
-    JSONTEST_ASSERT( errors.at(0).message ==
-        "Bad escape sequence in string" );
+JSONTEST_FIXTURE(ReaderTest, parseWithDetailError) {
+  Json::Reader reader;
+  Json::Value root;
+  bool ok = reader.parse("{ \"property\" : \"v\\alue\" }", root);
+  JSONTEST_ASSERT(!ok);
+  JSONTEST_ASSERT(reader.getFormattedErrorMessages() ==
+                  "* Line 1, Column 16\n  Bad escape sequence in string\nSee "
+                  "Line 1, Column 20 for detail.\n");
+  std::vector<Json::Reader::StructuredError> errors =
+      reader.getStructuredErrors();
+  JSONTEST_ASSERT(errors.size() == 1);
+  JSONTEST_ASSERT(errors.at(0).offset_start == 15);
+  JSONTEST_ASSERT(errors.at(0).offset_limit == 23);
+  JSONTEST_ASSERT(errors.at(0).message == "Bad escape sequence in string");
 }
 
+int main(int argc, const char *argv[]) {
+  JsonTest::Runner runner;
+  JSONTEST_REGISTER_FIXTURE(runner, ValueTest, checkNormalizeFloatingPointStr);
+  JSONTEST_REGISTER_FIXTURE(runner, ValueTest, memberCount);
+  JSONTEST_REGISTER_FIXTURE(runner, ValueTest, objects);
+  JSONTEST_REGISTER_FIXTURE(runner, ValueTest, arrays);
+  JSONTEST_REGISTER_FIXTURE(runner, ValueTest, null);
+  JSONTEST_REGISTER_FIXTURE(runner, ValueTest, strings);
+  JSONTEST_REGISTER_FIXTURE(runner, ValueTest, bools);
+  JSONTEST_REGISTER_FIXTURE(runner, ValueTest, integers);
+  JSONTEST_REGISTER_FIXTURE(runner, ValueTest, nonIntegers);
+  JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareNull);
+  JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareInt);
+  JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareUInt);
+  JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareDouble);
+  JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareString);
+  JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareBoolean);
+  JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareArray);
+  JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareObject);
+  JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareType);
+  JSONTEST_REGISTER_FIXTURE(runner, ValueTest, checkInteger);
+  JSONTEST_REGISTER_FIXTURE(runner, ValueTest, offsetAccessors);
 
-int main( int argc, const char *argv[] )
-{
-   JsonTest::Runner runner;
-   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, checkNormalizeFloatingPointStr );
-   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, memberCount );
-   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, objects );
-   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, arrays );
-   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, null );
-   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, strings );
-   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, bools );
-   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, integers );
-   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, nonIntegers );
-   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, compareNull );
-   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, compareInt );
-   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, compareUInt );
-   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, compareDouble );
-   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, compareString );
-   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, compareBoolean );
-   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, compareArray );
-   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, compareObject );
-   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, compareType );
-   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, checkInteger );
-   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, offsetAccessors );
+  JSONTEST_REGISTER_FIXTURE(runner, ReaderTest, parseWithNoErrors);
+  JSONTEST_REGISTER_FIXTURE(
+      runner, ReaderTest, parseWithNoErrorsTestingOffsets);
+  JSONTEST_REGISTER_FIXTURE(runner, ReaderTest, parseWithOneError);
+  JSONTEST_REGISTER_FIXTURE(runner, ReaderTest, parseChineseWithOneError);
+  JSONTEST_REGISTER_FIXTURE(runner, ReaderTest, parseWithDetailError);
 
-   JSONTEST_REGISTER_FIXTURE( runner, ReaderTest, parseWithNoErrors );
-   JSONTEST_REGISTER_FIXTURE( runner, ReaderTest, parseWithNoErrorsTestingOffsets );
-   JSONTEST_REGISTER_FIXTURE( runner, ReaderTest, parseWithOneError );
-   JSONTEST_REGISTER_FIXTURE( runner, ReaderTest, parseChineseWithOneError );
-   JSONTEST_REGISTER_FIXTURE( runner, ReaderTest, parseWithDetailError );
-
-   JSONTEST_REGISTER_FIXTURE( runner, WriterTest, dropNullPlaceholders );
-   return runner.runCommandLine( argc, argv );
+  JSONTEST_REGISTER_FIXTURE(runner, WriterTest, dropNullPlaceholders);
+  return runner.runCommandLine(argc, argv);
 }
 // vim: et ts=4 sts=4 sw=4 tw=0