Merge "Merge remote-tracking branch 'aosp/upstream-master' into androidx-main" into androidx-main am: 8f16167c39

Original change: https://android-review.googlesource.com/c/platform/external/icing/+/1874071

Change-Id: I28b130b82b61861225dddd4fc958d1758dce839f

1 files changed, 121 insertions, 70 deletions

diff --git a/icing/scoring/scorer_test.cc b/icing/scoring/scorer_test.cc
index 8b89514..f22a31a 100644
--- a/icing/scoring/scorer_test.cc
+++ b/icing/scoring/scorer_test.cc
@@ -27,6 +27,7 @@
 #include "icing/proto/scoring.pb.h"
 #include "icing/schema-builder.h"
 #include "icing/schema/schema-store.h"
+#include "icing/scoring/section-weights.h"
 #include "icing/store/document-id.h"
 #include "icing/store/document-store.h"
 #include "icing/testing/common-matchers.h"
@@ -91,6 +92,8 @@ class ScorerTest : public testing::Test {
 
   DocumentStore* document_store() { return document_store_.get(); }
 
+  SchemaStore* schema_store() { return schema_store_.get(); }
+
   const FakeClock& fake_clock1() { return fake_clock1_; }
 
   const FakeClock& fake_clock2() { return fake_clock2_; }
@@ -121,17 +124,37 @@ UsageReport CreateUsageReport(std::string name_space, std::string uri,
   return usage_report;
 }
 
-TEST_F(ScorerTest, CreationWithNullPointerShouldFail) {
-  EXPECT_THAT(Scorer::Create(ScoringSpecProto::RankingStrategy::DOCUMENT_SCORE,
-                             /*default_score=*/0, /*document_store=*/nullptr),
-              StatusIs(libtextclassifier3::StatusCode::FAILED_PRECONDITION));
+ScoringSpecProto CreateScoringSpecForRankingStrategy(
+    ScoringSpecProto::RankingStrategy::Code ranking_strategy) {
+  ScoringSpecProto scoring_spec;
+  scoring_spec.set_rank_by(ranking_strategy);
+  return scoring_spec;
+}
+
+TEST_F(ScorerTest, CreationWithNullDocumentStoreShouldFail) {
+  EXPECT_THAT(
+      Scorer::Create(CreateScoringSpecForRankingStrategy(
+                         ScoringSpecProto::RankingStrategy::DOCUMENT_SCORE),
+                     /*default_score=*/0, /*document_store=*/nullptr,
+                     schema_store()),
+      StatusIs(libtextclassifier3::StatusCode::FAILED_PRECONDITION));
+}
+
+TEST_F(ScorerTest, CreationWithNullSchemaStoreShouldFail) {
+  EXPECT_THAT(
+      Scorer::Create(CreateScoringSpecForRankingStrategy(
+                         ScoringSpecProto::RankingStrategy::DOCUMENT_SCORE),
+                     /*default_score=*/0, document_store(),
+                     /*schema_store=*/nullptr),
+      StatusIs(libtextclassifier3::StatusCode::FAILED_PRECONDITION));
 }
 
 TEST_F(ScorerTest, ShouldGetDefaultScoreIfDocumentDoesntExist) {
   ICING_ASSERT_OK_AND_ASSIGN(
       std::unique_ptr<Scorer> scorer,
-      Scorer::Create(ScoringSpecProto::RankingStrategy::DOCUMENT_SCORE,
-                     /*default_score=*/10, document_store()));
+      Scorer::Create(CreateScoringSpecForRankingStrategy(
+                         ScoringSpecProto::RankingStrategy::DOCUMENT_SCORE),
+                     /*default_score=*/10, document_store(), schema_store()));
 
   // Non existent document id
   DocHitInfo docHitInfo = DocHitInfo(/*document_id_in=*/1);
@@ -153,8 +176,9 @@ TEST_F(ScorerTest, ShouldGetDefaultScoreIfDocumentIsDeleted) {
 
   ICING_ASSERT_OK_AND_ASSIGN(
       std::unique_ptr<Scorer> scorer,
-      Scorer::Create(ScoringSpecProto::RankingStrategy::DOCUMENT_SCORE,
-                     /*default_score=*/10, document_store()));
+      Scorer::Create(CreateScoringSpecForRankingStrategy(
+                         ScoringSpecProto::RankingStrategy::DOCUMENT_SCORE),
+                     /*default_score=*/10, document_store(), schema_store()));
 
   DocHitInfo docHitInfo = DocHitInfo(document_id);
 
@@ -185,8 +209,9 @@ TEST_F(ScorerTest, ShouldGetDefaultScoreIfDocumentIsExpired) {
 
   ICING_ASSERT_OK_AND_ASSIGN(
       std::unique_ptr<Scorer> scorer,
-      Scorer::Create(ScoringSpecProto::RankingStrategy::DOCUMENT_SCORE,
-                     /*default_score=*/10, document_store()));
+      Scorer::Create(CreateScoringSpecForRankingStrategy(
+                         ScoringSpecProto::RankingStrategy::DOCUMENT_SCORE),
+                     /*default_score=*/10, document_store(), schema_store()));
 
   DocHitInfo docHitInfo = DocHitInfo(document_id);
 
@@ -213,8 +238,9 @@ TEST_F(ScorerTest, ShouldGetDefaultDocumentScore) {
                              document_store()->Put(test_document));
   ICING_ASSERT_OK_AND_ASSIGN(
       std::unique_ptr<Scorer> scorer,
-      Scorer::Create(ScoringSpecProto::RankingStrategy::DOCUMENT_SCORE,
-                     /*default_score=*/10, document_store()));
+      Scorer::Create(CreateScoringSpecForRankingStrategy(
+                         ScoringSpecProto::RankingStrategy::DOCUMENT_SCORE),
+                     /*default_score=*/10, document_store(), schema_store()));
 
   DocHitInfo docHitInfo = DocHitInfo(document_id);
   EXPECT_THAT(scorer->GetScore(docHitInfo), Eq(0));
@@ -235,8 +261,9 @@ TEST_F(ScorerTest, ShouldGetCorrectDocumentScore) {
                              document_store()->Put(test_document));
   ICING_ASSERT_OK_AND_ASSIGN(
       std::unique_ptr<Scorer> scorer,
-      Scorer::Create(ScoringSpecProto::RankingStrategy::DOCUMENT_SCORE,
-                     /*default_score=*/0, document_store()));
+      Scorer::Create(CreateScoringSpecForRankingStrategy(
+                         ScoringSpecProto::RankingStrategy::DOCUMENT_SCORE),
+                     /*default_score=*/0, document_store(), schema_store()));
 
   DocHitInfo docHitInfo = DocHitInfo(document_id);
   EXPECT_THAT(scorer->GetScore(docHitInfo), Eq(5));
