diff --git a/buffet/commands/command_dictionary_unittest.cc b/buffet/commands/command_dictionary_unittest.cc
index 6a2c8d7..e31f8cc 100644
--- a/buffet/commands/command_dictionary_unittest.cc
+++ b/buffet/commands/command_dictionary_unittest.cc
@@ -11,6 +11,7 @@
 namespace buffet {
 
 using unittests::CreateDictionaryValue;
+using unittests::IsEqualValue;
 
 TEST(CommandDictionary, Empty) {
   CommandDictionary dict;
@@ -206,7 +207,7 @@
   CommandDictionary base_dict;
   base_dict.LoadCommands(*json_base, "base", nullptr, nullptr);
 
-  auto json = unittests::CreateDictionaryValue(R"({
+  auto json = CreateDictionaryValue(R"({
     'base': {
       'reboot': {
         'parameters': {'delay': {'minimum': 10}},
@@ -225,24 +226,51 @@
 
   json = dict.GetCommandsAsJson(
       [](const CommandDefinition* def) { return true; }, false, nullptr);
-  EXPECT_NE(nullptr, json.get());
-  EXPECT_EQ(
-      "{'base':{'reboot':{'parameters':{'delay':{'minimum':10}}}},"
-      "'robot':{'_jump':{'parameters':{'_height':'integer'}}}}",
-      unittests::ValueToString(json.get()));
+  ASSERT_NE(nullptr, json.get());
+  auto expected = R"({
+    'base': {
+      'reboot': {
+        'parameters': {'delay': {'minimum': 10}}
+      }
+    },
+    'robot': {
+      '_jump': {
+        'parameters': {'_height': 'integer'}
+      }
+    }
+  })";
+  EXPECT_JSON_EQ(expected, *json);
 
   json = dict.GetCommandsAsJson(
       [](const CommandDefinition* def) { return true; }, true, nullptr);
-  EXPECT_NE(nullptr, json.get());
-  EXPECT_EQ(
-      "{'base':{'reboot':{'parameters':{'delay':{"
-      "'maximum':100,'minimum':10,'type':'integer'}}}},"
-      "'robot':{'_jump':{'parameters':{'_height':{'type':'integer'}}}}}",
-      unittests::ValueToString(json.get()));
+  ASSERT_NE(nullptr, json.get());
+  expected = R"({
+    'base': {
+      'reboot': {
+        'parameters': {
+          'delay': {
+            'maximum': 100,
+            'minimum': 10,
+            'type': 'integer'
+          }
+        }
+      }
+    },
+    'robot': {
+      '_jump': {
+        'parameters': {
+          '_height': {
+           'type': 'integer'
+          }
+        }
+      }
+    }
+  })";
+  EXPECT_JSON_EQ(expected, *json);
 }
 
 TEST(CommandDictionary, GetCommandsAsJsonWithVisibility) {
-  auto json = unittests::CreateDictionaryValue(R"({
+  auto json = CreateDictionaryValue(R"({
     'test': {
       'command1': {
         'parameters': {},
@@ -292,56 +320,60 @@
   json = dict.GetCommandsAsJson(
       [](const CommandDefinition* def) { return true; }, false, nullptr);
   ASSERT_NE(nullptr, json.get());
-  EXPECT_EQ(
-      "{'test':{"
-      "'command1':{'parameters':{}},"
-      "'command2':{'parameters':{}},"
-      "'command3':{'parameters':{}},"
-      "'command4':{'parameters':{}},"
-      "'command5':{'parameters':{}},"
-      "'command6':{'parameters':{}},"
-      "'command7':{'parameters':{}},"
-      "'command8':{'parameters':{}}"
-      "}}",
-      unittests::ValueToString(json.get()));
+  auto expected = R"({
+    'test': {
+      'command1': {'parameters': {}},
+      'command2': {'parameters': {}},
+      'command3': {'parameters': {}},
+      'command4': {'parameters': {}},
+      'command5': {'parameters': {}},
+      'command6': {'parameters': {}},
+      'command7': {'parameters': {}},
+      'command8': {'parameters': {}}
+    }
+  })";
+  EXPECT_JSON_EQ(expected, *json);
 
   json = dict.GetCommandsAsJson(
       [](const CommandDefinition* def) { return def->GetVisibility().local; },
       false, nullptr);
   ASSERT_NE(nullptr, json.get());
-  EXPECT_EQ(
-      "{'test':{"
-      "'command2':{'parameters':{}},"
-      "'command4':{'parameters':{}},"
-      "'command6':{'parameters':{}},"
-      "'command8':{'parameters':{}}"
-      "}}",
-      unittests::ValueToString(json.get()));
+  expected = R"({
+    'test': {
+      'command2': {'parameters': {}},
+      'command4': {'parameters': {}},
+      'command6': {'parameters': {}},
+      'command8': {'parameters': {}}
+    }
+  })";
+  EXPECT_JSON_EQ(expected, *json);
 
   json = dict.GetCommandsAsJson(
       [](const CommandDefinition* def) { return def->GetVisibility().cloud; },
       false, nullptr);
   ASSERT_NE(nullptr, json.get());
-  EXPECT_EQ(
-      "{'test':{"
-      "'command3':{'parameters':{}},"
-      "'command4':{'parameters':{}},"
-      "'command7':{'parameters':{}},"
-      "'command8':{'parameters':{}}"
-      "}}",
-      unittests::ValueToString(json.get()));
+  expected = R"({
+    'test': {
+      'command3': {'parameters': {}},
+      'command4': {'parameters': {}},
+      'command7': {'parameters': {}},
+      'command8': {'parameters': {}}
+    }
+  })";
+  EXPECT_JSON_EQ(expected, *json);
 
   json = dict.GetCommandsAsJson(
     [](const CommandDefinition* def) {
       return def->GetVisibility().local && def->GetVisibility().cloud;
     }, false, nullptr);
   ASSERT_NE(nullptr, json.get());
