rocksdb

0.18.0
3.1.1 3.1.0 3.0.0 2.6.2 2.6.1 retired 2.6.0 retired 2.5.0 2.4.1 2.4.0 2.3.0 2.2.0 2.1.0 2.0.0 1.9.0 1.8.0 1.7.0 1.6.0 1.5.1 1.5.0 1.4.0 1.3.2 1.3.1 1.3.0 1.2.0 1.1.1 1.1.0 1.0.0 0.26.2 0.26.1 0.26.0 0.25.0 0.24.0 0.23.3 0.23.2 0.23.1 0.23.0 0.22.0 0.21.0 0.20.1 0.20.0 0.19.0 0.18.0 0.17.0 0.16.0 0.15.0 0.14.0 0.13.1 0.13.0 0.12.0 0.11.0 0.10.0 0.9.1 0.9.0 0.8.2 0.8.1 0.8.0 0.7.1 0.7.0 0.6.4 0.6.3 0.6.2 0.6.1 0.6.0
RocksDB for Erlang
HexDocs
Current section
Files
Jump to
Readme 63 Versions 0 Dependencies Dependants Files Activity
rocksdb deps rocksdb utilities document json_document_test.cc
Raw
deps/rocksdb/utilities/document/json_document_test.cc

//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
//  This source code is licensed under both the GPLv2 (found in the
//  COPYING file in the root directory) and Apache 2.0 License
//  (found in the LICENSE.Apache file in the root directory).

#ifndef ROCKSDB_LITE

#include <map>
#include <set>
#include <string>

#include "rocksdb/utilities/json_document.h"

#include "util/testutil.h"
#include "util/testharness.h"

namespace rocksdb {
namespace {
void AssertField(const JSONDocument& json, const std::string& field) {
  ASSERT_TRUE(json.Contains(field));
  ASSERT_TRUE(json[field].IsNull());
}

void AssertField(const JSONDocument& json, const std::string& field,
                 const std::string& expected) {
  ASSERT_TRUE(json.Contains(field));
  ASSERT_TRUE(json[field].IsString());
  ASSERT_EQ(expected, json[field].GetString());
}

void AssertField(const JSONDocument& json, const std::string& field,
                 int64_t expected) {
  ASSERT_TRUE(json.Contains(field));
  ASSERT_TRUE(json[field].IsInt64());
  ASSERT_EQ(expected, json[field].GetInt64());
}

void AssertField(const JSONDocument& json, const std::string& field,
                 bool expected) {
  ASSERT_TRUE(json.Contains(field));
  ASSERT_TRUE(json[field].IsBool());
  ASSERT_EQ(expected, json[field].GetBool());
}

void AssertField(const JSONDocument& json, const std::string& field,
                 double expected) {
  ASSERT_TRUE(json.Contains(field));
  ASSERT_TRUE(json[field].IsDouble());
  ASSERT_DOUBLE_EQ(expected, json[field].GetDouble());
}
}  // namespace

class JSONDocumentTest : public testing::Test {
 public:
  JSONDocumentTest()
  : rnd_(101)
  {}

  void AssertSampleJSON(const JSONDocument& json) {
    AssertField(json, "title", std::string("json"));
    AssertField(json, "type", std::string("object"));
    // properties
    ASSERT_TRUE(json.Contains("properties"));
    ASSERT_TRUE(json["properties"].Contains("flags"));
    ASSERT_TRUE(json["properties"]["flags"].IsArray());
    ASSERT_EQ(3u, json["properties"]["flags"].Count());
    ASSERT_TRUE(json["properties"]["flags"][0].IsInt64());
    ASSERT_EQ(10, json["properties"]["flags"][0].GetInt64());
    ASSERT_TRUE(json["properties"]["flags"][1].IsString());
    ASSERT_EQ("parse", json["properties"]["flags"][1].GetString());
    ASSERT_TRUE(json["properties"]["flags"][2].IsObject());
    AssertField(json["properties"]["flags"][2], "tag", std::string("no"));
    AssertField(json["properties"]["flags"][2], std::string("status"));
    AssertField(json["properties"], "age", 110.5e-4);
    AssertField(json["properties"], "depth", static_cast<int64_t>(-10));
    // test iteration
    std::set<std::string> expected({"flags", "age", "depth"});
    for (auto item : json["properties"].Items()) {
      auto iter = expected.find(item.first);
      ASSERT_TRUE(iter != expected.end());
      expected.erase(iter);
    }
    ASSERT_EQ(0U, expected.size());
    ASSERT_TRUE(json.Contains("latlong"));
    ASSERT_TRUE(json["latlong"].IsArray());
    ASSERT_EQ(2u, json["latlong"].Count());
    ASSERT_TRUE(json["latlong"][0].IsDouble());
    ASSERT_EQ(53.25, json["latlong"][0].GetDouble());
    ASSERT_TRUE(json["latlong"][1].IsDouble());
    ASSERT_EQ(43.75, json["latlong"][1].GetDouble());
    AssertField(json, "enabled", true);
  }