@@ -259,8 +286,9 @@ TEST_F(ScorerTest, QueryIteratorNullRelevanceScoreShouldReturnDefaultScore) {
                              document_store()->Put(test_document));
   ICING_ASSERT_OK_AND_ASSIGN(
       std::unique_ptr<Scorer> scorer,
-      Scorer::Create(ScoringSpecProto::RankingStrategy::RELEVANCE_SCORE,
-                     /*default_score=*/10, document_store()));
+      Scorer::Create(CreateScoringSpecForRankingStrategy(
+                         ScoringSpecProto::RankingStrategy::RELEVANCE_SCORE),
+                     /*default_score=*/10, document_store(), schema_store()));
 
   DocHitInfo docHitInfo = DocHitInfo(document_id);
   EXPECT_THAT(scorer->GetScore(docHitInfo), Eq(10));
@@ -290,8 +318,9 @@ TEST_F(ScorerTest, ShouldGetCorrectCreationTimestampScore) {
                              document_store()->Put(test_document2));
   ICING_ASSERT_OK_AND_ASSIGN(
       std::unique_ptr<Scorer> scorer,
-      Scorer::Create(ScoringSpecProto::RankingStrategy::CREATION_TIMESTAMP,
-                     /*default_score=*/0, document_store()));
+      Scorer::Create(CreateScoringSpecForRankingStrategy(
+                         ScoringSpecProto::RankingStrategy::CREATION_TIMESTAMP),
+                     /*default_score=*/0, document_store(), schema_store()));
 
   DocHitInfo docHitInfo1 = DocHitInfo(document_id1);
   DocHitInfo docHitInfo2 = DocHitInfo(document_id2);
