#include "StarJson.hpp"
#include "StarFile.hpp"
#include "StarJsonPatch.hpp"
#include "StarJsonPath.hpp"

#include "gtest/gtest.h"

using namespace Star;

TEST(JsonTest, ImplicitSharing) {
  Json map1 = JsonObject{{"foo", 1}, {"bar", 10}};

  Json map2 = JsonObject{{"foo", 5}, {"bar", 50}};

  std::swap(map1, map2);
  Json map3 = map1;
  map1 = map2;
  map2 = map3;

  EXPECT_EQ(map1.get("foo"), 1);
  EXPECT_EQ(map2.get("bar"), 50);
}

TEST(JsonTest, Defaults) {
  Json obj = JsonObject{{"null", Json()}};
  Json arr = JsonArray{"array", JsonArray{Json(), Json()}};

  EXPECT_EQ(obj.getInt("null", 5), 5);
  EXPECT_EQ(arr.getInt(2, 5), 5);
  EXPECT_EQ(arr.getInt(3, 5), 5);
  EXPECT_THROW(arr.getInt(2), JsonException);
}

TEST(JsonTest, Merging) {
  JsonObject a{{"I", "feel"}, {"friendly", "now"}};
  JsonObject b{{"hello", "there"}, {"leg", "friend"}};
  JsonObject c{{"hello", "you"}, {"leg", "fiend"}};
  JsonObject d{{"goodbye", "you"}, {"friendly", "leg"}};

  Json merged = jsonMerge(a, b, c, d);

  EXPECT_EQ(merged.get("I"), "feel");
  EXPECT_EQ(merged.get("hello"), "you");
  EXPECT_EQ(merged.get("friendly"), "leg");
  EXPECT_EQ(merged.get("leg"), "fiend");

  Json e = JsonObject();
  e = e.set("1", 2);
  e = e.setAll({{"a", "b"}, {"c", "d"}});
  Json f = JsonObject{{"1", 2}, {"a", "b"}, {"c", "d"}};

  EXPECT_EQ(e, f);

  Json g = JsonObject{{"a", "a"}, {"sub", JsonObject()}};
  g = g.setPath("sub.field", 1);
  g = g.setPath("sub.field2", 2);
  g = g.erasePath("sub.field2");
  Json h = JsonObject{{"a", "a"}, {"sub", JsonObject{{"field", 1}}}};
  EXPECT_EQ(g, h);
}

TEST(JsonTest, Unicode) {
  Json v = Json::parse("{ \"first\" : \"日本語\", \"second\" : \"foobar\\u0019\" }");
  EXPECT_EQ(v.getString("first"), String("日本語"));
  EXPECT_EQ(v.get("second").repr(), String("\"foobar\\u0019\""));

  String json = v.printJson();
  Json v2 = Json::parseJson(json);
  EXPECT_EQ(v2.getString("first"), String("日本語"));

  EXPECT_EQ(v, v2);

  EXPECT_EQ(Json("😀"), Json::parse("\"\\ud83d\\ude00\""));
  EXPECT_EQ(Json::parse("\"\\ud83d\\ude00\"").toString().size(), 1u);
}

TEST(JsonTest, UnicodeFile) {
  Json v = Json::parse("{ \"first\" : \"日本語\", \"second\" : \"foobar\\u0019\" }");
  EXPECT_EQ(v.getString("first"), String("日本語"));
  EXPECT_EQ(v.get("second").repr(), String("\"foobar\\u0019\""));

  String file = File::temporaryFileName();
  auto finallyGuard = finally([&file]() { File::remove(file); });

  File::writeFile(v.printJson(), file);
  Json v2 = Json::parseJson(File::readFileString(file));
  EXPECT_EQ(v2.getString("first"), "日本語");

  EXPECT_EQ(v, v2);
}

TEST(JsonTest, JsonParsingEdge) {
  auto isValidFragment = [](String const& json) -> bool {
    try {
      Json::parse(json);
      return true;
    } catch (JsonParsingException const&) {
      return false;
    }
  };

  auto isValidJson = [](String const& json) -> bool {
    try {
      Json::parseJson(json);
      return true;
    } catch (JsonParsingException const&) {
      return false;
    }
  };

  EXPECT_TRUE(isValidFragment(" \t 0.0 "));
  EXPECT_TRUE(isValidFragment("-0.0\t "));
  EXPECT_FALSE(isValidFragment("-.0"));
  EXPECT_FALSE(isValidFragment("00.0"));

  EXPECT_FALSE(isValidJson(" 0.0"));
  EXPECT_FALSE(isValidJson("true"));
  EXPECT_TRUE(isValidJson("\t[]"));
  EXPECT_TRUE(isValidJson(" {} "));
}

