[UnitTest] Add unit-test for LLVMCAS

Author: cachemeifyoucan

llvm/unittests/CAS/ActionCacheTest.cpp

@@ -0,0 +1,152 @@
+//===- ActionCacheTest.cpp ------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/CAS/ActionCache.h"
+#include "CASTestConfig.h"
+#include "llvm/CAS/ObjectStore.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Testing/Support/Error.h"
+#include "llvm/Testing/Support/SupportHelpers.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+using namespace llvm::cas;
+
+TEST_P(CASTest, ActionCacheHit) {
+  std::shared_ptr<ObjectStore> CAS = createObjectStore();
+  std::unique_ptr<ActionCache> Cache = createActionCache();
+
+  std::optional<ObjectProxy> ID;
+  ASSERT_THAT_ERROR(CAS->createProxy(std::nullopt, "1").moveInto(ID),
+                    Succeeded());
+  std::optional<CASID> ResultID;
+  ASSERT_THAT_ERROR(Cache->put(*ID, *ID), Succeeded());
+  ASSERT_THAT_ERROR(Cache->get(*ID).moveInto(ResultID), Succeeded());
+  ASSERT_TRUE(ResultID);
+  std::optional<ObjectRef> Result = CAS->getReference(*ResultID);
+  ASSERT_TRUE(Result);
+  ASSERT_EQ(*ID, *Result);
+}
+
+TEST_P(CASTest, ActionCacheMiss) {
+  std::shared_ptr<ObjectStore> CAS = createObjectStore();
+  std::unique_ptr<ActionCache> Cache = createActionCache();
+
+  std::optional<ObjectProxy> ID1, ID2;
+  ASSERT_THAT_ERROR(CAS->createProxy(std::nullopt, "1").moveInto(ID1),
+                    Succeeded());
+  ASSERT_THAT_ERROR(CAS->createProxy(std::nullopt, "2").moveInto(ID2),
+                    Succeeded());
+  ASSERT_THAT_ERROR(Cache->put(*ID1, *ID2), Succeeded());
+  // This is a cache miss for looking up a key doesn't exist.
+  std::optional<CASID> Result1;
+  ASSERT_THAT_ERROR(Cache->get(*ID2).moveInto(Result1), Succeeded());
+  ASSERT_FALSE(Result1);
+
+  ASSERT_THAT_ERROR(Cache->put(*ID2, *ID1), Succeeded());
+  // Cache hit after adding the value.
+  std::optional<CASID> Result2;
+  ASSERT_THAT_ERROR(Cache->get(*ID2).moveInto(Result2), Succeeded());
+  ASSERT_TRUE(Result2);
+  std::optional<ObjectRef> Ref = CAS->getReference(*Result2);
+  ASSERT_TRUE(Ref);
+  ASSERT_EQ(*ID1, *Ref);
+}
+
+TEST_P(CASTest, ActionCacheRewrite) {
+  std::shared_ptr<ObjectStore> CAS = createObjectStore();
+  std::unique_ptr<ActionCache> Cache = createActionCache();
+
+  std::optional<ObjectProxy> ID1, ID2;
+  ASSERT_THAT_ERROR(CAS->createProxy(std::nullopt, "1").moveInto(ID1),
+                    Succeeded());
+  ASSERT_THAT_ERROR(CAS->createProxy(std::nullopt, "2").moveInto(ID2),
+                    Succeeded());
+  ASSERT_THAT_ERROR(Cache->put(*ID1, *ID1), Succeeded());
+  // Writing to the same key with different value is error.
+  ASSERT_THAT_ERROR(Cache->put(*ID1, *ID2), Failed());
+  // Writing the same value multiple times to the same key is fine.
+  ASSERT_THAT_ERROR(Cache->put(*ID1, *ID1), Succeeded());
+}
+
+#if LLVM_ENABLE_ONDISK_CAS
+TEST(OnDiskActionCache, ActionCacheResultInvalid) {
+  unittest::TempDir Temp("on-disk-cache", /*Unique=*/true);
+  std::unique_ptr<ObjectStore> CAS1 = createInMemoryCAS();
+  std::unique_ptr<ObjectStore> CAS2 = createInMemoryCAS();
+
+  std::optional<ObjectProxy> ID1, ID2, ID3;
+  ASSERT_THAT_ERROR(CAS1->createProxy(std::nullopt, "1").moveInto(ID1),
+                    Succeeded());
+  ASSERT_THAT_ERROR(CAS1->createProxy(std::nullopt, "2").moveInto(ID2),
+                    Succeeded());
+  ASSERT_THAT_ERROR(CAS2->createProxy(std::nullopt, "1").moveInto(ID3),
+                    Succeeded());
+
+  std::unique_ptr<ActionCache> Cache1 =
+      cantFail(createOnDiskActionCache(Temp.path()));
+  // Test put and get.
+  ASSERT_THAT_ERROR(Cache1->put(*ID1, *ID2), Succeeded());
+  std::optional<CASID> Result;
+  ASSERT_THAT_ERROR(Cache1->get(*ID1).moveInto(Result), Succeeded());
+  ASSERT_TRUE(Result);
+
+  // Create OnDiskCAS from the same location but a different underlying CAS.
+  std::unique_ptr<ActionCache> Cache2 =
+      cantFail(createOnDiskActionCache(Temp.path()));
+  // Loading an key that points to an invalid object.
+  std::optional<CASID> Result2;
+  // Get will work but the resulting CASID doesn't exist in ObjectStore.
+  ASSERT_THAT_ERROR(Cache2->get(*ID3).moveInto(Result2), Succeeded());
+  ASSERT_FALSE(CAS2->getReference(*Result2));
+  // Write a different value will cause error.
+  ASSERT_THAT_ERROR(Cache2->put(*ID3, *ID3), Failed());
+}
+#endif
+
+TEST_P(CASTest, ActionCacheAsync) {
+  std::shared_ptr<ObjectStore> CAS = createObjectStore();
+  std::unique_ptr<ActionCache> Cache = createActionCache();
+
+  {
+    std::optional<ObjectProxy> ID;
+    ASSERT_THAT_ERROR(CAS->createProxy(std::nullopt, "1").moveInto(ID),
+                      Succeeded());
+    auto PutFuture = Cache->putFuture(*ID, *ID);
+    ASSERT_THAT_ERROR(PutFuture.get().take(), Succeeded());
+    auto GetFuture = Cache->getFuture(*ID);
+    std::optional<CASID> ResultID;
+    ASSERT_THAT_ERROR(GetFuture.get().take().moveInto(ResultID), Succeeded());
+    ASSERT_TRUE(ResultID);
+  }
+
+  std::optional<ObjectProxy> ID2;
+  ASSERT_THAT_ERROR(CAS->createProxy(std::nullopt, "2").moveInto(ID2),
+                    Succeeded());
+  {
+    std::promise<AsyncErrorValue> Promise;
+    auto Future = Promise.get_future();
+    Cache->putAsync(*ID2, *ID2, false,
+                    [Promise = std::move(Promise)](Error E) mutable {
+                      Promise.set_value(std::move(E));
+                    });
+    ASSERT_THAT_ERROR(Future.get().take(), Succeeded());
+  }
+  {
+    std::promise<AsyncCASIDValue> Promise;
+    auto Future = Promise.get_future();
+    Cache->getAsync(*ID2, false,
+                    [Promise = std::move(Promise)](
+                        Expected<std::optional<CASID>> Value) mutable {
+                      Promise.set_value(std::move(Value));
+                    });
+    std::optional<CASID> ResultID;
+    ASSERT_THAT_ERROR(Future.get().take().moveInto(ResultID), Succeeded());
+    ASSERT_TRUE(ResultID);
+  }
+}