-  EXPECT_EQ(
-      "{'test':{"
-      "'command4':{'parameters':{}},"
-      "'command8':{'parameters':{}}"
-      "}}",
-      unittests::ValueToString(json.get()));
+  expected = R"({
+    'test': {
+      'command4': {'parameters': {}},
+      'command8': {'parameters': {}}
+    }
+  })";
+  EXPECT_JSON_EQ(expected, *json);
 }
 
 TEST(CommandDictionary, LoadCommandsWithVisibility) {
diff --git a/buffet/commands/object_schema_unittest.cc b/buffet/commands/object_schema_unittest.cc
index 06d2ca7..1330099 100644
--- a/buffet/commands/object_schema_unittest.cc
+++ b/buffet/commands/object_schema_unittest.cc
@@ -23,7 +23,6 @@
 
 using unittests::CreateValue;
 using unittests::CreateDictionaryValue;
-using unittests::ValueToString;
 
 namespace {
 
@@ -69,32 +68,26 @@
 
 TEST(CommandSchema, IntPropType_ToJson) {
   IntPropType prop;
-  EXPECT_EQ("'integer'", ValueToString(prop.ToJson(false, nullptr).get()));
-  EXPECT_EQ("{'type':'integer'}",
-            ValueToString(prop.ToJson(true, nullptr).get()));
+  EXPECT_JSON_EQ("'integer'", *prop.ToJson(false, nullptr));
+  EXPECT_JSON_EQ("{'type':'integer'}", *prop.ToJson(true, nullptr));
   IntPropType param2;
   param2.FromJson(CreateDictionaryValue("{}").get(), &prop, nullptr);
-  EXPECT_EQ("{}", ValueToString(param2.ToJson(false, nullptr).get()));
+  EXPECT_JSON_EQ("{}", *param2.ToJson(false, nullptr));
   param2.FromJson(CreateDictionaryValue("{'minimum':3}").get(),
                   &prop, nullptr);
-  EXPECT_EQ("{'minimum':3}",
-            ValueToString(param2.ToJson(false, nullptr).get()));
+  EXPECT_JSON_EQ("{'minimum':3}", *param2.ToJson(false, nullptr));
   param2.FromJson(CreateDictionaryValue("{'maximum':-7}").get(),
                   &prop, nullptr);
-  EXPECT_EQ("{'maximum':-7}",
-            ValueToString(param2.ToJson(false, nullptr).get()));
+  EXPECT_JSON_EQ("{'maximum':-7}", *param2.ToJson(false, nullptr));
   param2.FromJson(CreateDictionaryValue("{'minimum':0,'maximum':5}").get(),
                   &prop, nullptr);
-  EXPECT_EQ("{'maximum':5,'minimum':0}",
-            ValueToString(param2.ToJson(false, nullptr).get()));
+  EXPECT_JSON_EQ("{'maximum':5,'minimum':0}", *param2.ToJson(false, nullptr));
   param2.FromJson(CreateDictionaryValue("{'enum':[1,2,3]}").get(), &prop,
                   nullptr);
-  EXPECT_EQ("[1,2,3]",
-            ValueToString(param2.ToJson(false, nullptr).get()));
+  EXPECT_JSON_EQ("[1,2,3]", *param2.ToJson(false, nullptr));
   param2.FromJson(CreateDictionaryValue("{'default':123}").get(),
                   &prop, nullptr);
-  EXPECT_EQ("{'default':123}",
-            ValueToString(param2.ToJson(false, nullptr).get()));
+  EXPECT_JSON_EQ("{'default':123}", *param2.ToJson(false, nullptr));
 }
 
 TEST(CommandSchema, IntPropType_FromJson) {
@@ -195,21 +188,19 @@
 
 TEST(CommandSchema, BoolPropType_ToJson) {
   BooleanPropType prop;
-  EXPECT_EQ("'boolean'", ValueToString(prop.ToJson(false, nullptr).get()));
-  EXPECT_EQ("{'type':'boolean'}",
-            ValueToString(prop.ToJson(true, nullptr).get()));
+  EXPECT_JSON_EQ("'boolean'", *prop.ToJson(false, nullptr));
+  EXPECT_JSON_EQ("{'type':'boolean'}", *prop.ToJson(true, nullptr));
   BooleanPropType param2;
   param2.FromJson(CreateDictionaryValue("{}").get(), &prop, nullptr);
-  EXPECT_EQ("{}", ValueToString(param2.ToJson(false, nullptr).get()));
+  EXPECT_JSON_EQ("{}", *param2.ToJson(false, nullptr));
   param2.FromJson(CreateDictionaryValue("{'enum':[true,false]}").get(), &prop,
                   nullptr);
-  EXPECT_EQ("[true,false]", ValueToString(param2.ToJson(false, nullptr).get()));
-  EXPECT_EQ("{'enum':[true,false],'type':'boolean'}",
-            ValueToString(param2.ToJson(true, nullptr).get()));
+  EXPECT_JSON_EQ("[true,false]", *param2.ToJson(false, nullptr));
+  EXPECT_JSON_EQ("{'enum':[true,false],'type':'boolean'}",
+                 *param2.ToJson(true, nullptr));
   param2.FromJson(CreateDictionaryValue("{'default':true}").get(),
                   &prop, nullptr);
-  EXPECT_EQ("{'default':true}",
-            ValueToString(param2.ToJson(false, nullptr).get()));
+  EXPECT_JSON_EQ("{'default':true}", *param2.ToJson(false, nullptr));
 }
 
 TEST(CommandSchema, BoolPropType_FromJson) {
@@ -288,28 +279,24 @@
 
 TEST(CommandSchema, DoublePropType_ToJson) {
   DoublePropType prop;
-  EXPECT_EQ("'number'", ValueToString(prop.ToJson(false, nullptr).get()));
-  EXPECT_EQ("{'type':'number'}",
-            ValueToString(prop.ToJson(true, nullptr).get()));
+  EXPECT_JSON_EQ("'number'", *prop.ToJson(false, nullptr));
+  EXPECT_JSON_EQ("{'type':'number'}", *prop.ToJson(true, nullptr));
   DoublePropType param2;
   param2.FromJson(CreateDictionaryValue("{}").get(), &prop, nullptr);
-  EXPECT_EQ("{}", ValueToString(param2.ToJson(false, nullptr).get()));
+  EXPECT_JSON_EQ("{}", *param2.ToJson(false, nullptr));
   param2.FromJson(CreateDictionaryValue("{'minimum':3}").get(), &prop,
                   nullptr);
-  EXPECT_EQ("{'minimum':3.0}",
-            ValueToString(param2.ToJson(false, nullptr).get()));
+  EXPECT_JSON_EQ("{'minimum':3.0}", *param2.ToJson(false, nullptr));
   param2.FromJson(CreateDictionaryValue("{'maximum':-7}").get(), &prop,
                   nullptr);
-  EXPECT_EQ("{'maximum':-7.0}",
-            ValueToString(param2.ToJson(false, nullptr).get()));
+  EXPECT_JSON_EQ("{'maximum':-7.0}", *param2.ToJson(false, nullptr));
   param2.FromJson(CreateDictionaryValue("{'minimum':0,'maximum':5}").get(),
                   &prop, nullptr);
-  EXPECT_EQ("{'maximum':5.0,'minimum':0.0}",
-            ValueToString(param2.ToJson(false, nullptr).get()));
+  EXPECT_JSON_EQ("{'maximum':5.0,'minimum':0.0}",
+                 *param2.ToJson(false, nullptr));
   param2.FromJson(CreateDictionaryValue("{'default':12.3}").get(),
                   &prop, nullptr);
-  EXPECT_EQ("{'default':12.3}",
-            ValueToString(param2.ToJson(false, nullptr).get()));
+  EXPECT_JSON_EQ("{'default':12.3}", *param2.ToJson(false, nullptr));
 }
 
 TEST(CommandSchema, DoublePropType_FromJson) {
@@ -411,28 +398,24 @@
 
 TEST(CommandSchema, StringPropType_ToJson) {
   StringPropType prop;
-  EXPECT_EQ("'string'", ValueToString(prop.ToJson(false, nullptr).get()));
-  EXPECT_EQ("{'type':'string'}",
-            ValueToString(prop.ToJson(true, nullptr).get()));
+  EXPECT_JSON_EQ("'string'", *prop.ToJson(false, nullptr));
+  EXPECT_JSON_EQ("{'type':'string'}", *prop.ToJson(true, nullptr));
   StringPropType param2;
   param2.FromJson(CreateDictionaryValue("{}").get(), &prop, nullptr);
-  EXPECT_EQ("{}", ValueToString(param2.ToJson(false, nullptr).get()));
+  EXPECT_JSON_EQ("{}", *param2.ToJson(false, nullptr));
   param2.FromJson(CreateDictionaryValue("{'minLength':3}").get(), &prop,
                   nullptr);
-  EXPECT_EQ("{'minLength':3}",
-            ValueToString(param2.ToJson(false, nullptr).get()));
+  EXPECT_JSON_EQ("{'minLength':3}", *param2.ToJson(false, nullptr));
   param2.FromJson(CreateDictionaryValue("{'maxLength':7}").get(), &prop,
                   nullptr);
-  EXPECT_EQ("{'maxLength':7}",
-            ValueToString(param2.ToJson(false, nullptr).get()));
+  EXPECT_JSON_EQ("{'maxLength':7}", *param2.ToJson(false, nullptr));
   param2.FromJson(CreateDictionaryValue("{'minLength':0,'maxLength':5}").get(),
                   &prop, nullptr);
-  EXPECT_EQ("{'maxLength':5,'minLength':0}",
-            ValueToString(param2.ToJson(false, nullptr).get()));
+  EXPECT_JSON_EQ("{'maxLength':5,'minLength':0}",
+                 *param2.ToJson(false, nullptr));
   param2.FromJson(CreateDictionaryValue("{'default':'abcd'}").get(),
                   &prop, nullptr);
-  EXPECT_EQ("{'default':'abcd'}",
-            ValueToString(param2.ToJson(false, nullptr).get()));
+  EXPECT_JSON_EQ("{'default':'abcd'}", *param2.ToJson(false, nullptr));
 }
 
 TEST(CommandSchema, StringPropType_FromJson) {
@@ -538,14 +521,15 @@
 
 TEST(CommandSchema, ObjectPropType_ToJson) {
   ObjectPropType prop;
-  EXPECT_EQ("{'additionalProperties':false,'properties':{}}",
-            ValueToString(prop.ToJson(false, nullptr).get()));
-  EXPECT_EQ("{'additionalProperties':false,'properties':{},'type':'object'}",
-            ValueToString(prop.ToJson(true, nullptr).get()));
+  EXPECT_JSON_EQ("{'additionalProperties':false,'properties':{}}",
+                 *prop.ToJson(false, nullptr));
+  EXPECT_JSON_EQ(
+      "{'additionalProperties':false,'properties':{},'type':'object'}",
+      *prop.ToJson(true, nullptr));
   EXPECT_FALSE(prop.IsBasedOnSchema());
   ObjectPropType prop2;
   prop2.FromJson(CreateDictionaryValue("{}").get(), &prop, nullptr);
-  EXPECT_EQ("{}", ValueToString(prop2.ToJson(false, nullptr).get()));
+  EXPECT_JSON_EQ("{}", *prop2.ToJson(false, nullptr));
   EXPECT_TRUE(prop2.IsBasedOnSchema());
 
   auto schema = ObjectSchema::Create();
@@ -554,44 +538,106 @@
   pw->GetString()->AddLengthConstraint(6, 100);
   schema->AddProp("password", std::move(pw));
   prop2.SetObjectSchema(std::move(schema));
-  EXPECT_EQ("{'additionalProperties':false,'properties':{'expires':'integer',"
-            "'password':{'maxLength':100,'minLength':6}}}",
-            ValueToString(prop2.ToJson(false, nullptr).get()));
-  EXPECT_EQ("{'additionalProperties':false,'properties':{"
-            "'expires':{'type':'integer'},"
-            "'password':{'maxLength':100,'minLength':6,'type':'string'}},"
-            "'type':'object'}",
-            ValueToString(prop2.ToJson(true, nullptr).get()));
+  auto expected = R"({
+    'additionalProperties': false,
+    'properties': {
+      'expires': 'integer',
+      'password': {
+        'maxLength': 100,
+        'minLength': 6
+      }
+    }
+  })";
+  EXPECT_JSON_EQ(expected, *prop2.ToJson(false, nullptr));
+
+  expected = R"({
+    'additionalProperties': false,
+    'properties': {
+      'expires': {
+        'type': 'integer'
+      },
+      'password': {
+        'maxLength': 100,
+        'minLength': 6,
+        'type': 'string'
+      }
+    },
+    'type': 'object'
+  })";
+  EXPECT_JSON_EQ(expected, *prop2.ToJson(true, nullptr));
 
   ObjectPropType prop3;
   ASSERT_TRUE(prop3.FromJson(CreateDictionaryValue(
       "{'default':{'expires':3,'password':'abracadabra'}}").get(), &prop2,
       nullptr));
-  EXPECT_EQ("{'default':{'expires':3,'password':'abracadabra'}}",
-            ValueToString(prop3.ToJson(false, nullptr).get()));
-  EXPECT_EQ("{'additionalProperties':false,"
-            "'default':{'expires':3,'password':'abracadabra'},"
-            "'properties':{'expires':{'type':'integer'},"
-            "'password':{'maxLength':100,'minLength':6,'type':'string'}},"
-            "'type':'object'}",
-            ValueToString(prop3.ToJson(true, nullptr).get()));
+  expected = R"({
+    'default': {
+      'expires': 3,
+      'password': 'abracadabra'
+    }
+  })";
+  EXPECT_JSON_EQ(expected, *prop3.ToJson(false, nullptr));
+
+  expected = R"({
+    'additionalProperties': false,
+    'default': {
+      'expires': 3,
+      'password': 'abracadabra'
+    },
+    'properties': {
+      'expires': {
+        'type': 'integer'
+      },
+      'password': {
+        'maxLength': 100,
+        'minLength': 6,
+        'type': 'string'
+      }
+    },
+    'type': 'object'
+  })";
+  EXPECT_JSON_EQ(expected, *prop3.ToJson(true, nullptr));
 
   ObjectPropType prop4;
   ASSERT_TRUE(prop4.FromJson(CreateDictionaryValue(
       "{'additionalProperties':true,"
       "'default':{'expires':3,'password':'abracadabra'}}").get(), &prop2,
       nullptr));