TEST(JsonTest, Types) {
  Json v;
  EXPECT_EQ(v.type(), Json::Type::Null);
  v = 0;
  EXPECT_EQ(v.type(), Json::Type::Int);
  v = 0.0;
  EXPECT_EQ(v.type(), Json::Type::Float);
  v = true;
  EXPECT_EQ(v.type(), Json::Type::Bool);
  v = "";
  EXPECT_EQ(v.type(), Json::Type::String);
  v = JsonArray();
  EXPECT_EQ(v.type(), Json::Type::Array);
  v = JsonObject();
  EXPECT_EQ(v.type(), Json::Type::Object);
}

TEST(JsonTest, Query) {
  Json v = Json::parse(R"JSON(
      {
        "foo" : "bar",
        "baz" : {
          "baf" : [1, 2],
          "bal" : 2
        },

        "baf" : null
      }
    )JSON");

  EXPECT_EQ(v.query("foo"), Json("bar"));
  EXPECT_EQ(v.query("baz.baf[1]"), Json(2));
  EXPECT_EQ(v.query("baz.bal"), Json(2));
  EXPECT_EQ(v.query("blargh", Json("default")), Json("default"));
  EXPECT_EQ(v.query("blargh", Json("default")), Json("default"));
  EXPECT_EQ(v.query("baz.baf[3]", Json("default")), Json("default"));
  EXPECT_EQ(v.query("baz.bal[0]", Json("default")), Json("default"));
  EXPECT_EQ(v.query("baz[1]", Json("default")), Json("default"));
  EXPECT_EQ(v.query("baz.bal.a", Json("default")), Json("default"));
  EXPECT_EQ(v.query("baz[0]", Json("default")), Json("default"));
  EXPECT_EQ(v.query("baz.baf.a", Json("default")), Json("default"));
  EXPECT_THROW(v.query("blargh"), JsonPath::TraversalException);
  EXPECT_THROW(v.query("baz.funk"), JsonPath::TraversalException);
  EXPECT_THROW(v.query("baz.baf[3]"), JsonPath::TraversalException);
  EXPECT_THROW(v.query("baz.baf[whee]", Json()), JsonPath::ParsingException);
  EXPECT_THROW(v.query("baz.baf[[]", Json()), JsonPath::ParsingException);
  EXPECT_THROW(v.query("baz..baf", Json()), JsonPath::ParsingException);
  EXPECT_THROW(v.query("baf.nothing"), JsonException);
}

TEST(JsonTest, PatchingAdd) {
  Json before = Json::parse(R"JSON(
      {
        "foo" : "bar",
        "baz" : {
          "baf" : 1,
          "bal" : 2
        },
        "rab" : [0, 1, 2, "foo", false]
      }
    )JSON");

  Json after = Json::parse(R"JSON(
      {
        "foo" : "xyzzy",
        "bar" : "foo",
        "baz" : {
          "baf" : 1,
          "bal" : 2,
          "0" : "derp",
          "rebar" : {
            "after" : "party"
          }
        },
        "rab" : [0, 0, 1, 2, "foo", false, true, { "baz" : "bar"} ]
      }
    )JSON");

  Json patch = Json::parse(R"JSON(
      [
        {"op" : "add", "path" : "/foo", "value" : "xyzzy"},
        {"op" : "add", "path" : "/bar", "value" : "foo"},
        {"op" : "add", "path" : "/baz/rebar", "value" : {}},
        {"op" : "add", "path" : "/baz/rebar/after", "value" : "party"},
        {"op" : "add", "path" : "/baz/0", "value" : "derp"},
        {"op" : "add", "path" : "/rab/0", "value" : 0},
        {"op" : "add", "path" : "/rab/6", "value" : true},
        {"op" : "add", "path" : "/rab/-", "value" : {"baz" : "bar"} }
      ]
  )JSON");

  // Past end of list
  Json badPatch1 = Json::parse(R"JSON(
      [
        {"op" : "add", "path" : "/rab/6", "value" : {"baz" : "bar"} }
      ]
  )JSON");

  // Parent does not exist, map
  Json badPatch2 = Json::parse(R"JSON(
      [
        {"op" : "add", "path" : "/bar/baz", "value" : {"baz" : "bar"} }
      ]
  )JSON");

  // Parent does not exist, list
  Json badPatch3 = Json::parse(R"JSON(
      [
        {"op" : "add", "path" : "/bar/0", "value" : {"baz" : "bar"} }
      ]
  )JSON");

  EXPECT_EQ(jsonPatch(before, patch.toArray()), after);
  ASSERT_THROW(jsonPatch(before, badPatch1.toArray()), JsonPatchException);
  ASSERT_THROW(jsonPatch(before, badPatch2.toArray()), JsonPatchException);
  ASSERT_THROW(jsonPatch(before, badPatch3.toArray()), JsonPatchException);
}