llvm/unittests/CAS/CASTestConfig.cpp

@@ -7,16 +7,45 @@
 //===----------------------------------------------------------------------===//
 
 #include "CASTestConfig.h"
+#include "llvm/CAS/ActionCache.h"
 #include "llvm/CAS/ObjectStore.h"
 #include "gtest/gtest.h"
+#include <mutex>
 
 using namespace llvm;
 using namespace llvm::cas;
 
-CASTestingEnv createInMemory(int I) {
+TestingAndDir createInMemory(int I) {
   std::unique_ptr<ObjectStore> CAS = createInMemoryCAS();
-  return CASTestingEnv{std::move(CAS)};
+  std::unique_ptr<ActionCache> Cache = createInMemoryActionCache();
+  return TestingAndDir{std::move(CAS), std::move(Cache), std::nullopt};
 }
 
 INSTANTIATE_TEST_SUITE_P(InMemoryCAS, CASTest,
                          ::testing::Values(createInMemory));
+
+#if LLVM_ENABLE_ONDISK_CAS
+__attribute__((constructor)) static void configureCASTestEnv() {
+  // Restrict the size of the on-disk CAS for tests. This allows testing in
+  // constrained environments (e.g. small TMPDIR). It also prevents leaving
+  // behind large files on file systems that do not support sparse files if a
+  // test  crashes before resizing the file.
+  static std::once_flag Flag;
+  std::call_once(Flag, [] {
+    size_t Limit = 100 * 1024 * 1024;
+    std::string LimitStr = std::to_string(Limit);
+    setenv("LLVM_CAS_MAX_MAPPING_SIZE", LimitStr.c_str(), /*overwrite=*/false);
+  });
+}
+
+TestingAndDir createOnDisk(int I) {
+  unittest::TempDir Temp("on-disk-cas", /*Unique=*/true);
+  std::unique_ptr<ObjectStore> CAS;
+  EXPECT_THAT_ERROR(createOnDiskCAS(Temp.path()).moveInto(CAS), Succeeded());
+  std::unique_ptr<ActionCache> Cache;
+  EXPECT_THAT_ERROR(createOnDiskActionCache(Temp.path()).moveInto(Cache),
+                    Succeeded());
+  return TestingAndDir{std::move(CAS), std::move(Cache), std::move(Temp)};
+}
+INSTANTIATE_TEST_SUITE_P(OnDiskCAS, CASTest, ::testing::Values(createOnDisk));
+#endif /* LLVM_ENABLE_ONDISK_CAS */

llvm/unittests/CAS/CASTestConfig.h

@@ -6,31 +6,47 @@
 //
 //===----------------------------------------------------------------------===//
 
+#ifndef LLVM_UNITTESTS_CASTESTCONFIG_H
+#define LLVM_UNITTESTS_CASTESTCONFIG_H
+
+#include "llvm/CAS/ActionCache.h"
 #include "llvm/CAS/ObjectStore.h"
-#include "llvm/Config/llvm-config.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Testing/Support/Error.h"
 #include "llvm/Testing/Support/SupportHelpers.h"
 #include "gtest/gtest.h"
+#include <memory>
 
-#ifndef LLVM_UNITTESTS_CASTESTCONFIG_H
-#define LLVM_UNITTESTS_CASTESTCONFIG_H
-
-struct CASTestingEnv {
-  std::unique_ptr<llvm::cas::ObjectStore> CAS;
+struct TestingAndDir {
+  std::shared_ptr<llvm::cas::ObjectStore> CAS;
+  std::unique_ptr<llvm::cas::ActionCache> Cache;
+  std::optional<llvm::unittest::TempDir> Temp;
 };
 
 class CASTest
-    : public testing::TestWithParam<std::function<CASTestingEnv(int)>> {
+    : public testing::TestWithParam<std::function<TestingAndDir(int)>> {
 protected:
   std::optional<int> NextCASIndex;
 
-  std::unique_ptr<llvm::cas::ObjectStore> createObjectStore() {
+  llvm::SmallVector<llvm::unittest::TempDir> Dirs;
+
+  std::shared_ptr<llvm::cas::ObjectStore> createObjectStore() {
     auto TD = GetParam()(++(*NextCASIndex));
+    if (TD.Temp)
+      Dirs.push_back(std::move(*TD.Temp));
     return std::move(TD.CAS);
   }
+  std::unique_ptr<llvm::cas::ActionCache> createActionCache() {
+    auto TD = GetParam()(++(*NextCASIndex));
+    if (TD.Temp)
+      Dirs.push_back(std::move(*TD.Temp));
+    return std::move(TD.Cache);
+  }
   void SetUp() { NextCASIndex = 0; }
-  void TearDown() { NextCASIndex = std::nullopt; }
+  void TearDown() {
+    NextCASIndex = std::nullopt;
+    Dirs.clear();
+  }
 };
 
 #endif

llvm/unittests/CAS/CMakeLists.txt

@@ -1,12 +1,24 @@
+if (LLVM_ENABLE_ONDISK_CAS)
+  add_definitions(-DLLVM_ENABLE_ONDISK_CAS=1)
+endif()
+
 set(LLVM_LINK_COMPONENTS
   Support
   CAS
   TestingSupport
   )
 
 add_llvm_unittest(CASTests
+  ActionCacheTest.cpp
   CASTestConfig.cpp
+  HierarchicalTreeBuilderTest.cpp
   ObjectStoreTest.cpp
+  OnDiskCommonUtils.h
+  OnDiskGraphDBTest.cpp
+  OnDiskHashMappedTrieTest.cpp
+  OnDiskKeyValueDBTest.cpp
+  TreeSchemaTest.cpp
+  UnifiedOnDiskCacheTest.cpp
   )
 
 target_link_libraries(CASTests PRIVATE LLVMTestingSupport)