-  EXPECT_EQ("{'additionalProperties':true,"
-            "'default':{'expires':3,'password':'abracadabra'},"
-            "'properties':{'expires':'integer',"
-            "'password':{'maxLength':100,'minLength':6}}}",
-            ValueToString(prop4.ToJson(false, nullptr).get()));
-  EXPECT_EQ("{'additionalProperties':true,"
-            "'default':{'expires':3,'password':'abracadabra'},"
-            "'properties':{'expires':{'type':'integer'},"
-            "'password':{'maxLength':100,'minLength':6,'type':'string'}},"
-            "'type':'object'}",
-            ValueToString(prop4.ToJson(true, nullptr).get()));
+  expected = R"({
+    'additionalProperties': true,
+    'default': {
+      'expires': 3,
+      'password': 'abracadabra'
+    },
+    'properties': {
+      'expires': 'integer',
+      'password': {
+        'maxLength': 100,
+        'minLength': 6
+      }
+    }
+  })";
+  EXPECT_JSON_EQ(expected, *prop4.ToJson(false, nullptr));
+
+  expected = R"({
+    'additionalProperties': true,
+    'default': {
+      'expires': 3,
+      'password': 'abracadabra'
+    },
+    'properties': {
+      'expires': {
+        'type': 'integer'
+      },
+      'password': {
+        'maxLength': 100,
+        'minLength': 6,
+        'type': 'string'
+      }
+    },
+    'type': 'object'
+  })";
+  EXPECT_JSON_EQ(expected, *prop4.ToJson(true, nullptr));
 }
 
 TEST(CommandSchema, ObjectPropType_FromJson) {
@@ -725,21 +771,20 @@
 TEST(CommandSchema, ArrayPropType_ToJson) {
   ArrayPropType prop;
   prop.SetItemType(PropType::Create(ValueType::Int));
-  EXPECT_EQ("{'items':'integer'}",
-            ValueToString(prop.ToJson(false, nullptr).get()));
-  EXPECT_EQ("{'items':{'type':'integer'},'type':'array'}",
-            ValueToString(prop.ToJson(true, nullptr).get()));
+  EXPECT_JSON_EQ("{'items':'integer'}", *prop.ToJson(false, nullptr));
+  EXPECT_JSON_EQ("{'items':{'type':'integer'},'type':'array'}",
+                 *prop.ToJson(true, nullptr));
   EXPECT_FALSE(prop.IsBasedOnSchema());
   ArrayPropType prop2;
   prop2.FromJson(CreateDictionaryValue("{}").get(), &prop, nullptr);
-  EXPECT_EQ("{}", ValueToString(prop2.ToJson(false, nullptr).get()));
+  EXPECT_JSON_EQ("{}", *prop2.ToJson(false, nullptr));
   EXPECT_TRUE(prop2.IsBasedOnSchema());
   prop2.FromJson(CreateDictionaryValue("{'default':[1,2,3]}").get(),
                  &prop, nullptr);
-  EXPECT_EQ("{'default':[1,2,3]}",
-            ValueToString(prop2.ToJson(false, nullptr).get()));
-  EXPECT_EQ("{'default':[1,2,3],'items':{'type':'integer'},'type':'array'}",
-            ValueToString(prop2.ToJson(true, nullptr).get()));
+  EXPECT_JSON_EQ("{'default':[1,2,3]}", *prop2.ToJson(false, nullptr));
+  EXPECT_JSON_EQ(
+      "{'default':[1,2,3],'items':{'type':'integer'},'type':'array'}",
+      *prop2.ToJson(true, nullptr));
 }
 
 TEST(CommandSchema, ArrayPropType_FromJson) {
@@ -816,7 +861,7 @@
   ASSERT_NE(nullptr, val.get());
   EXPECT_EQ(nullptr, error.get());
   EXPECT_EQ(arr, val->GetValueAsAny().Get<native_types::Array>());
-  EXPECT_EQ("[]", ValueToString(val->ToJson(nullptr).get()));
+  EXPECT_JSON_EQ("[]", *val->ToJson(nullptr));
 
   IntPropType int_type;
   ObjectPropType obj_type;
@@ -840,8 +885,8 @@
   ASSERT_NE(nullptr, val.get());
   EXPECT_EQ(nullptr, error.get());
   EXPECT_EQ(arr, val->GetValueAsAny().Get<native_types::Array>());
-  EXPECT_EQ("[{'height':20,'width':10},{'height':18,'width':17}]",
-            ValueToString(val->ToJson(nullptr).get()));
+  EXPECT_JSON_EQ("[{'height':20,'width':10},{'height':18,'width':17}]",
+                 *val->ToJson(nullptr));
 
   val = prop.CreateValue("blah", &error);
   EXPECT_EQ(nullptr, val.get());
diff --git a/buffet/commands/schema_utils_unittest.cc b/buffet/commands/schema_utils_unittest.cc
index 9698317..d872995 100644
--- a/buffet/commands/schema_utils_unittest.cc
+++ b/buffet/commands/schema_utils_unittest.cc
@@ -22,38 +22,32 @@
 
 using unittests::CreateDictionaryValue;
 using unittests::CreateValue;
-using unittests::ValueToString;
 using chromeos::VariantDictionary;
 
 TEST(CommandSchemaUtils, TypedValueToJson_Scalar) {
-  EXPECT_EQ("true", ValueToString(TypedValueToJson(true, nullptr).get()));
-  EXPECT_EQ("false", ValueToString(TypedValueToJson(false, nullptr).get()));
+  EXPECT_JSON_EQ("true", *TypedValueToJson(true, nullptr));
+  EXPECT_JSON_EQ("false", *TypedValueToJson(false, nullptr));
 
-  EXPECT_EQ("0", ValueToString(TypedValueToJson(0, nullptr).get()));
-  EXPECT_EQ("-10", ValueToString(TypedValueToJson(-10, nullptr).get()));
-  EXPECT_EQ("20", ValueToString(TypedValueToJson(20, nullptr).get()));
+  EXPECT_JSON_EQ("0", *TypedValueToJson(0, nullptr));
+  EXPECT_JSON_EQ("-10", *TypedValueToJson(-10, nullptr));
+  EXPECT_JSON_EQ("20", *TypedValueToJson(20, nullptr));
 
-  EXPECT_EQ("0.0", ValueToString(TypedValueToJson(0.0, nullptr).get()));
-  EXPECT_EQ("1.2", ValueToString(TypedValueToJson(1.2, nullptr).get()));
+  EXPECT_JSON_EQ("0.0", *TypedValueToJson(0.0, nullptr));
+  EXPECT_JSON_EQ("1.2", *TypedValueToJson(1.2, nullptr));
 
-  EXPECT_EQ("'abc'",
-            ValueToString(TypedValueToJson(std::string("abc"), nullptr).get()));
+  EXPECT_JSON_EQ("'abc'", *TypedValueToJson(std::string("abc"), nullptr));
 
   std::vector<bool> bool_array{true, false};
-  EXPECT_EQ("[true,false]",
-            ValueToString(TypedValueToJson(bool_array, nullptr).get()));
+  EXPECT_JSON_EQ("[true,false]", *TypedValueToJson(bool_array, nullptr));
 
   std::vector<int> int_array{1, 2, 5};
-  EXPECT_EQ("[1,2,5]",
-            ValueToString(TypedValueToJson(int_array, nullptr).get()));
+  EXPECT_JSON_EQ("[1,2,5]", *TypedValueToJson(int_array, nullptr));
 
   std::vector<double> dbl_array{1.1, 2.2};
-  EXPECT_EQ("[1.1,2.2]",
-            ValueToString(TypedValueToJson(dbl_array, nullptr).get()));
+  EXPECT_JSON_EQ("[1.1,2.2]", *TypedValueToJson(dbl_array, nullptr));
 
   std::vector<std::string> str_array{"a", "bc"};
-  EXPECT_EQ("['a','bc']",
-            ValueToString(TypedValueToJson(str_array, nullptr).get()));
+  EXPECT_JSON_EQ("['a','bc']", *TypedValueToJson(str_array, nullptr));
 }
 
 TEST(CommandSchemaUtils, TypedValueToJson_Object) {
@@ -62,8 +56,8 @@
 
   object.insert(std::make_pair("width", int_type.CreateValue(640, nullptr)));
   object.insert(std::make_pair("height", int_type.CreateValue(480, nullptr)));
-  EXPECT_EQ("{'height':480,'width':640}",
-            ValueToString(TypedValueToJson(object, nullptr).get()));
+  EXPECT_JSON_EQ("{'height':480,'width':640}",
+                 *TypedValueToJson(object, nullptr));
 }
 
 TEST(CommandSchemaUtils, TypedValueToJson_Array) {
@@ -72,7 +66,7 @@
 
   arr.push_back(int_type.CreateValue(640, nullptr));
   arr.push_back(int_type.CreateValue(480, nullptr));
-  EXPECT_EQ("[640,480]", ValueToString(TypedValueToJson(arr, nullptr).get()));
+  EXPECT_JSON_EQ("[640,480]", *TypedValueToJson(arr, nullptr));
 }
 
 TEST(CommandSchemaUtils, TypedValueFromJson_Bool) {
diff --git a/buffet/commands/unittest_utils.cc b/buffet/commands/unittest_utils.cc
index db8aa4a..be4d4e7 100644
--- a/buffet/commands/unittest_utils.cc
+++ b/buffet/commands/unittest_utils.cc
@@ -14,25 +14,22 @@
   std::string json2(json);
   // Convert apostrophes to double-quotes so JSONReader can parse the string.
   std::replace(json2.begin(), json2.end(), '\'', '"');
-  return std::unique_ptr<base::Value>(base::JSONReader::Read(json2));
+  int error = 0;
+  std::string message;
+  std::unique_ptr<base::Value> value{base::JSONReader::ReadAndReturnError(
+      json2, base::JSON_PARSE_RFC, &error, &message)};
+  CHECK(value) << "Failed to load JSON: " << message << ", " << json;
+  return value;
 }
 
 std::unique_ptr<base::DictionaryValue> CreateDictionaryValue(const char* json) {
-  std::string json2(json);
-  std::replace(json2.begin(), json2.end(), '\'', '"');
-  base::Value* value = base::JSONReader::Read(json2);
-  CHECK(value) << "Failed to load JSON: " << json2;
+  std::unique_ptr<base::Value> value = CreateValue(json);
   base::DictionaryValue* dict = nullptr;
   value->GetAsDictionary(&dict);
+  CHECK(dict) << "Value is not dictionary: " << json;
+  value.release();
   return std::unique_ptr<base::DictionaryValue>(dict);
 }
 
-std::string ValueToString(const base::Value* value) {
-  std::string json;
-  base::JSONWriter::Write(value, &json);
-  std::replace(json.begin(), json.end(), '"', '\'');
-  return json;
-}
-
 }  // namespace unittests
 }  // namespace buffet