TEST(JsonTest, PatchingRemove) {
  Json before = Json::parse(R"JSON(
      {
        "foo" : "xyzzy",
        "bar" : "foo",
        "baz" : {
          "baf" : 1,
          "bal" : 2,
          "rebar" : true
        },
        "rab" : [0, 0, 1, 2, "foo", false, {"baz" : "bar"} ]
      }
    )JSON");

  Json after = Json::parse(R"JSON(
      {
        "bar" : "foo",
        "baz" : {
          "baf" : 1,
          "bal" : 2
        },
        "rab" : [0, 1, 2, "foo", false]
      }
    )JSON");

  Json patch = Json::parse(R"JSON(
      [
        {"op" : "remove", "path" : "/foo"},
        {"op" : "remove", "path" : "/baz/rebar"},
        {"op" : "remove", "path" : "/rab/0"},
        {"op" : "remove", "path" : "/rab/5"}
      ]
  )JSON");

  // Removing end of list
  Json badPatch1 = Json::parse(R"JSON(
      [
        {"op" : "remove", "path" : "/rab/-"}
      ]
  )JSON");

  // Removing past end of list
  Json badPatch2 = Json::parse(R"JSON(
      [
        {"op" : "add", "path" : "/rab/7"}
      ]
  )JSON");

  // Path wrong type
  Json badPatch3 = Json::parse(R"JSON(
      [
        {"op" : "remove", "path" : "/bar/baz"}
      ]
  )JSON");

  EXPECT_EQ(jsonPatch(before, patch.toArray()), after);
  ASSERT_THROW(jsonPatch(before, badPatch1.toArray()), JsonPatchException);
  ASSERT_THROW(jsonPatch(before, badPatch2.toArray()), JsonPatchException);
  ASSERT_THROW(jsonPatch(before, badPatch3.toArray()), JsonPatchException);
}

TEST(JsonTest, PatchingReplace) {
  Json before = Json::parse(R"JSON(
      {
        "foo" : "bar",
        "bar" : {
          "baf" : 1,
          "bal" : 2
        },
        "baz" : {
          "baf" : 1,
          "bal" : 2
        },
        "rab" : [0, 1, 2, "foo", false],
        "rabby" : [0, 1, 2, "foo", false]
      }
    )JSON");

  Json after = Json::parse(R"JSON(
      {
        "foo" : "xyzzy",
        "bar" : [3, 2, 1, "contact"],
        "baz" : {
          "baf" : 1,
          "bal" : "touched"
        },
        "rab" : [{"omg" : "no"}, 1, 2, "foo", false],
        "rabby" : false
      }
    )JSON");

  Json patch = Json::parse(R"JSON(
      [
        {"op" : "replace", "path" : "/foo", "value" : "xyzzy"},
        {"op" : "replace", "path" : "/bar", "value" : [3, 2, 1, "contact"]},
        {"op" : "replace", "path" : "/baz/bal", "value" : "touched"},
        {"op" : "replace", "path" : "/rab/0", "value" : {"omg" : "yes"}},
        {"op" : "replace", "path" : "/rab/0/omg", "value" : "no"},
        {"op" : "replace", "path" : "/rab/2", "value" : 2},
        {"op" : "replace", "path" : "/rabby", "value" : false}
      ]
  )JSON");

  // End of list
  Json badPatch1 = Json::parse(R"JSON(
      [
        {"op" : "replace", "path" : "/rab/-", "value" : {"baz" : "bar"} }
      ]
  )JSON");

  // Past end of list
  Json badPatch2 = Json::parse(R"JSON(
      [
        {"op" : "replace", "path" : "/rab/5", "value" : {"baz" : "bar"} }
      ]
  )JSON");

  // Key does not exist
  Json badPatch3 = Json::parse(R"JSON(
      [
        {"op" : "replace", "path" : "/bar/baz", "value" : {"baz" : "bar"} }
      ]
  )JSON");

  EXPECT_EQ(jsonPatch(before, patch.toArray()), after);
  ASSERT_THROW(jsonPatch(before, badPatch1.toArray()), JsonPatchException);
  ASSERT_THROW(jsonPatch(before, badPatch2.toArray()), JsonPatchException);
  ASSERT_THROW(jsonPatch(before, badPatch3.toArray()), JsonPatchException);
}