@@ -316,16 +345,19 @@ TEST_F(ScorerTest, ShouldGetCorrectUsageCountScoreForType1) {
   // Create 3 scorers for 3 different usage types.
   ICING_ASSERT_OK_AND_ASSIGN(
       std::unique_ptr<Scorer> scorer1,
-      Scorer::Create(ScoringSpecProto::RankingStrategy::USAGE_TYPE1_COUNT,
-                     /*default_score=*/0, document_store()));
+      Scorer::Create(CreateScoringSpecForRankingStrategy(
+                         ScoringSpecProto::RankingStrategy::USAGE_TYPE1_COUNT),
+                     /*default_score=*/0, document_store(), schema_store()));
   ICING_ASSERT_OK_AND_ASSIGN(
       std::unique_ptr<Scorer> scorer2,
-      Scorer::Create(ScoringSpecProto::RankingStrategy::USAGE_TYPE2_COUNT,
-                     /*default_score=*/0, document_store()));
+      Scorer::Create(CreateScoringSpecForRankingStrategy(
+                         ScoringSpecProto::RankingStrategy::USAGE_TYPE2_COUNT),
+                     /*default_score=*/0, document_store(), schema_store()));
   ICING_ASSERT_OK_AND_ASSIGN(
       std::unique_ptr<Scorer> scorer3,
-      Scorer::Create(ScoringSpecProto::RankingStrategy::USAGE_TYPE3_COUNT,
-                     /*default_score=*/0, document_store()));
+      Scorer::Create(CreateScoringSpecForRankingStrategy(
+                         ScoringSpecProto::RankingStrategy::USAGE_TYPE3_COUNT),
+                     /*default_score=*/0, document_store(), schema_store()));
   DocHitInfo docHitInfo = DocHitInfo(document_id);
   EXPECT_THAT(scorer1->GetScore(docHitInfo), Eq(0));
   EXPECT_THAT(scorer2->GetScore(docHitInfo), Eq(0));
@@ -357,16 +389,19 @@ TEST_F(ScorerTest, ShouldGetCorrectUsageCountScoreForType2) {
   // Create 3 scorers for 3 different usage types.
   ICING_ASSERT_OK_AND_ASSIGN(
       std::unique_ptr<Scorer> scorer1,
-      Scorer::Create(ScoringSpecProto::RankingStrategy::USAGE_TYPE1_COUNT,
-                     /*default_score=*/0, document_store()));
+      Scorer::Create(CreateScoringSpecForRankingStrategy(
+                         ScoringSpecProto::RankingStrategy::USAGE_TYPE1_COUNT),
+                     /*default_score=*/0, document_store(), schema_store()));
   ICING_ASSERT_OK_AND_ASSIGN(
       std::unique_ptr<Scorer> scorer2,
-      Scorer::Create(ScoringSpecProto::RankingStrategy::USAGE_TYPE2_COUNT,
-                     /*default_score=*/0, document_store()));
+      Scorer::Create(CreateScoringSpecForRankingStrategy(
+                         ScoringSpecProto::RankingStrategy::USAGE_TYPE2_COUNT),
+                     /*default_score=*/0, document_store(), schema_store()));
   ICING_ASSERT_OK_AND_ASSIGN(
       std::unique_ptr<Scorer> scorer3,
-      Scorer::Create(ScoringSpecProto::RankingStrategy::USAGE_TYPE3_COUNT,
-                     /*default_score=*/0, document_store()));
+      Scorer::Create(CreateScoringSpecForRankingStrategy(
+                         ScoringSpecProto::RankingStrategy::USAGE_TYPE3_COUNT),
+                     /*default_score=*/0, document_store(), schema_store()));
   DocHitInfo docHitInfo = DocHitInfo(document_id);
   EXPECT_THAT(scorer1->GetScore(docHitInfo), Eq(0));
   EXPECT_THAT(scorer2->GetScore(docHitInfo), Eq(0));