diff --git a/buffet/commands/unittest_utils.h b/buffet/commands/unittest_utils.h
index 25db6b2..3a9dcc1 100644
--- a/buffet/commands/unittest_utils.h
+++ b/buffet/commands/unittest_utils.h
@@ -9,6 +9,7 @@
 #include <string>
 
 #include <base/values.h>
+#include <gtest/gtest.h>
 
 #include "buffet/commands/prop_types.h"
 #include "buffet/commands/prop_values.h"
@@ -24,9 +25,9 @@
 // Helper method to create a JSON dictionary object from a string.
 std::unique_ptr<base::DictionaryValue> CreateDictionaryValue(const char* json);
 
-// Converts a JSON value to a string. It also converts double-quotes to
-// apostrophes for easy comparisons in C++ source code.
-std::string ValueToString(const base::Value* value);
+inline bool IsEqualValue(const base::Value& val1, const base::Value& val2) {
+  return val1.Equals(&val2);
+}
 
 template <typename PropVal, typename T>
 std::unique_ptr<const PropVal> make_prop_value(const T& value) {
@@ -56,4 +57,8 @@
 }  // namespace unittests
 }  // namespace buffet
 
+#define EXPECT_JSON_EQ(expected, actual) \
+  EXPECT_PRED2(buffet::unittests::IsEqualValue, \
+               *buffet::unittests::CreateValue(expected), actual)
+
 #endif  // BUFFET_COMMANDS_UNITTEST_UTILS_H_