Function EXPECT_OK_AND_ASSIGN

cpp/src/arrow/dataset/partition_test.cc:630–1038

  factory_ = HivePartitioning::MakeFactory(options);

  EXPECT_OK_AND_ASSIGN(auto schema, factory_->Inspect({"/alpha=a/beta=0"}));
  EXPECT_OK_AND_ASSIGN(auto partitioning, factory_->Finish(schema));
  ASSERT_EQ("xyz",
            std::static_pointer_cast<HivePartitioning>(partitioning)->null_fallback());
}

TEST_F(TestPartitioning, HiveDictionaryHasUniqueValues) {
  HivePartitioningFactoryOptions options;
  options.infer_dictionary = true;
  factory_ = HivePartitioning::MakeFactory(options);

  auto alpha = DictStr("alpha");
  AssertInspect({"/alpha=a", "/alpha=b", "/alpha=a", "/alpha=b", "/alpha=c", "/alpha=a"},
                {alpha});
  ASSERT_OK_AND_ASSIGN(auto partitioning, factory_->Finish(schema({alpha})));

  auto expected_dictionary =
      checked_pointer_cast<StringArray>(ArrayFromJSON(utf8(), R"(["a", "b", "c"])"));

  for (int32_t i = 0; i < expected_dictionary->length(); ++i) {
    DictionaryScalar::ValueType index_and_dictionary{std::make_shared<Int32Scalar>(i),
                                                     expected_dictionary};
    auto dictionary_scalar =
        std::make_shared<DictionaryScalar>(index_and_dictionary, alpha->type());

    auto path = "/alpha=" + expected_dictionary->GetString(i) + "/";
    AssertParse(path, equal(field_ref("alpha"), literal(dictionary_scalar)));
  }

  AssertParseError("/alpha=yosemite/");  // not in inspected dictionary
}

TEST_F(TestPartitioning, ExistingSchemaDirectory) {
  // Infer dictionary values but with a given schema
  auto dict_type = dictionary(int8(), utf8());
  PartitioningFactoryOptions options;
  options.schema = schema({field("alpha", int64()), field("beta", dict_type)});
  factory_ = DirectoryPartitioning::MakeFactory({"alpha", "beta"}, options);

  AssertInspect({"/0/1"}, options.schema->fields());
  AssertInspect({"/0/1/what"}, options.schema->fields());

  // fail if any segment is not parseable as schema type
  EXPECT_RAISES_WITH_MESSAGE_THAT(Invalid, ::testing::HasSubstr("Failed to parse string"),
                                  factory_->Inspect({"/0/1", "/hello/1"}));
  factory_ = DirectoryPartitioning::MakeFactory({"alpha", "beta"}, options);

  // Now we don't fail since our type is large enough
  AssertInspect({"/3760212050/1"}, options.schema->fields());
  // If there are still too many digits, fail
  EXPECT_RAISES_WITH_MESSAGE_THAT(Invalid, ::testing::HasSubstr("Failed to parse string"),
                                  factory_->Inspect({"/1038581385102940193760212050/1"}));
  factory_ = DirectoryPartitioning::MakeFactory({"alpha", "beta"}, options);

  AssertInspect({"/0/1", "/2"}, options.schema->fields());
}

TEST_F(TestPartitioning, ExistingSchemaHive) {