@@ -398,16 +433,19 @@ TEST_F(ScorerTest, ShouldGetCorrectUsageCountScoreForType3) {
   // Create 3 scorers for 3 different usage types.
   ICING_ASSERT_OK_AND_ASSIGN(
       std::unique_ptr<Scorer> scorer1,
-      Scorer::Create(ScoringSpecProto::RankingStrategy::USAGE_TYPE1_COUNT,
-                     /*default_score=*/0, document_store()));
+      Scorer::Create(CreateScoringSpecForRankingStrategy(
+                         ScoringSpecProto::RankingStrategy::USAGE_TYPE1_COUNT),
+                     /*default_score=*/0, document_store(), schema_store()));
   ICING_ASSERT_OK_AND_ASSIGN(
       std::unique_ptr<Scorer> scorer2,
-      Scorer::Create(ScoringSpecProto::RankingStrategy::USAGE_TYPE2_COUNT,
-                     /*default_score=*/0, document_store()));
+      Scorer::Create(CreateScoringSpecForRankingStrategy(
+                         ScoringSpecProto::RankingStrategy::USAGE_TYPE2_COUNT),
+                     /*default_score=*/0, document_store(), schema_store()));
   ICING_ASSERT_OK_AND_ASSIGN(
       std::unique_ptr<Scorer> scorer3,
-      Scorer::Create(ScoringSpecProto::RankingStrategy::USAGE_TYPE3_COUNT,
-                     /*default_score=*/0, document_store()));
+      Scorer::Create(CreateScoringSpecForRankingStrategy(
+                         ScoringSpecProto::RankingStrategy::USAGE_TYPE3_COUNT),
+                     /*default_score=*/0, document_store(), schema_store()));
   DocHitInfo docHitInfo = DocHitInfo(document_id);
   EXPECT_THAT(scorer1->GetScore(docHitInfo), Eq(0));
   EXPECT_THAT(scorer2->GetScore(docHitInfo), Eq(0));
@@ -439,19 +477,22 @@ TEST_F(ScorerTest, ShouldGetCorrectUsageTimestampScoreForType1) {
   // Create 3 scorers for 3 different usage types.
   ICING_ASSERT_OK_AND_ASSIGN(
       std::unique_ptr<Scorer> scorer1,
-      Scorer::Create(
-          ScoringSpecProto::RankingStrategy::USAGE_TYPE1_LAST_USED_TIMESTAMP,
-          /*default_score=*/0, document_store()));
+      Scorer::Create(CreateScoringSpecForRankingStrategy(
+                         ScoringSpecProto::RankingStrategy::
+                             USAGE_TYPE1_LAST_USED_TIMESTAMP),
+                     /*default_score=*/0, document_store(), schema_store()));
   ICING_ASSERT_OK_AND_ASSIGN(
       std::unique_ptr<Scorer> scorer2,
-      Scorer::Create(
-          ScoringSpecProto::RankingStrategy::USAGE_TYPE2_LAST_USED_TIMESTAMP,
-          /*default_score=*/0, document_store()));
+      Scorer::Create(CreateScoringSpecForRankingStrategy(
+                         ScoringSpecProto::RankingStrategy::
+                             USAGE_TYPE2_LAST_USED_TIMESTAMP),
+                     /*default_score=*/0, document_store(), schema_store()));
   ICING_ASSERT_OK_AND_ASSIGN(
       std::unique_ptr<Scorer> scorer3,
-      Scorer::Create(
-          ScoringSpecProto::RankingStrategy::USAGE_TYPE3_LAST_USED_TIMESTAMP,
-          /*default_score=*/0, document_store()));
+      Scorer::Create(CreateScoringSpecForRankingStrategy(
+                         ScoringSpecProto::RankingStrategy::
+                             USAGE_TYPE3_LAST_USED_TIMESTAMP),
+                     /*default_score=*/0, document_store(), schema_store()));
   DocHitInfo docHitInfo = DocHitInfo(document_id);
   EXPECT_THAT(scorer1->GetScore(docHitInfo), Eq(0));
   EXPECT_THAT(scorer2->GetScore(docHitInfo), Eq(0));