TEST(JsonTest, PatchingMove) {
  Json before = Json::parse(R"JSON(
      {
        "foo" : "bar",
        "bar" : [1, 2, 3, "contact"],
        "baz" : {
          "baf" : 1,
          "bar" : 2
        },
        "rab" : [0, 1, 2, "foo", false],
        "rabby" : [0, 1, 2, "foo", true]
      }
    )JSON");

  Json after = Json::parse(R"JSON(
      {
        "foot" : "bar",
        "baz" : {
          "baf" : 1,
          "bar" : [3, 2, 1, "contact"]
        },
        "bar" : 2,
        "rab" : [0, 1, 2, true, "foo"]
      }
    )JSON");

  Json patch = Json::parse(R"JSON(
      [
        {"op" : "move", "from" : "/foo", "path" : "/foot"},
        {"op" : "move", "from" : "/bar", "path" : "/baz/bal"},
        {"op" : "move", "from" : "/baz/bar", "path" : "/bar"},
        {"op" : "move", "from" : "/baz/bal", "path" : "/baz/bar"},
        {"op" : "move", "from" : "/baz/bar/0", "path" : "/baz/bar/1"},
        {"op" : "move", "from" : "/baz/bar/2", "path" : "/baz/bar/0"},
        {"op" : "move", "from" : "/rabby", "path" : "/rab"},
        {"op" : "move", "from" : "/rab/3", "path" : "/rab/-"}
      ]
  )JSON");

  // From end of list
  Json badPatch1 = Json::parse(R"JSON(
      [
        {"op" : "move", "from" : "/rab/-", "path" : "/doesnotmatter"}
      ]
  )JSON");

  // From past end of list
  Json badPatch2 = Json::parse(R"JSON(
      [
        {"op" : "move", "from" : "/rab/5", "path" : "/doesnotmatter"}
      ]
  )JSON");

  // To past end of list
  Json badPatch3 = Json::parse(R"JSON(
      [
        {"op" : "move", "from" : "/rab/0", "path" : "/rab/5"}
      ]
  )JSON");

  // Source path does not exist
  Json badPatch4 = Json::parse(R"JSON(
      [
        {"op" : "move", "from" : "/omgomg", "path" : "/doesntmatter"}
      ]
  )JSON");

  // Dest path wrong type
  Json badPatch5 = Json::parse(R"JSON(
      [
        {"op" : "move", "from" : "/baz/bar", "path" : "/rabby/bar"}
      ]
  )JSON");

  EXPECT_EQ(jsonPatch(before, patch.toArray()), after);
  ASSERT_THROW(jsonPatch(before, badPatch1.toArray()), JsonPatchException);
  ASSERT_THROW(jsonPatch(before, badPatch2.toArray()), JsonPatchException);
  ASSERT_THROW(jsonPatch(before, badPatch3.toArray()), JsonPatchException);
  ASSERT_THROW(jsonPatch(before, badPatch4.toArray()), JsonPatchException);
  ASSERT_THROW(jsonPatch(before, badPatch5.toArray()), JsonPatchException);
}