  const std::string kSampleJSON =
      "{ \"title\" : \"json\", \"type\" : \"object\", \"properties\" : { "
      "\"flags\": [10, \"parse\", {\"tag\": \"no\", \"status\": null}], "
      "\"age\": 110.5e-4, \"depth\": -10 }, \"latlong\": [53.25, 43.75], "
      "\"enabled\": true }";

  const std::string kSampleJSONDifferent =
      "{ \"title\" : \"json\", \"type\" : \"object\", \"properties\" : { "
      "\"flags\": [10, \"parse\", {\"tag\": \"no\", \"status\": 2}], "
      "\"age\": 110.5e-4, \"depth\": -10 }, \"latlong\": [53.25, 43.75], "
      "\"enabled\": true }";

  Random rnd_;
};

TEST_F(JSONDocumentTest, MakeNullTest) {
  JSONDocument x;
  ASSERT_TRUE(x.IsNull());
  ASSERT_TRUE(x.IsOwner());
  ASSERT_TRUE(!x.IsBool());
}

TEST_F(JSONDocumentTest, MakeBoolTest) {
  {
    JSONDocument x(true);
    ASSERT_TRUE(x.IsOwner());
    ASSERT_TRUE(x.IsBool());
    ASSERT_TRUE(!x.IsInt64());
    ASSERT_EQ(x.GetBool(), true);
  }

  {
    JSONDocument x(false);
    ASSERT_TRUE(x.IsOwner());
    ASSERT_TRUE(x.IsBool());
    ASSERT_TRUE(!x.IsInt64());
    ASSERT_EQ(x.GetBool(), false);
  }
}

TEST_F(JSONDocumentTest, MakeInt64Test) {
  JSONDocument x(static_cast<int64_t>(16));
  ASSERT_TRUE(x.IsInt64());
  ASSERT_TRUE(x.IsInt64());
  ASSERT_TRUE(!x.IsBool());
  ASSERT_TRUE(x.IsOwner());
  ASSERT_EQ(x.GetInt64(), 16);
}

TEST_F(JSONDocumentTest, MakeStringTest) {
  JSONDocument x("string");
  ASSERT_TRUE(x.IsOwner());
  ASSERT_TRUE(x.IsString());
  ASSERT_TRUE(!x.IsBool());
  ASSERT_EQ(x.GetString(), "string");
}

TEST_F(JSONDocumentTest, MakeDoubleTest) {
  JSONDocument x(5.6);
  ASSERT_TRUE(x.IsOwner());
  ASSERT_TRUE(x.IsDouble());
  ASSERT_TRUE(!x.IsBool());
  ASSERT_EQ(x.GetDouble(), 5.6);
}

TEST_F(JSONDocumentTest, MakeByTypeTest) {
  {
    JSONDocument x(JSONDocument::kNull);
    ASSERT_TRUE(x.IsNull());
  }
  {
    JSONDocument x(JSONDocument::kBool);
    ASSERT_TRUE(x.IsBool());
  }
  {
    JSONDocument x(JSONDocument::kString);
    ASSERT_TRUE(x.IsString());
  }
  {
    JSONDocument x(JSONDocument::kInt64);
    ASSERT_TRUE(x.IsInt64());
  }
  {
    JSONDocument x(JSONDocument::kDouble);
    ASSERT_TRUE(x.IsDouble());
  }
  {
    JSONDocument x(JSONDocument::kObject);
    ASSERT_TRUE(x.IsObject());
  }
  {
    JSONDocument x(JSONDocument::kArray);
    ASSERT_TRUE(x.IsArray());
  }
}

TEST_F(JSONDocumentTest, Parsing) {
  std::unique_ptr<JSONDocument> parsed_json(
          JSONDocument::ParseJSON(kSampleJSON.c_str()));
  ASSERT_TRUE(parsed_json->IsOwner());
  ASSERT_TRUE(parsed_json != nullptr);
  AssertSampleJSON(*parsed_json);

  // test deep copying
  JSONDocument copied_json_document(*parsed_json);
  AssertSampleJSON(copied_json_document);
  ASSERT_TRUE(copied_json_document == *parsed_json);

  std::unique_ptr<JSONDocument> parsed_different_sample(
      JSONDocument::ParseJSON(kSampleJSONDifferent.c_str()));
  ASSERT_TRUE(parsed_different_sample != nullptr);
  ASSERT_TRUE(!(*parsed_different_sample == copied_json_document));

  // parse error
  const std::string kFaultyJSON =
      kSampleJSON.substr(0, kSampleJSON.size() - 10);
  ASSERT_TRUE(JSONDocument::ParseJSON(kFaultyJSON.c_str()) == nullptr);
}

TEST_F(JSONDocumentTest, Serialization) {
  std::unique_ptr<JSONDocument> parsed_json(
            JSONDocument::ParseJSON(kSampleJSON.c_str()));
  ASSERT_TRUE(parsed_json != nullptr);
  ASSERT_TRUE(parsed_json->IsOwner());
  std::string serialized;
  parsed_json->Serialize(&serialized);

  std::unique_ptr<JSONDocument> deserialized_json(
            JSONDocument::Deserialize(Slice(serialized)));
  ASSERT_TRUE(deserialized_json != nullptr);
  AssertSampleJSON(*deserialized_json);

  // deserialization failure
  ASSERT_TRUE(JSONDocument::Deserialize(
                  Slice(serialized.data(), serialized.size() - 10)) == nullptr);
}

TEST_F(JSONDocumentTest, OperatorEqualsTest) {
  // kNull
  ASSERT_TRUE(JSONDocument() == JSONDocument());

  // kBool
  ASSERT_TRUE(JSONDocument(false) != JSONDocument());
  ASSERT_TRUE(JSONDocument(false) == JSONDocument(false));
  ASSERT_TRUE(JSONDocument(true) == JSONDocument(true));
  ASSERT_TRUE(JSONDocument(false) != JSONDocument(true));

  // kString
  ASSERT_TRUE(JSONDocument("test") != JSONDocument());
  ASSERT_TRUE(JSONDocument("test") == JSONDocument("test"));

  // kInt64
  ASSERT_TRUE(JSONDocument(static_cast<int64_t>(15)) != JSONDocument());
  ASSERT_TRUE(JSONDocument(static_cast<int64_t>(15)) !=
              JSONDocument(static_cast<int64_t>(14)));
  ASSERT_TRUE(JSONDocument(static_cast<int64_t>(15)) ==
              JSONDocument(static_cast<int64_t>(15)));

  unique_ptr<JSONDocument> arrayWithInt8Doc(JSONDocument::ParseJSON("[8]"));
  ASSERT_TRUE(arrayWithInt8Doc != nullptr);
  ASSERT_TRUE(arrayWithInt8Doc->IsArray());
  ASSERT_TRUE((*arrayWithInt8Doc)[0].IsInt64());
  ASSERT_TRUE((*arrayWithInt8Doc)[0] == JSONDocument(static_cast<int64_t>(8)));

  unique_ptr<JSONDocument> arrayWithInt16Doc(JSONDocument::ParseJSON("[512]"));
  ASSERT_TRUE(arrayWithInt16Doc != nullptr);
  ASSERT_TRUE(arrayWithInt16Doc->IsArray());
  ASSERT_TRUE((*arrayWithInt16Doc)[0].IsInt64());
  ASSERT_TRUE((*arrayWithInt16Doc)[0] ==
              JSONDocument(static_cast<int64_t>(512)));

  unique_ptr<JSONDocument> arrayWithInt32Doc(
    JSONDocument::ParseJSON("[1000000]"));
  ASSERT_TRUE(arrayWithInt32Doc != nullptr);
  ASSERT_TRUE(arrayWithInt32Doc->IsArray());
  ASSERT_TRUE((*arrayWithInt32Doc)[0].IsInt64());
  ASSERT_TRUE((*arrayWithInt32Doc)[0] ==
               JSONDocument(static_cast<int64_t>(1000000)));

  // kDouble
  ASSERT_TRUE(JSONDocument(15.) != JSONDocument());
  ASSERT_TRUE(JSONDocument(15.) != JSONDocument(14.));
  ASSERT_TRUE(JSONDocument(15.) == JSONDocument(15.));
}

TEST_F(JSONDocumentTest, JSONDocumentBuilderTest) {
  unique_ptr<JSONDocument> parsedArray(
    JSONDocument::ParseJSON("[1, [123, \"a\", \"b\"], {\"b\":\"c\"}]"));
  ASSERT_TRUE(parsedArray != nullptr);

  JSONDocumentBuilder builder;
  ASSERT_TRUE(builder.WriteStartArray());
  ASSERT_TRUE(builder.WriteJSONDocument(1));

  ASSERT_TRUE(builder.WriteStartArray());
    ASSERT_TRUE(builder.WriteJSONDocument(123));
    ASSERT_TRUE(builder.WriteJSONDocument("a"));
    ASSERT_TRUE(builder.WriteJSONDocument("b"));
  ASSERT_TRUE(builder.WriteEndArray());

  ASSERT_TRUE(builder.WriteStartObject());
    ASSERT_TRUE(builder.WriteKeyValue("b", "c"));
  ASSERT_TRUE(builder.WriteEndObject());

  ASSERT_TRUE(builder.WriteEndArray());

  ASSERT_TRUE(*parsedArray == builder.GetJSONDocument());
}

TEST_F(JSONDocumentTest, OwnershipTest) {
  std::unique_ptr<JSONDocument> parsed(
          JSONDocument::ParseJSON(kSampleJSON.c_str()));
  ASSERT_TRUE(parsed != nullptr);
  ASSERT_TRUE(parsed->IsOwner());

  // Copy constructor from owner -> owner
  JSONDocument copy_constructor(*parsed);
  ASSERT_TRUE(copy_constructor.IsOwner());

  // Copy constructor from non-owner -> non-owner
  JSONDocument non_owner((*parsed)["properties"]);
  ASSERT_TRUE(!non_owner.IsOwner());

  // Move constructor from owner -> owner
  JSONDocument moved_from_owner(std::move(copy_constructor));
  ASSERT_TRUE(moved_from_owner.IsOwner());

  // Move constructor from non-owner -> non-owner
  JSONDocument moved_from_non_owner(std::move(non_owner));
  ASSERT_TRUE(!moved_from_non_owner.IsOwner());
}

}  //  namespace rocksdb

int main(int argc, char** argv) {
  ::testing::InitGoogleTest(&argc, argv);
  return RUN_ALL_TESTS();
}

#else
#include <stdio.h>

int main(int /*argc*/, char** /*argv*/) {
  fprintf(stderr, "SKIPPED as JSONDocument is not supported in ROCKSDB_LITE\n");
  return 0;
}

#endif  // !ROCKSDB_LITE
Operator	Description	Example
name:	Match package name. Supports * wildcards and repo/package form	name:phx* or name:hexpm/phoenix
description:	Full-text search of package descriptions	description:auth
depends:	Packages depending on a given package. Supports repo:package form	depends:ecto or depends:hexpm:ecto
build_tool:	Filter by build tool	build_tool:mix
updated_after:	Packages updated after an ISO8601 datetime	updated_after:2025-01-01T00:00:00Z
extra:	Match custom metadata (key,value). Nested keys are separated by commas	extra:license,MIT