@@ -499,19 +540,22 @@ TEST_F(ScorerTest, ShouldGetCorrectUsageTimestampScoreForType2) {
   // Create 3 scorers for 3 different usage types.
   ICING_ASSERT_OK_AND_ASSIGN(
       std::unique_ptr<Scorer> scorer1,
-      Scorer::Create(
-          ScoringSpecProto::RankingStrategy::USAGE_TYPE1_LAST_USED_TIMESTAMP,
-          /*default_score=*/0, document_store()));
+      Scorer::Create(CreateScoringSpecForRankingStrategy(
+                         ScoringSpecProto::RankingStrategy::
+                             USAGE_TYPE1_LAST_USED_TIMESTAMP),
+                     /*default_score=*/0, document_store(), schema_store()));
   ICING_ASSERT_OK_AND_ASSIGN(
       std::unique_ptr<Scorer> scorer2,
-      Scorer::Create(
-          ScoringSpecProto::RankingStrategy::USAGE_TYPE2_LAST_USED_TIMESTAMP,
-          /*default_score=*/0, document_store()));
+      Scorer::Create(CreateScoringSpecForRankingStrategy(
+                         ScoringSpecProto::RankingStrategy::
+                             USAGE_TYPE2_LAST_USED_TIMESTAMP),
+                     /*default_score=*/0, document_store(), schema_store()));
   ICING_ASSERT_OK_AND_ASSIGN(
       std::unique_ptr<Scorer> scorer3,
-      Scorer::Create(
-          ScoringSpecProto::RankingStrategy::USAGE_TYPE3_LAST_USED_TIMESTAMP,
-          /*default_score=*/0, document_store()));
+      Scorer::Create(CreateScoringSpecForRankingStrategy(
+                         ScoringSpecProto::RankingStrategy::
+                             USAGE_TYPE3_LAST_USED_TIMESTAMP),
+                     /*default_score=*/0, document_store(), schema_store()));
   DocHitInfo docHitInfo = DocHitInfo(document_id);
   EXPECT_THAT(scorer1->GetScore(docHitInfo), Eq(0));
   EXPECT_THAT(scorer2->GetScore(docHitInfo), Eq(0));
