diff --git a/buffet/states/state_manager_unittest.cc b/buffet/states/state_manager_unittest.cc
index 12d3845..d71ebb6 100644
--- a/buffet/states/state_manager_unittest.cc
+++ b/buffet/states/state_manager_unittest.cc
@@ -21,7 +21,6 @@
 using testing::_;
 using testing::Return;
 using unittests::CreateDictionaryValue;
-using unittests::ValueToString;
 
 namespace {
 std::unique_ptr<base::DictionaryValue> GetTestSchema() {
@@ -53,16 +52,14 @@
     // Initial expectations.
     EXPECT_CALL(mock_state_change_queue_, IsEmpty()).Times(0);
     EXPECT_CALL(mock_state_change_queue_, NotifyPropertiesUpdated(_, _))
-      .Times(0);
+        .Times(0);
     EXPECT_CALL(mock_state_change_queue_, GetAndClearRecordedStateChanges())
-      .Times(0);
+        .Times(0);
     mgr_.reset(new StateManager(&mock_state_change_queue_));
     LoadStateDefinition(GetTestSchema().get(), "default", nullptr);
     ASSERT_TRUE(mgr_->LoadStateDefaults(*GetTestValues().get(), nullptr));
   }
-  void TearDown() override {
-    mgr_.reset();
-  }
+  void TearDown() override { mgr_.reset(); }
 
   void LoadStateDefinition(const base::DictionaryValue* json,
                            const std::string& category,
@@ -82,9 +79,16 @@
 
 TEST_F(StateManagerTest, Initialized) {
   EXPECT_EQ(std::set<std::string>{"default"}, mgr_->GetCategories());
-  EXPECT_EQ("{'base':{'manufacturer':'Skynet','serialNumber':'T1000'},"
-            "'terminator':{'target':''}}",
-            ValueToString(mgr_->GetStateValuesAsJson(nullptr).get()));
+  auto expected = R"({
+    'base': {
+      'manufacturer': 'Skynet',
+      'serialNumber': 'T1000'
+    },
+    'terminator': {
+      'target': ''
+    }
+  })";
+  EXPECT_JSON_EQ(expected, *mgr_->GetStateValuesAsJson(nullptr));
 }
 
 TEST_F(StateManagerTest, LoadStateDefinition) {
@@ -96,27 +100,42 @@
   LoadStateDefinition(dict.get(), "powerd", nullptr);
   EXPECT_EQ((std::set<std::string>{"default", "powerd"}),
             mgr_->GetCategories());
-  EXPECT_EQ("{'base':{'manufacturer':'Skynet','serialNumber':'T1000'},"
-            "'power':{'battery_level':0},"
-            "'terminator':{'target':''}}",
-            ValueToString(mgr_->GetStateValuesAsJson(nullptr).get()));
+
+  auto expected = R"({
+    'base': {
+      'manufacturer': 'Skynet',
+      'serialNumber': 'T1000'
+    },
+    'power': {
+      'battery_level': 0
+    },
+    'terminator': {
+      'target': ''
+    }
+  })";
+  EXPECT_JSON_EQ(expected, *mgr_->GetStateValuesAsJson(nullptr));
 }
 
 TEST_F(StateManagerTest, SetPropertyValue) {
   native_types::Object expected_prop_set{
-    {"terminator.target", unittests::make_string_prop_value("John Connor")},
+      {"terminator.target", unittests::make_string_prop_value("John Connor")},
   };
   base::Time timestamp = base::Time::Now();
   EXPECT_CALL(mock_state_change_queue_,
               NotifyPropertiesUpdated(timestamp, expected_prop_set))
       .WillOnce(Return(true));
-  ASSERT_TRUE(mgr_->SetPropertyValue("terminator.target",
-                                     std::string{"John Connor"},
-                                     timestamp,
-                                     nullptr));
-  EXPECT_EQ("{'base':{'manufacturer':'Skynet','serialNumber':'T1000'},"
-            "'terminator':{'target':'John Connor'}}",
-            ValueToString(mgr_->GetStateValuesAsJson(nullptr).get()));
+  ASSERT_TRUE(mgr_->SetPropertyValue(
+      "terminator.target", std::string{"John Connor"}, timestamp, nullptr));
+  auto expected = R"({
+    'base': {
+      'manufacturer': 'Skynet',
+      'serialNumber': 'T1000'
+    },
+    'terminator': {
+      'target': 'John Connor'
+    }
+  })";
+  EXPECT_JSON_EQ(expected, *mgr_->GetStateValuesAsJson(nullptr));
 }
 
 TEST_F(StateManagerTest, SetPropertyValue_Error_NoName) {
@@ -129,8 +148,8 @@
 
 TEST_F(StateManagerTest, SetPropertyValue_Error_NoPackage) {
   chromeos::ErrorPtr error;
-  ASSERT_FALSE(mgr_->SetPropertyValue("target", int{0}, base::Time::Now(),
-                                      &error));
+  ASSERT_FALSE(
+      mgr_->SetPropertyValue("target", int{0}, base::Time::Now(), &error));
   EXPECT_EQ(errors::state::kDomain, error->GetDomain());
   EXPECT_EQ(errors::state::kPackageNameMissing, error->GetCode());
   EXPECT_EQ("Package name is missing in the property name",
@@ -139,8 +158,8 @@
 
 TEST_F(StateManagerTest, SetPropertyValue_Error_UnknownPackage) {
   chromeos::ErrorPtr error;
-  ASSERT_FALSE(mgr_->SetPropertyValue("power.level", int{0}, base::Time::Now(),
-                                      &error));
+  ASSERT_FALSE(
+      mgr_->SetPropertyValue("power.level", int{0}, base::Time::Now(), &error));
   EXPECT_EQ(errors::state::kDomain, error->GetDomain());
   EXPECT_EQ(errors::state::kPropertyNotDefined, error->GetCode());
   EXPECT_EQ("Unknown state property package 'power'", error->GetMessage());
@@ -148,8 +167,8 @@
 
 TEST_F(StateManagerTest, SetPropertyValue_Error_UnknownProperty) {
   chromeos::ErrorPtr error;
-  ASSERT_FALSE(mgr_->SetPropertyValue("base.level", int{0}, base::Time::Now(),
-                                      &error));
+  ASSERT_FALSE(
+      mgr_->SetPropertyValue("base.level", int{0}, base::Time::Now(), &error));
   EXPECT_EQ(errors::state::kDomain, error->GetDomain());
   EXPECT_EQ(errors::state::kPropertyNotDefined, error->GetCode());
   EXPECT_EQ("State property 'base.level' is not defined", error->GetMessage());
@@ -159,10 +178,8 @@
   base::Time timestamp = base::Time::Now();
   EXPECT_CALL(mock_state_change_queue_, NotifyPropertiesUpdated(timestamp, _))
       .WillOnce(Return(true));
-  ASSERT_TRUE(mgr_->SetPropertyValue("terminator.target",
-                                     std::string{"John Connor"},
-                                     timestamp,
-                                     nullptr));
+  ASSERT_TRUE(mgr_->SetPropertyValue(
+      "terminator.target", std::string{"John Connor"}, timestamp, nullptr));
   std::vector<StateChange> expected_val;
   expected_val.emplace_back(
       timestamp,
diff --git a/buffet/states/state_package_unittest.cc b/buffet/states/state_package_unittest.cc
index 7856531..179d206 100644
--- a/buffet/states/state_package_unittest.cc
+++ b/buffet/states/state_package_unittest.cc
@@ -18,7 +18,6 @@
 namespace buffet {
 
 using unittests::CreateDictionaryValue;
-using unittests::ValueToString;
 
 class StatePackageTestHelper {
  public:
@@ -86,16 +85,41 @@
   ASSERT_TRUE(package.AddSchemaFromJson(GetTestSchema().get(), nullptr));
   EXPECT_EQ(4, GetTypes(package).GetProps().size());
   EXPECT_EQ(4, GetValues(package).size());
-  EXPECT_EQ("{'color':{'type':'string'},"
-            "'direction':{'additionalProperties':false,'properties':{"
-              "'altitude':{'maximum':90.0,'type':'number'},"
-              "'azimuth':{'type':'number'}},"
-              "'type':'object'},"
-            "'iso':{'enum':[50,100,200,400],'type':'integer'},"
-            "'light':{'type':'boolean'}}",
-            ValueToString(GetTypes(package).ToJson(true, nullptr).get()));
-  EXPECT_EQ("{'color':'','direction':{},'iso':0,'light':false}",
-            ValueToString(package.GetValuesAsJson(nullptr).get()));
+
+  auto expected = R"({
+    'color': {
+      'type': 'string'
+    },
+    'direction': {
+      'additionalProperties': false,
+      'properties': {
+        'altitude': {
+          'maximum': 90.0,
+          'type': 'number'
+        },
+        'azimuth': {
+          'type': 'number'
+        }
+      },
+      'type': 'object'
+    },
+    'iso': {
+      'enum': [50, 100, 200, 400],
+      'type': 'integer'
+    },
+    'light': {
+      'type': 'boolean'
+    }
+  })";
+  EXPECT_JSON_EQ(expected, *GetTypes(package).ToJson(true, nullptr));
+
+  expected = R"({
+    'color': '',
+    'direction': {},
+    'iso': 0,
+    'light': false
+  })";
+  EXPECT_JSON_EQ(expected, *package.GetValuesAsJson(nullptr));
 }
 
 TEST(StatePackage, AddValuesFromJson_OnEmpty) {
@@ -103,11 +127,16 @@
   ASSERT_TRUE(package.AddSchemaFromJson(GetTestSchema().get(), nullptr));
   ASSERT_TRUE(package.AddValuesFromJson(GetTestValues().get(), nullptr));
   EXPECT_EQ(4, GetValues(package).size());
-  EXPECT_EQ("{'color':'white',"
-            "'direction':{'altitude':89.9,'azimuth':57.2957795},"
-            "'iso':200,"
-            "'light':true}",
-            ValueToString(package.GetValuesAsJson(nullptr).get()));
+  auto expected = R"({
+    'color': 'white',
+    'direction': {
+      'altitude': 89.9,
+      'azimuth': 57.2957795
+    },
+    'iso': 200,
+    'light': true
+  })";
+  EXPECT_JSON_EQ(expected, *package.GetValuesAsJson(nullptr));
 }
 
 TEST_F(StatePackageTest, AddSchemaFromJson_AddMore) {
@@ -115,21 +144,48 @@
   ASSERT_TRUE(package_->AddSchemaFromJson(dict.get(), nullptr));
   EXPECT_EQ(5, GetTypes(*package_).GetProps().size());
   EXPECT_EQ(5, GetValues(*package_).size());
-  EXPECT_EQ("{'brightness':{'enum':['low','medium','high'],'type':'string'},"
-            "'color':{'type':'string'},"
-            "'direction':{'additionalProperties':false,'properties':{"
-              "'altitude':{'maximum':90.0,'type':'number'},"
-              "'azimuth':{'type':'number'}},"
-              "'type':'object'},"
-            "'iso':{'enum':[50,100,200,400],'type':'integer'},"
-            "'light':{'type':'boolean'}}",
-            ValueToString(GetTypes(*package_).ToJson(true, nullptr).get()));
-  EXPECT_EQ("{'brightness':'',"
-            "'color':'white',"
-            "'direction':{'altitude':89.9,'azimuth':57.2957795},"
-            "'iso':200,"
-            "'light':true}",
-            ValueToString(package_->GetValuesAsJson(nullptr).get()));
+  auto expected = R"({
+    'brightness': {
+      'enum': ['low', 'medium', 'high'],
+      'type': 'string'
+    },
+    'color': {
+      'type': 'string'
+    },
+    'direction': {
+      'additionalProperties': false,
+      'properties': {
+        'altitude': {
+          'maximum': 90.0,
+          'type': 'number'
+        },
+        'azimuth': {
+          'type': 'number'
+        }
+      },
+      'type': 'object'
+    },
+    'iso': {
+      'enum': [50, 100, 200, 400],
+      'type': 'integer'
+    },
+    'light': {
+      'type': 'boolean'
+    }
+  })";
+  EXPECT_JSON_EQ(expected, *GetTypes(*package_).ToJson(true, nullptr));
+
+  expected = R"({
+    'brightness': '',
+    'color': 'white',
+    'direction': {
+      'altitude': 89.9,
+      'azimuth': 57.2957795
+    },
+    'iso': 200,
+    'light': true
+  })";
+  EXPECT_JSON_EQ(expected, *package_->GetValuesAsJson(nullptr));
 }
 
 TEST_F(StatePackageTest, AddValuesFromJson_AddMore) {
@@ -138,12 +194,17 @@
   dict = CreateDictionaryValue("{'brightness':'medium'}");
   ASSERT_TRUE(package_->AddValuesFromJson(dict.get(), nullptr));
   EXPECT_EQ(5, GetValues(*package_).size());
-  EXPECT_EQ("{'brightness':'medium',"
-            "'color':'white',"
-            "'direction':{'altitude':89.9,'azimuth':57.2957795},"
-            "'iso':200,"
-            "'light':true}",
-            ValueToString(package_->GetValuesAsJson(nullptr).get()));
+  auto expected = R"({
+    'brightness': 'medium',
+    'color': 'white',
+    'direction': {
+      'altitude': 89.9,
+      'azimuth': 57.2957795
+    },
+    'iso': 200,
+    'light': true
+  })";
+  EXPECT_JSON_EQ(expected, *package_->GetValuesAsJson(nullptr));
 }
 
 TEST_F(StatePackageTest, AddSchemaFromJson_Error_Redefined) {
@@ -214,11 +275,17 @@
     {"azimuth", double{15.0}},
   };
   EXPECT_TRUE(package_->SetPropertyValue("direction", direction, nullptr));
-  EXPECT_EQ("{'color':'white',"
-            "'direction':{'altitude':45.0,'azimuth':15.0},"
-            "'iso':200,"
-            "'light':true}",
-            ValueToString(package_->GetValuesAsJson(nullptr).get()));
+
+  auto expected = R"({
+    'color': 'white',
+    'direction': {
+      'altitude': 45.0,
+      'azimuth': 15.0
+    },
+    'iso': 200,
+    'light': true
+  })";
+  EXPECT_JSON_EQ(expected, *package_->GetValuesAsJson(nullptr));
 }
 
 TEST_F(StatePackageTest, SetPropertyValue_Error_TypeMismatch) {