TEST(JsonTest, PatchingCopy) {
  Json before = Json::parse(R"JSON(
      {
        "foo" : "bar",
        "foot" : "bar",
        "bar" : [1, 2, 3, "contact"],
        "baz" : {
          "baf" : 1,
          "bar" : 2
        },
        "rab" : [0, 1, 2, "foo", false],
        "rabby" : [0, 1, 2, "foo", true]
      }
    )JSON");

  Json after = Json::parse(R"JSON(
      {
        "foo" : "bar",
        "foot" : "bar",
        "baz" : {
          "baf" : 1,
          "bar" : [2, 1, 1, 2, 3, "contact"],
          "bal" : [1, 2, 3, "contact"]
        },
        "bar" : 2,
        "rab" : [0, 1, 2, "foo", true, "foo"],
        "rabby" : [0, 1, 2, "foo", true]
      }
    )JSON");

  Json patch = Json::parse(R"JSON(
      [
        {"op" : "copy", "from" : "/foo", "path" : "/foot"},
        {"op" : "copy", "from" : "/bar", "path" : "/baz/bal"},
        {"op" : "copy", "from" : "/baz/bar", "path" : "/bar"},
        {"op" : "copy", "from" : "/baz/bal", "path" : "/baz/bar"},
        {"op" : "copy", "from" : "/baz/bar/0", "path" : "/baz/bar/1"},
        {"op" : "copy", "from" : "/baz/bar/2", "path" : "/baz/bar/0"},
        {"op" : "copy", "from" : "/rabby", "path" : "/rab"},
        {"op" : "copy", "from" : "/rab/3", "path" : "/rab/-"}
      ]
  )JSON");

  // From end of list
  Json badPatch1 = Json::parse(R"JSON(
      [
        {"op" : "copy", "from" : "/rab/-", "path" : "/doesnotmatter"}
      ]
  )JSON");

  // From past end of list
  Json badPatch2 = Json::parse(R"JSON(
      [
        {"op" : "copy", "from" : "/rab/5", "path" : "/doesnotmatter"}
      ]
  )JSON");

  // To past end of list
  Json badPatch3 = Json::parse(R"JSON(
      [
        {"op" : "copy", "from" : "/rab/0", "path" : "/rab/6"}
      ]
  )JSON");

  // Source path does not exist
  Json badPatch4 = Json::parse(R"JSON(
      [
        {"op" : "copy", "from" : "/omgomg", "path" : "/doesntmatter"}
      ]
  )JSON");

  // Dest path wrong type
  Json badPatch5 = Json::parse(R"JSON(
      [
        {"op" : "copy", "from" : "/baz/bar", "path" : "/rabby/bar"}
      ]
  )JSON");

  EXPECT_EQ(jsonPatch(before, patch.toArray()), after);
  ASSERT_THROW(jsonPatch(before, badPatch1.toArray()), JsonPatchException);
  ASSERT_THROW(jsonPatch(before, badPatch2.toArray()), JsonPatchException);
  ASSERT_THROW(jsonPatch(before, badPatch3.toArray()), JsonPatchException);
  ASSERT_THROW(jsonPatch(before, badPatch4.toArray()), JsonPatchException);
  ASSERT_THROW(jsonPatch(before, badPatch5.toArray()), JsonPatchException);
}