@@ -559,19 +603,22 @@ TEST_F(ScorerTest, ShouldGetCorrectUsageTimestampScoreForType3) {
   // Create 3 scorers for 3 different usage types.
   ICING_ASSERT_OK_AND_ASSIGN(
       std::unique_ptr<Scorer> scorer1,
-      Scorer::Create(
-          ScoringSpecProto::RankingStrategy::USAGE_TYPE1_LAST_USED_TIMESTAMP,
-          /*default_score=*/0, document_store()));
+      Scorer::Create(CreateScoringSpecForRankingStrategy(
+                         ScoringSpecProto::RankingStrategy::
+                             USAGE_TYPE1_LAST_USED_TIMESTAMP),
+                     /*default_score=*/0, document_store(), schema_store()));
   ICING_ASSERT_OK_AND_ASSIGN(
       std::unique_ptr<Scorer> scorer2,
-      Scorer::Create(
-          ScoringSpecProto::RankingStrategy::USAGE_TYPE2_LAST_USED_TIMESTAMP,
-          /*default_score=*/0, document_store()));
+      Scorer::Create(CreateScoringSpecForRankingStrategy(
+                         ScoringSpecProto::RankingStrategy::
+                             USAGE_TYPE2_LAST_USED_TIMESTAMP),
+                     /*default_score=*/0, document_store(), schema_store()));
   ICING_ASSERT_OK_AND_ASSIGN(
       std::unique_ptr<Scorer> scorer3,
-      Scorer::Create(
-          ScoringSpecProto::RankingStrategy::USAGE_TYPE3_LAST_USED_TIMESTAMP,
-          /*default_score=*/0, document_store()));
+      Scorer::Create(CreateScoringSpecForRankingStrategy(
+                         ScoringSpecProto::RankingStrategy::
+                             USAGE_TYPE3_LAST_USED_TIMESTAMP),
+                     /*default_score=*/0, document_store(), schema_store()));
   DocHitInfo docHitInfo = DocHitInfo(document_id);
   EXPECT_THAT(scorer1->GetScore(docHitInfo), Eq(0));
   EXPECT_THAT(scorer2->GetScore(docHitInfo), Eq(0));
@@ -607,8 +654,9 @@ TEST_F(ScorerTest, ShouldGetCorrectUsageTimestampScoreForType3) {
 TEST_F(ScorerTest, NoScorerShouldAlwaysReturnDefaultScore) {
   ICING_ASSERT_OK_AND_ASSIGN(
       std::unique_ptr<Scorer> scorer,
-      Scorer::Create(ScoringSpecProto::RankingStrategy::NONE,
-                     /*default_score=*/3, document_store()));
+      Scorer::Create(CreateScoringSpecForRankingStrategy(
+                         ScoringSpecProto::RankingStrategy::NONE),
+                     /*default_score=*/3, document_store(), schema_store()));
 
   DocHitInfo docHitInfo1 = DocHitInfo(/*document_id_in=*/0);
   DocHitInfo docHitInfo2 = DocHitInfo(/*document_id_in=*/1);
@@ -618,8 +666,10 @@ TEST_F(ScorerTest, NoScorerShouldAlwaysReturnDefaultScore) {
   EXPECT_THAT(scorer->GetScore(docHitInfo3), Eq(3));
 
   ICING_ASSERT_OK_AND_ASSIGN(
-      scorer, Scorer::Create(ScoringSpecProto::RankingStrategy::NONE,
-                             /*default_score=*/111, document_store()));
+      scorer,
+      Scorer::Create(CreateScoringSpecForRankingStrategy(
+                         ScoringSpecProto::RankingStrategy::NONE),
+                     /*default_score=*/111, document_store(), schema_store()));
 
   docHitInfo1 = DocHitInfo(/*document_id_in=*/4);
   docHitInfo2 = DocHitInfo(/*document_id_in=*/5);
@@ -643,9 +693,10 @@ TEST_F(ScorerTest, ShouldScaleUsageTimestampScoreForMaxTimestamp) {
 
   ICING_ASSERT_OK_AND_ASSIGN(
       std::unique_ptr<Scorer> scorer1,
-      Scorer::Create(
-          ScoringSpecProto::RankingStrategy::USAGE_TYPE1_LAST_USED_TIMESTAMP,
-          /*default_score=*/0, document_store()));
+      Scorer::Create(CreateScoringSpecForRankingStrategy(
+                         ScoringSpecProto::RankingStrategy::
+                             USAGE_TYPE1_LAST_USED_TIMESTAMP),
+                     /*default_score=*/0, document_store(), schema_store()));
   DocHitInfo docHitInfo = DocHitInfo(document_id);
 
   // Create usage report for the maximum allowable timestamp.