diff --git a/key_file_store_unittest.cc b/key_file_store_unittest.cc
new file mode 100644
index 0000000..9e52558
--- /dev/null
+++ b/key_file_store_unittest.cc
@@ -0,0 +1,429 @@
+// Copyright (c) 2011 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <base/file_util.h>
+#include <base/stl_util-inl.h>
+#include <base/stringprintf.h>
+#include <base/memory/scoped_temp_dir.h>
+#include <gtest/gtest.h>
+
+#include "shill/key_file_store.h"
+
+using std::set;
+using std::string;
+using testing::Test;
+
+namespace shill {
+
+class KeyFileStoreTest : public Test {
+ public:
+  KeyFileStoreTest() : store_(&glib_) {}
+
+  virtual void SetUp() {
+    ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
+    store_.set_path(temp_dir_.path().Append("test-key-file-store"));
+  }
+
+  virtual void TearDown() {
+    store_.set_path(FilePath(""));  // Don't try to save the store.
+    ASSERT_TRUE(temp_dir_.Delete());
+  }
+
+ protected:
+  string ReadKeyFile();
+  void WriteKeyFile(string data);
+
+  GLib glib_;  // Use real GLib for testing KeyFileStore.
+  ScopedTempDir temp_dir_;
+  KeyFileStore store_;
+};
+
+string KeyFileStoreTest::ReadKeyFile() {
+  string data;
+  EXPECT_TRUE(file_util::ReadFileToString(store_.path(), &data));
+  return data;
+}
+
+void KeyFileStoreTest::WriteKeyFile(string data) {
+  EXPECT_EQ(data.size(),
+            file_util::WriteFile(store_.path(), data.data(), data.size()));
+}
+
+TEST_F(KeyFileStoreTest, OpenClose) {
+  EXPECT_FALSE(store_.key_file_);
+
+  ASSERT_TRUE(store_.Open());
+  EXPECT_TRUE(store_.key_file_);
+  ASSERT_TRUE(store_.Close());
+  EXPECT_FALSE(store_.key_file_);
+
+  ASSERT_TRUE(store_.Open());
+  EXPECT_TRUE(store_.key_file_);
+  ASSERT_TRUE(store_.Close());
+  EXPECT_FALSE(store_.key_file_);
+
+  ASSERT_TRUE(store_.Open());
+  store_.set_path(FilePath(""));
+  ASSERT_FALSE(store_.Close());
+  EXPECT_FALSE(store_.key_file_);
+}
+
+TEST_F(KeyFileStoreTest, OpenFail) {
+  WriteKeyFile("garbage\n");
+  EXPECT_FALSE(store_.Open());
+  EXPECT_FALSE(store_.key_file_);
+}
+
+TEST_F(KeyFileStoreTest, GetGroups) {
+  static const char kGroupA[] = "g-a";
+  static const char kGroupB[] = "g-b";
+  static const char kGroupC[] = "g-c";
+  WriteKeyFile(base::StringPrintf("[%s]\n"
+                                  "[%s]\n"
+                                  "[%s]\n",
+                                  kGroupA, kGroupB, kGroupC));
+  ASSERT_TRUE(store_.Open());
+  set<string> groups = store_.GetGroups();
+  EXPECT_EQ(3, groups.size());
+  EXPECT_TRUE(ContainsKey(groups, kGroupA));
+  EXPECT_TRUE(ContainsKey(groups, kGroupB));
+  EXPECT_TRUE(ContainsKey(groups, kGroupC));
+  EXPECT_FALSE(ContainsKey(groups, "g-x"));
+  ASSERT_TRUE(store_.Close());
+}
+
+TEST_F(KeyFileStoreTest, ContainsGroup) {
+  static const char kGroupA[] = "group-a";
+  static const char kGroupB[] = "group-b";
+  static const char kGroupC[] = "group-c";
+  WriteKeyFile(base::StringPrintf("[%s]\n"
+                                  "[%s]\n"
+                                  "[%s]\n",
+                                  kGroupA, kGroupB, kGroupC));
+  ASSERT_TRUE(store_.Open());
+  EXPECT_TRUE(store_.ContainsGroup(kGroupA));
+  EXPECT_TRUE(store_.ContainsGroup(kGroupB));
+  EXPECT_TRUE(store_.ContainsGroup(kGroupC));
+  EXPECT_FALSE(store_.ContainsGroup("group-d"));
+  ASSERT_TRUE(store_.Close());
+}
+
+TEST_F(KeyFileStoreTest, DeleteKey) {
+  static const char kGroup[] = "the-group";
+  static const char kKeyDead[] = "dead";
+  static const char kKeyAlive[] = "alive";
+  const int kValueAlive = 3;
+  WriteKeyFile(base::StringPrintf("[%s]\n"
+                                  "%s=5\n"
+                                  "%s=%d\n",
+                                  kGroup, kKeyDead, kKeyAlive, kValueAlive));
+  ASSERT_TRUE(store_.Open());
+  EXPECT_TRUE(store_.DeleteKey(kGroup, kKeyDead));
+  EXPECT_FALSE(store_.DeleteKey(kGroup, "random-key"));
+  EXPECT_FALSE(store_.DeleteKey("random-group", kKeyAlive));
+  ASSERT_TRUE(store_.Close());
+  EXPECT_EQ(base::StringPrintf("\n"
+                               "[%s]\n"
+                               "%s=%d\n",
+                               kGroup, kKeyAlive, kValueAlive),
+            ReadKeyFile());
+}
+
+TEST_F(KeyFileStoreTest, DeleteGroup) {
+  static const char kGroupA[] = "group-a";
+  static const char kGroupB[] = "group-b";
+  static const char kGroupC[] = "group-c";
+  WriteKeyFile(base::StringPrintf("[%s]\n"
+                                  "[%s]\n"
+                                  "key-to-be-deleted=true\n"
+                                  "[%s]\n",
+                                  kGroupA, kGroupB, kGroupC));
+  ASSERT_TRUE(store_.Open());
+  EXPECT_TRUE(store_.DeleteGroup(kGroupB));
+  EXPECT_FALSE(store_.DeleteGroup("group-d"));
+  ASSERT_TRUE(store_.Close());
+  EXPECT_EQ(base::StringPrintf("\n"
+                               "[%s]\n"
+                               "\n"
+                               "[%s]\n",
+                               kGroupA, kGroupC),
+            ReadKeyFile());
+}
+
+TEST_F(KeyFileStoreTest, GetString) {
+  static const char kGroup[] = "something";
+  static const char kKey[] = "foo";
+  static const char kValue[] = "bar";
+  WriteKeyFile(base::StringPrintf("[%s]\n"
+                                  "%s=%s\n",
+                                  kGroup, kKey, kValue));
+  ASSERT_TRUE(store_.Open());
+  string value;
+  EXPECT_TRUE(store_.GetString(kGroup, kKey, &value));
+  EXPECT_EQ(kValue, value);
+  EXPECT_FALSE(store_.GetString("something-else", kKey, &value));
+  EXPECT_FALSE(store_.GetString(kGroup, "bar", &value));
+  EXPECT_TRUE(store_.GetString(kGroup, kKey, NULL));
+  ASSERT_TRUE(store_.Close());
+}
+
+TEST_F(KeyFileStoreTest, SetString) {
+  static const char kGroup[] = "string-group";
+  static const char kKey1[] = "test-string";
+  static const char kValue1[] = "foo";
+  static const char kKey2[] = "empty-string";
+  static const char kValue2[] = "";
+  ASSERT_TRUE(store_.Open());
+  ASSERT_TRUE(store_.SetString(kGroup, kKey1, kValue1));
+  ASSERT_TRUE(store_.SetString(kGroup, kKey2, kValue2));
+  ASSERT_TRUE(store_.Close());
+  EXPECT_EQ(base::StringPrintf("\n"
+                               "[%s]\n"
+                               "%s=%s\n"
+                               "%s=%s\n",
+                               kGroup, kKey1, kValue1, kKey2, kValue2),
+            ReadKeyFile());
+}
+
+TEST_F(KeyFileStoreTest, GetBool) {
+  static const char kGroup[] = "boo";
+  static const char kKeyTrue[] = "foo";
+  static const char kKeyFalse[] = "bar";
+  static const char kKeyBad[] = "zoo";
+  WriteKeyFile(base::StringPrintf("[%s]\n"
+                                  "%s=true\n"
+                                  "%s=false\n"
+                                  "%s=moo\n",
+                                  kGroup, kKeyTrue, kKeyFalse, kKeyBad));
+  ASSERT_TRUE(store_.Open());
+  {
+    bool value = true;
+    EXPECT_TRUE(store_.GetBool(kGroup, kKeyFalse, &value));
+    EXPECT_FALSE(value);
+  }
+  {
+    bool value = false;
+    EXPECT_TRUE(store_.GetBool(kGroup, kKeyTrue, &value));
+    EXPECT_TRUE(value);
+  }
+  {
+    bool value;
+    EXPECT_FALSE(store_.GetBool(kGroup, kKeyBad, &value));
+    EXPECT_FALSE(store_.GetBool(kGroup, "unknown", &value));
+    EXPECT_FALSE(store_.GetBool("unknown", kKeyTrue, &value));
+  }
+  EXPECT_TRUE(store_.GetBool(kGroup, kKeyFalse, NULL));
+  ASSERT_TRUE(store_.Close());
+}
+
+TEST_F(KeyFileStoreTest, SetBool) {
+  static const char kGroup[] = "bool-group";
+  static const char kKeyTrue[] = "test-true-bool";
+  static const char kKeyFalse[] = "test-false-bool";
+  ASSERT_TRUE(store_.Open());
+  ASSERT_TRUE(store_.SetBool(kGroup, kKeyTrue, true));
+  ASSERT_TRUE(store_.SetBool(kGroup, kKeyFalse, false));
+  ASSERT_TRUE(store_.Close());
+  EXPECT_EQ(base::StringPrintf("\n"
+                               "[%s]\n"
+                               "%s=true\n"
+                               "%s=false\n",
+                               kGroup, kKeyTrue, kKeyFalse),
+            ReadKeyFile());
+}
+
+TEST_F(KeyFileStoreTest, GetInt) {
+  static const char kGroup[] = "numbers";
+  static const char kKeyPos[] = "pos";
+  static const char kKeyNeg[] = "neg";
+  static const char kKeyBad[] = "bad";
+  const int kValuePos = 50;
+  const int kValueNeg = -20;
+  static const char kValueBad[] = "nan";
+  WriteKeyFile(base::StringPrintf("[%s]\n"
+                                  "%s=%d\n"
+                                  "%s=%d\n"
+                                  "%s=%s\n",
+                                  kGroup,
+                                  kKeyPos, kValuePos,
+                                  kKeyNeg, kValueNeg,
+                                  kKeyBad, kValueBad));
+  ASSERT_TRUE(store_.Open());
+  {
+    int value = 0;
+    EXPECT_TRUE(store_.GetInt(kGroup, kKeyNeg, &value));
+    EXPECT_EQ(kValueNeg, value);
+  }
+  {
+    int value = 0;
+    EXPECT_TRUE(store_.GetInt(kGroup, kKeyPos, &value));
+    EXPECT_EQ(kValuePos, value);
+  }
+  {
+    int value;
+    EXPECT_FALSE(store_.GetInt(kGroup, kKeyBad, &value));
+    EXPECT_FALSE(store_.GetInt(kGroup, "invalid", &value));
+    EXPECT_FALSE(store_.GetInt("invalid", kKeyPos, &value));
+  }
+  EXPECT_TRUE(store_.GetInt(kGroup, kKeyPos, NULL));
+  ASSERT_TRUE(store_.Close());
+}
+
+TEST_F(KeyFileStoreTest, SetInt) {
+  static const char kGroup[] = "int-group";
+  static const char kKey1[] = "test-int";
+  static const char kKey2[] = "test-negative";
+  const int kValue1 = 5;
+  const int kValue2 = -10;
+  ASSERT_TRUE(store_.Open());
+  ASSERT_TRUE(store_.SetInt(kGroup, kKey1, kValue1));
+  ASSERT_TRUE(store_.SetInt(kGroup, kKey2, kValue2));
+  ASSERT_TRUE(store_.Close());
+  EXPECT_EQ(base::StringPrintf("\n"
+                               "[%s]\n"
+                               "%s=%d\n"
+                               "%s=%d\n",
+                               kGroup, kKey1, kValue1, kKey2, kValue2),
+            ReadKeyFile());
+}
+
+TEST_F(KeyFileStoreTest, Combo) {
+  static const char kGroupA[] = "square";
+  static const char kGroupB[] = "circle";
+  static const char kGroupC[] = "triangle";
+  static const char kGroupX[] = "pentagon";
+  static const char kKeyString[] = "color";
+  static const char kKeyInt[] = "area";
+  static const char kKeyBool[] = "visible";
+  static const char kValueStringA[] = "blue";
+  static const char kValueStringB[] = "red";
+  static const char kValueStringC[] = "yellow";
+  static const char kValueStringCNew[] = "purple";
+  const int kValueIntA = 5;
+  const int kValueIntB = 10;
+  const int kValueIntBNew = 333;
+  WriteKeyFile(base::StringPrintf("[%s]\n"
+                                  "%s=%s\n"
+                                  "%s=%d\n"
+                                  "[%s]\n"
+                                  "%s=%s\n"
+                                  "%s=%d\n"
+                                  "%s=true\n"
+                                  "[%s]\n"
+                                  "%s=%s\n"
+                                  "%s=false\n",
+                                  kGroupA,
+                                  kKeyString, kValueStringA,
+                                  kKeyInt, kValueIntA,
+                                  kGroupB,
+                                  kKeyString, kValueStringB,
+                                  kKeyInt, kValueIntB,
+                                  kKeyBool,
+                                  kGroupC,
+                                  kKeyString, kValueStringC,
+                                  kKeyBool));
+  ASSERT_TRUE(store_.Open());
+
+  EXPECT_TRUE(store_.ContainsGroup(kGroupA));
+  EXPECT_TRUE(store_.ContainsGroup(kGroupB));
+  EXPECT_TRUE(store_.ContainsGroup(kGroupC));
+  EXPECT_FALSE(store_.ContainsGroup(kGroupX));
+
+  set<string> groups = store_.GetGroups();
+  EXPECT_EQ(3, groups.size());
+  EXPECT_TRUE(ContainsKey(groups, kGroupA));
+  EXPECT_TRUE(ContainsKey(groups, kGroupB));
+  EXPECT_TRUE(ContainsKey(groups, kGroupC));
+  EXPECT_FALSE(ContainsKey(groups, kGroupX));
+
+  {
+    string value;
+    EXPECT_TRUE(store_.GetString(kGroupB, kKeyString, &value));
+    EXPECT_EQ(kValueStringB, value);
+    EXPECT_TRUE(store_.GetString(kGroupA, kKeyString, &value));
+    EXPECT_EQ(kValueStringA, value);
+    EXPECT_TRUE(store_.GetString(kGroupC, kKeyString, &value));
+    EXPECT_EQ(kValueStringC, value);
+  }
+  {
+    int value = 0;
+    EXPECT_TRUE(store_.GetInt(kGroupB, kKeyInt, &value));
+    EXPECT_EQ(kValueIntB, value);
+    EXPECT_TRUE(store_.GetInt(kGroupA, kKeyInt, &value));
+    EXPECT_EQ(kValueIntA, value);
+    EXPECT_FALSE(store_.GetInt(kGroupC, kKeyInt, &value));
+  }
+  {
+    bool value = false;
+    EXPECT_TRUE(store_.GetBool(kGroupB, kKeyBool, &value));
+    EXPECT_TRUE(value);
+    EXPECT_TRUE(store_.GetBool(kGroupC, kKeyBool, &value));
+    EXPECT_FALSE(value);
+    EXPECT_FALSE(store_.GetBool(kGroupA, kKeyBool, &value));
+  }
+
+  EXPECT_TRUE(store_.DeleteGroup(kGroupA));
+  EXPECT_FALSE(store_.DeleteGroup(kGroupA));
+
+  EXPECT_FALSE(store_.ContainsGroup(kGroupA));
+  EXPECT_TRUE(store_.ContainsGroup(kGroupB));
+  EXPECT_TRUE(store_.ContainsGroup(kGroupC));
+
+  groups = store_.GetGroups();
+  EXPECT_EQ(2, groups.size());
+  EXPECT_FALSE(ContainsKey(groups, kGroupA));
+  EXPECT_TRUE(ContainsKey(groups, kGroupB));
+  EXPECT_TRUE(ContainsKey(groups, kGroupC));
+
+  EXPECT_TRUE(store_.SetBool(kGroupB, kKeyBool, false));
+  EXPECT_TRUE(store_.SetInt(kGroupB, kKeyInt, kValueIntBNew));
+  EXPECT_TRUE(store_.SetString(kGroupC, kKeyString, kValueStringCNew));
+
+  EXPECT_TRUE(store_.DeleteKey(kGroupB, kKeyString));
+  EXPECT_FALSE(store_.DeleteKey(kGroupB, kKeyString));
+
+  {
+    string value;
+    EXPECT_FALSE(store_.GetString(kGroupB, kKeyString, &value));
+    EXPECT_FALSE(store_.GetString(kGroupA, kKeyString, &value));
+    EXPECT_TRUE(store_.GetString(kGroupC, kKeyString, &value));
+    EXPECT_EQ(kValueStringCNew, value);
+  }
+
+  {
+    int value = 0;
+    EXPECT_TRUE(store_.GetInt(kGroupB, kKeyInt, &value));
+    EXPECT_EQ(kValueIntBNew, value);
+    EXPECT_FALSE(store_.GetInt(kGroupA, kKeyInt, &value));
+    EXPECT_FALSE(store_.GetInt(kGroupC, kKeyInt, &value));
+  }
+
+  {
+    bool value = false;
+    EXPECT_TRUE(store_.GetBool(kGroupB, kKeyBool, &value));
+    EXPECT_FALSE(value);
+    EXPECT_TRUE(store_.GetBool(kGroupC, kKeyBool, &value));
+    EXPECT_FALSE(value);
+    EXPECT_FALSE(store_.GetBool(kGroupA, kKeyBool, &value));
+  }
+
+  ASSERT_TRUE(store_.Close());
+  EXPECT_EQ(base::StringPrintf("\n"
+                               "[%s]\n"
+                               "%s=%d\n"
+                               "%s=false\n"
+                               "\n"
+                               "[%s]\n"
+                               "%s=%s\n"
+                               "%s=false\n",
+                               kGroupB,
+                               kKeyInt, kValueIntBNew,
+                               kKeyBool,
+                               kGroupC,
+                               kKeyString, kValueStringCNew,
+                               kKeyBool),
+            ReadKeyFile());
+}
+
+}  // namespace shill