TEST(JsonTest, PatchingTest) {
  Json base = Json::parse(R"JSON(
      {
        "foo" : "bar",
        "foot" : "bart",
        "bar" : [1, 2, 3, "contact"],
        "baz" : {
          "baf" : 1,
          "bar" : 2,
          "0" : 3
        }
      }
    )JSON");

  Json goodTest = Json::parse(R"JSON(
      [
        {"op" : "test", "path" : "/foo", "value" : "bar"},
        {"op" : "test", "path" : "/foo", "value" : "bark", "inverse" : true},
        {"op" : "test", "path" : "/foot", "value" : "bart"},
        {"op" : "test", "path" : "/bar", "value" : [1, 2, 3, "contact"]},
        {"op" : "test", "path" : "/bar/0", "value" : 1},
        {"op" : "test", "path" : "/bar/1", "value" : 2},
        {"op" : "test", "path" : "/bar/2", "value" : 3},
        {"op" : "test", "path" : "/bar/3", "value" : "contact"},
        {"op" : "test", "path" : "/baz", "value" : {"0" : 3, "baf" : 1, "bar" : 2}},
        {"op" : "test", "path" : "/baz/baf", "value" : 1},
        {"op" : "test", "path" : "/baz/bar", "value" : 2},
        {"op" : "test", "path" : "/baz/0", "value" : 3},
        {"op" : "test", "path" : "/nothere", "inverse" : true},
        {"op" : "test", "path" : "/foo" }
      ]
  )JSON");

  Json failTest1 = Json::parse(R"JSON(
      [
        {"op" : "test", "path" : "/bar", "value" : [1, 3, 2, "contact"]}
      ]
  )JSON");

  Json failTest2 = Json::parse(R"JSON(
      [
        {"op" : "test", "path" : "/bar/-", "value" : "contact"}
      ]
  )JSON");

  Json failTest3 = Json::parse(R"JSON(
      [
        {"op" : "test", "path" : "/xyzzy", "value" : null}
      ]
  )JSON");

  Json failTest4 = Json::parse(R"JSON(
      [
        {"op" : "test", "path" : "/xyzzy/zop", "value" : null}
      ]
  )JSON");

  Json failTest5 = Json::parse(R"JSON(
      [
        {"op" : "test", "path" : "/nothere" }
      ]
  )JSON");

  Json failTest6 = Json::parse(R"JSON(
      [
        {"op" : "test", "path" : "/bar", "inverse" : true }
      ]
  )JSON");

  Json failTest7 = Json::parse(R"JSON(
      [
        {"op" : "test", "path" : "/foo", "value" : "bar", "inverse" : true }
      ]
  )JSON");

  jsonPatch(base, goodTest.toArray());

  ASSERT_THROW(jsonPatch(base, failTest1.toArray()), JsonPatchTestFail);
  ASSERT_THROW(jsonPatch(base, failTest2.toArray()), JsonPatchTestFail);
  ASSERT_THROW(jsonPatch(base, failTest3.toArray()), JsonPatchTestFail);
  ASSERT_THROW(jsonPatch(base, failTest4.toArray()), JsonPatchTestFail);
  ASSERT_THROW(jsonPatch(base, failTest5.toArray()), JsonPatchTestFail);
  ASSERT_THROW(jsonPatch(base, failTest6.toArray()), JsonPatchTestFail);
  ASSERT_THROW(jsonPatch(base, failTest7.toArray()), JsonPatchTestFail);
}

TEST(JsonTest, PatchingEscaping) {
  Json base1 = Json::parse(R"JSON(
      {
        "~" : true,
        "/" : false,
        "~~0" : "foo",
        "~~1" : "bar",
        "~~0~1/~0~" : "ugh"
      }
  )JSON");

  Json test1 = Json::parse(R"JSON(
      [
        {"op" : "test", "path" : "/~0", "value" : true},
        {"op" : "test", "path" : "/~1", "value" : false},
        {"op" : "test", "path" : "/~0~00", "value" : "foo"},
        {"op" : "test", "path" : "/~0~01", "value" : "bar"},
        {"op" : "test", "path" : "/~0~00~01~1~00~0", "value" : "ugh"}
      ]
  )JSON");

  jsonPatch(base1, test1.toArray());
}

TEST(JsonTest, MergeQuery) {
  Json json1 = Json::parse(R"JSON(
      {
        "foo" : "foo1",
        "bar" : "bar1",
        "baz" : {
          "1" : "1"
        },
        "fob" : {},
        "fizz" : 4
      }
    )JSON");
  Json json2 = Json::parse(R"JSON(
      {
        "foo" : "foo2",
        "bar" : "bar2",
        "baz" : null,
        "baf" : {
          "2" : "2"
        },
        "fob" : 2
      }
    )JSON");
  Json json3 = Json::parse(R"JSON(
      {
        "baz" : {
          "3" : "3"
        },
        "baf" : {
          "3" : "3"
        },
        "fizz" : {
        }
      }
    )JSON");

  auto testIdentical = [&](String const& key) {
    EXPECT_EQ(jsonMergeQuery(key, json1, json2, json3), jsonMerge(json1, json2, json3).query(key, {}));
  };

  testIdentical("foo");
  testIdentical("bar");
  testIdentical("baz");
  testIdentical("baf");
  testIdentical("baz.1");
  testIdentical("baz.2");
  testIdentical("baz.3");
  testIdentical("baf.0");
  testIdentical("baf.2");
  testIdentical("baf.3");
  testIdentical("baz.blip");
  testIdentical("boo.blip");
  testIdentical("fob");
  testIdentical("fiz");
  testIdentical("nothing");
}