diff --git a/llvm/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp b/llvm/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp
index 12c43b5..963ce9f 100644
--- a/llvm/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp
+++ b/llvm/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp
@@ -87,4 +87,77 @@
       << "lookup returned the wrong result for address of 'foo'";
 }
 
+TEST(LegacyAPIInteropTset, LegacyLookupHelpersFn) {
+  constexpr JITTargetAddress FooAddr = 0xdeadbeef;
+  JITSymbolFlags FooFlags = JITSymbolFlags::Exported;
+
+  bool BarMaterialized = false;
+  constexpr JITTargetAddress BarAddr = 0xcafef00d;
+  JITSymbolFlags BarFlags = static_cast<JITSymbolFlags::FlagNames>(
+      JITSymbolFlags::Exported | JITSymbolFlags::Weak);
+
+  auto LegacyLookup = [&](const std::string &Name) -> JITSymbol {
+    if (Name == "foo")
+      return {FooAddr, FooFlags};
+
+    if (Name == "bar") {
+      auto BarMaterializer = [&]() -> Expected<JITTargetAddress> {
+        BarMaterialized = true;
+        return BarAddr;
+      };
+
+      return {BarMaterializer, BarFlags};
+    }
+
+    return nullptr;
+  };
+
+  SymbolStringPool SP;
+  auto Foo = SP.intern("foo");
+  auto Bar = SP.intern("bar");
+  auto Baz = SP.intern("baz");
+
+  SymbolNameSet Symbols({Foo, Bar, Baz});
+
+  auto LFR = lookupFlagsWithLegacyFn(Symbols, LegacyLookup);
+
+  EXPECT_TRUE(!!LFR) << "lookupFlagsWithLegacy failed unexpectedly";
+  EXPECT_EQ(LFR->SymbolFlags.size(), 2U) << "Wrong number of flags returned";
+  EXPECT_EQ(LFR->SymbolFlags.count(Foo), 1U) << "Flags for foo missing";
+  EXPECT_EQ(LFR->SymbolFlags.count(Bar), 1U) << "Flags for foo missing";
+  EXPECT_EQ(LFR->SymbolFlags[Foo], FooFlags) << "Wrong flags for foo";
+  EXPECT_EQ(LFR->SymbolFlags[Bar], BarFlags) << "Wrong flags for foo";
+  EXPECT_EQ(LFR->SymbolsNotFound.size(), 1U) << "Expected one symbol not found";
+  EXPECT_EQ(LFR->SymbolsNotFound.count(Baz), 1U)
+      << "Expected symbol baz to be not found";
+  EXPECT_FALSE(BarMaterialized)
+      << "lookupFlags should not have materialized bar";
+
+  bool OnResolvedRun = false;
+  bool OnReadyRun = false;
+  auto OnResolved = [&](Expected<SymbolMap> Result) {
+    OnResolvedRun = true;
+    EXPECT_TRUE(!!Result) << "lookuWithLegacy failed to resolve";
+    EXPECT_EQ(Result->size(), 2U) << "Wrong number of symbols resolved";
+    EXPECT_EQ(Result->count(Foo), 1U) << "Result for foo missing";
+    EXPECT_EQ(Result->count(Bar), 1U) << "Result for bar missing";
+    EXPECT_EQ((*Result)[Foo].getAddress(), FooAddr) << "Wrong address for foo";
+    EXPECT_EQ((*Result)[Foo].getFlags(), FooFlags) << "Wrong flags for foo";
+    EXPECT_EQ((*Result)[Bar].getAddress(), BarAddr) << "Wrong address for bar";
+    EXPECT_EQ((*Result)[Bar].getFlags(), BarFlags) << "Wrong flags for bar";
+  };
+  auto OnReady = [&](Error Err) {
+    EXPECT_FALSE(!!Err) << "Finalization unexpectedly failed";
+    OnReadyRun = true;
+  };
+
+  AsynchronousSymbolQuery Q({Foo, Bar}, OnResolved, OnReady);
+  auto Unresolved = lookupWithLegacyFn(Q, Symbols, LegacyLookup);
+
+  EXPECT_TRUE(OnResolvedRun) << "OnResolved was not run";
+  EXPECT_TRUE(OnReadyRun) << "OnReady was not run";
+  EXPECT_EQ(Unresolved.size(), 1U) << "Expected one unresolved symbol";
+  EXPECT_EQ(Unresolved.count(Baz), 1U) << "Expected baz to be unresolved";
+}
+
 } // namespace