diff --git a/parser_library/test/CMakeLists.txt b/parser_library/test/CMakeLists.txt
index 7b38c8b24..cd0b01b14 100644
--- a/parser_library/test/CMakeLists.txt
+++ b/parser_library/test/CMakeLists.txt
@@ -15,7 +15,6 @@ add_executable(library_test)
 target_sources(library_test PRIVATE
 	aread_time_test.cpp
 	common_testing.h
-	copy_mock.h
 	diagnosable_ctx_test.cpp
 	diagnostics_check_test.cpp
 	gtest_stringers.h
diff --git a/parser_library/test/context/context_test.cpp b/parser_library/test/context/context_test.cpp
index 5221e4ce3..e7dba0449 100644
--- a/parser_library/test/context/context_test.cpp
+++ b/parser_library/test/context/context_test.cpp
@@ -16,7 +16,7 @@
 
 #include "gtest/gtest.h"
 
-#include "../copy_mock.h"
+#include "../common_testing.h"
 #include "analyzer.h"
 #include "context/hlasm_context.h"
 #include "context/variables/system_variable.h"
@@ -585,42 +585,16 @@ TEST(context_system_variables, SYSNEST_SYSMAC)
 
  M2
 )";
-    copy_mock mock;
-    analyzer a(input, analyzer_options { &mock });
+    analyzer a(input);
     a.analyze();
 
     a.collect_diags();
 
     EXPECT_EQ(a.diags().size(), (size_t)0);
 
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("v1"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<context::A_t>()
-                  ->get_value(),
-        2);
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("v2"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<context::C_t>()
-                  ->get_value(),
-        "OPEN CODE");
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("v3"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<context::C_t>()
-                  ->get_value(),
-        "M2");
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("v4"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<context::A_t>()
-                  ->get_value(),
-        1);
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("v5"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<context::C_t>()
-                  ->get_value(),
-        "M1");
+    EXPECT_EQ(get_var_value<context::A_t>(a.hlasm_ctx(), "v1"), 2);
+    EXPECT_EQ(get_var_value<context::C_t>(a.hlasm_ctx(), "v2"), "OPEN CODE");
+    EXPECT_EQ(get_var_value<context::C_t>(a.hlasm_ctx(), "v3"), "M2");
+    EXPECT_EQ(get_var_value<context::A_t>(a.hlasm_ctx(), "v4"), 1);
+    EXPECT_EQ(get_var_value<context::C_t>(a.hlasm_ctx(), "v5"), "M1");
 }
diff --git a/parser_library/test/context/data_attribute_test.cpp b/parser_library/test/context/data_attribute_test.cpp
index 3891c3fbf..9e1be3002 100644
--- a/parser_library/test/context/data_attribute_test.cpp
+++ b/parser_library/test/context/data_attribute_test.cpp
@@ -15,6 +15,7 @@
 #include "gtest/gtest.h"
 
 #include "../common_testing.h"
+#include "../mock_parse_lib_provider.h"
 
 // test for
 // symbol data attributes
@@ -145,48 +146,13 @@ TEST(data_attributes, N_var_syms)
     analyzer a(input);
     a.analyze();
 
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("N1"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<A_t>()
-                  ->get_value(),
-        3);
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("N2"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<A_t>()
-                  ->get_value(),
-        0);
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("N3"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<A_t>()
-                  ->get_value(),
-        3);
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("N4"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<A_t>()
-                  ->get_value(),
-        0);
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("NN1"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<A_t>()
-                  ->get_value(),
-        3);
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("NN2"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<A_t>()
-                  ->get_value(),
-        1);
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("NN3"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<A_t>()
-                  ->get_value(),
-        1);
+    EXPECT_EQ(get_var_value<A_t>(a.hlasm_ctx(), "N1"), 3);
+    EXPECT_EQ(get_var_value<A_t>(a.hlasm_ctx(), "N2"), 0);
+    EXPECT_EQ(get_var_value<A_t>(a.hlasm_ctx(), "N3"), 3);
+    EXPECT_EQ(get_var_value<A_t>(a.hlasm_ctx(), "N4"), 0);
+    EXPECT_EQ(get_var_value<A_t>(a.hlasm_ctx(), "NN1"), 3);
+    EXPECT_EQ(get_var_value<A_t>(a.hlasm_ctx(), "NN2"), 1);
+    EXPECT_EQ(get_var_value<A_t>(a.hlasm_ctx(), "NN3"), 1);
 
     a.collect_diags();
     ASSERT_EQ(a.diags().size(), (size_t)0);
@@ -215,36 +181,11 @@ TEST(data_attributes, K_var_syms_good)
     analyzer a(input);
     a.analyze();
 
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("N1"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<A_t>()
-                  ->get_value(),
-        1);
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("N2"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<A_t>()
-                  ->get_value(),
-        1);
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("NN1"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<A_t>()
-                  ->get_value(),
-        7);
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("NN2"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<A_t>()
-                  ->get_value(),
-        1);
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("NN3"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<A_t>()
-                  ->get_value(),
-        5);
+    EXPECT_EQ(get_var_value<A_t>(a.hlasm_ctx(), "N1"), 1);
+    EXPECT_EQ(get_var_value<A_t>(a.hlasm_ctx(), "N2"), 1);
+    EXPECT_EQ(get_var_value<A_t>(a.hlasm_ctx(), "NN1"), 7);
+    EXPECT_EQ(get_var_value<A_t>(a.hlasm_ctx(), "NN2"), 1);
+    EXPECT_EQ(get_var_value<A_t>(a.hlasm_ctx(), "NN3"), 5);
 
     a.collect_diags();
     ASSERT_EQ(a.diags().size(), (size_t)0);
@@ -307,42 +248,12 @@ TEST(data_attributes, T_var_syms)
     analyzer a(input);
     a.analyze();
 
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("T1"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<C_t>()
-                  ->get_value(),
-        "O");
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("T2"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<C_t>()
-                  ->get_value(),
-        "N");
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("T3"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<C_t>()
-                  ->get_value(),
-        "N");
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("T4"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<C_t>()
-                  ->get_value(),
-        "N");
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("T5"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<C_t>()
-                  ->get_value(),
-        "N");
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("T6"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<C_t>()
-                  ->get_value(),
-        "U");
+    EXPECT_EQ(get_var_value<C_t>(a.hlasm_ctx(), "T1"), "O");
+    EXPECT_EQ(get_var_value<C_t>(a.hlasm_ctx(), "T2"), "N");
+    EXPECT_EQ(get_var_value<C_t>(a.hlasm_ctx(), "T3"), "N");
+    EXPECT_EQ(get_var_value<C_t>(a.hlasm_ctx(), "T4"), "N");
+    EXPECT_EQ(get_var_value<C_t>(a.hlasm_ctx(), "T5"), "N");
+    EXPECT_EQ(get_var_value<C_t>(a.hlasm_ctx(), "T6"), "U");
 
     a.collect_diags();
     ASSERT_EQ(a.diags().size(), (size_t)0);
@@ -366,18 +277,8 @@ TEST(data_attributes, T_macro_params)
     analyzer a(input);
     a.analyze();
 
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("T1"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<C_t>()
-                  ->get_value(),
-        "O");
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("T2"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<C_t>()
-                  ->get_value(),
-        "N");
+    EXPECT_EQ(get_var_value<C_t>(a.hlasm_ctx(), "T1"), "O");
+    EXPECT_EQ(get_var_value<C_t>(a.hlasm_ctx(), "T2"), "N");
 
     a.collect_diags();
     ASSERT_EQ(a.diags().size(), (size_t)0);
@@ -395,12 +296,7 @@ LAB LR 1,1
     analyzer a(input);
     a.analyze();
 
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("T1"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<C_t>()
-                  ->get_value(),
-        "I");
+    EXPECT_EQ(get_var_value<C_t>(a.hlasm_ctx(), "T1"), "I");
 
     a.collect_diags();
     ASSERT_EQ(a.diags().size(), (size_t)0);
@@ -425,31 +321,11 @@ B LR 1,1
     analyzer a(input);
     a.analyze();
 
-    EXPECT_TRUE(a.hlasm_ctx()
-                    .get_var_sym(a.hlasm_ctx().ids().add("V1"))
-                    ->access_set_symbol_base()
-                    ->access_set_symbol<B_t>()
-                    ->get_value());
-    EXPECT_TRUE(a.hlasm_ctx()
-                    .get_var_sym(a.hlasm_ctx().ids().add("V2"))
-                    ->access_set_symbol_base()
-                    ->access_set_symbol<B_t>()
-                    ->get_value());
-    EXPECT_FALSE(a.hlasm_ctx()
-                     .get_var_sym(a.hlasm_ctx().ids().add("V3"))
-                     ->access_set_symbol_base()
-                     ->access_set_symbol<B_t>()
-                     ->get_value());
-    EXPECT_TRUE(a.hlasm_ctx()
-                    .get_var_sym(a.hlasm_ctx().ids().add("V4"))
-                    ->access_set_symbol_base()
-                    ->access_set_symbol<B_t>()
-                    ->get_value());
-    EXPECT_FALSE(a.hlasm_ctx()
-                     .get_var_sym(a.hlasm_ctx().ids().add("V5"))
-                     ->access_set_symbol_base()
-                     ->access_set_symbol<B_t>()
-                     ->get_value());
+    EXPECT_EQ(get_var_value<B_t>(a.hlasm_ctx(), "V1"), true);
+    EXPECT_EQ(get_var_value<B_t>(a.hlasm_ctx(), "V2"), true);
+    EXPECT_EQ(get_var_value<B_t>(a.hlasm_ctx(), "V3"), false);
+    EXPECT_EQ(get_var_value<B_t>(a.hlasm_ctx(), "V4"), true);
+    EXPECT_EQ(get_var_value<B_t>(a.hlasm_ctx(), "V5"), false);
 
     a.collect_diags();
     ASSERT_EQ(a.diags().size(), (size_t)0);
@@ -490,18 +366,8 @@ TEST EQU 11,10
     analyzer a(input);
     a.analyze();
 
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("V1"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<A_t>()
-                  ->get_value(),
-        10);
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("V2"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<A_t>()
-                  ->get_value(),
-        10);
+    EXPECT_EQ(get_var_value<A_t>(a.hlasm_ctx(), "V1"), 10);
+    EXPECT_EQ(get_var_value<A_t>(a.hlasm_ctx(), "V2"), 10);
 
     a.collect_diags();
     ASSERT_EQ(a.diags().size(), (size_t)0);
@@ -537,12 +403,7 @@ A DC FS12'1'
     analyzer a(input);
     a.analyze();
 
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("V1"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<A_t>()
-                  ->get_value(),
-        12);
+    EXPECT_EQ(get_var_value<A_t>(a.hlasm_ctx(), "V1"), 12);
 
     a.collect_diags();
     ASSERT_EQ(a.diags().size(), (size_t)0);
@@ -602,12 +463,7 @@ HALFCON DC HS6'-25.93'
     analyzer a(input);
     a.analyze();
 
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("V"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<A_t>()
-                  ->get_value(),
-        9);
+    EXPECT_EQ(get_var_value<A_t>(a.hlasm_ctx(), "V"), 9);
 
     a.collect_diags();
     ASSERT_EQ(a.diags().size(), (size_t)0);
@@ -632,42 +488,12 @@ TEST(data_attributes, O_opencode_ord)
     analyzer a(input);
     a.analyze();
 
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("V1"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<C_t>()
-                  ->get_value(),
-        "O");
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("V2"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<C_t>()
-                  ->get_value(),
-        "A");
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("V3"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<C_t>()
-                  ->get_value(),
-        "A");
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("V4"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<C_t>()
-                  ->get_value(),
-        "E");
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("V5"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<C_t>()
-                  ->get_value(),
-        "M");
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("V6"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<C_t>()
-                  ->get_value(),
-        "U");
+    EXPECT_EQ(get_var_value<C_t>(a.hlasm_ctx(), "V1"), "O");
+    EXPECT_EQ(get_var_value<C_t>(a.hlasm_ctx(), "V2"), "A");
+    EXPECT_EQ(get_var_value<C_t>(a.hlasm_ctx(), "V3"), "A");
+    EXPECT_EQ(get_var_value<C_t>(a.hlasm_ctx(), "V4"), "E");
+    EXPECT_EQ(get_var_value<C_t>(a.hlasm_ctx(), "V5"), "M");
+    EXPECT_EQ(get_var_value<C_t>(a.hlasm_ctx(), "V6"), "U");
 
     a.collect_diags();
     ASSERT_EQ(a.diags().size(), (size_t)0);
@@ -692,53 +518,13 @@ TEST(data_attributes, O_opencode_var)
     analyzer a(input);
     a.analyze();
 
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("V1"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<C_t>()
-                  ->get_value(),
-        "O");
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("V2"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<C_t>()
-                  ->get_value(),
-        "M");
+    EXPECT_EQ(get_var_value<C_t>(a.hlasm_ctx(), "V1"), "O");
+    EXPECT_EQ(get_var_value<C_t>(a.hlasm_ctx(), "V2"), "M");
 
     a.collect_diags();
     ASSERT_EQ(a.diags().size(), (size_t)0);
 }
 
-class O_mock : public workspaces::parse_lib_provider
-{
-public:
-    workspaces::parse_result parse_library(
-        const std::string& library, analyzing_context ctx, workspaces::library_data data) override
-    {
-        if (!has_library(library, ctx.hlasm_ctx->opencode_file_name()))
-            return false;
-
-        analyzer a(M, analyzer_options { library, this, std::move(ctx), data });
-        a.analyze();
-        return true;
-    }
-    bool has_library(const std::string& lib, const std::string&) const override { return lib == "MAC"; }
-    std::optional<std::string> get_library(
-        const std::string& library, const std::string& program, std::string*) const override
-    {
-        if (library == "MAC")
-            return M;
-        return std::nullopt;
-    }
-
-private:
-    const std::string M =
-        R"(   MACRO
-       MAC  
-       LR   1,1
-       MEND
-)";
-};
 
 TEST(data_attributes, O_libraries)
 {
@@ -749,31 +535,23 @@ TEST(data_attributes, O_libraries)
 &V3 SETC O'MAC
 
 )";
-    O_mock prov;
+    const std::string mac_def =
+        R"(   MACRO
+       MAC  
+       LR   1,1
+       MEND
+)";
+
+    mock_parse_lib_provider prov { { "MAC", mac_def } };
     analyzer a(input, analyzer_options { &prov });
     a.analyze();
 
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("V1"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<C_t>()
-                  ->get_value(),
-        "S");
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("V2"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<C_t>()
-                  ->get_value(),
-        "U");
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("V3"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<C_t>()
-                  ->get_value(),
-        "M");
+    EXPECT_EQ(get_var_value<C_t>(a.hlasm_ctx(), "V1"), "S");
+    EXPECT_EQ(get_var_value<C_t>(a.hlasm_ctx(), "V2"), "U");
+    EXPECT_EQ(get_var_value<C_t>(a.hlasm_ctx(), "V3"), "M");
 
     a.collect_diags();
-    ASSERT_EQ(a.diags().size(), (size_t)0);
+    ASSERT_EQ(a.diags().size(), 0U);
 }
 
 TEST(data_attributes, basic_attr_ref)
@@ -833,12 +611,7 @@ B EQU 1,11
     analyzer a(input);
     a.analyze();
 
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("V1"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<A_t>()
-                  ->get_value(),
-        1);
+    EXPECT_EQ(get_var_value<A_t>(a.hlasm_ctx(), "V1"), 1);
     EXPECT_EQ(a.hlasm_ctx().ord_ctx.get_symbol(a.hlasm_ctx().ids().add("A"))->attributes().length(),
         (symbol_attributes::len_attr)1);
 
diff --git a/parser_library/test/context/macro_test.cpp b/parser_library/test/context/macro_test.cpp
index faa027fb5..0474d4e3d 100644
--- a/parser_library/test/context/macro_test.cpp
+++ b/parser_library/test/context/macro_test.cpp
@@ -15,6 +15,7 @@
 #include "gtest/gtest.h"
 
 #include "../common_testing.h"
+#include "../mock_parse_lib_provider.h"
 
 // tests for macro feature:
 // definition parsing
@@ -519,85 +520,51 @@ TEST(macro, arguments_continuation)
     EXPECT_EQ(a.diags().size(), (size_t)0);
     EXPECT_EQ(a.parser().getNumberOfSyntaxErrors(), (size_t)0);
 }
-
-class bad_mock : public parse_lib_provider
+TEST(external_macro, bad_name)
 {
-    static const std::string* content_variant(int i)
-    {
-        static const std::string content_bad_name =
-            R"(   MACRO
-       MACC   &VAR
-       LR    &VAR,&VAR
-       MEND
-)";
-        static const std::string content_bad_begin =
-            R"(  aMACRO
-       MAC   &VAR
-       LR    &VAR,&VAR
-       MEND
+    std::string input =
+        R"(
+ MAC
+ MAC
 )";
-        static const std::string content_comment =
-            R"(**********  
-       MACRO
-       MAC   &VAR
+    std::string content_bad_name =
+        R"(   MACRO
+       MACC   &VAR
        LR    &VAR,&VAR
        MEND
 )";
-        switch (i)
-        {
-            case 0:
-                return &content_bad_name;
-            case 1:
-                return &content_bad_begin;
-            case 2:
-                return &content_comment;
-            default:
-                throw std::invalid_argument("Unknown variant");
-        }
-    }
-
-    const std::string* current_content;
-
-public:
-    bad_mock(int lib_code)
-        : current_content(content_variant(lib_code))
-    {}
-
-    parse_result parse_library(const std::string& library, analyzing_context ctx, library_data data) override
-    {
-        (void)library;
-
-        a = std::make_unique<analyzer>(*current_content, analyzer_options { "/tmp/MAC", this, std::move(ctx), data });
-        a->analyze();
-        a->collect_diags();
-        return true;
-    }
-    bool has_library(const std::string&, const std::string&) const override { return true; }
-    std::optional<std::string> get_library(
-        const std::string& library, const std::string& program, std::string*) const override
-    {
-        return *current_content;
-    }
-    std::unique_ptr<analyzer> a;
-};
+    mock_parse_lib_provider lib_provider { { "MAC", content_bad_name } };
+    analyzer a(input, analyzer_options { &lib_provider });
+    a.analyze();
+    a.collect_diags();
+    ASSERT_EQ(lib_provider.analyzers.count("MAC"), 1U);
+    EXPECT_EQ(lib_provider.analyzers["MAC"]->diags().size(), 1U);
+    EXPECT_EQ(a.diags().size(), 2U);
+    EXPECT_EQ(a.parser().getNumberOfSyntaxErrors(), 0U);
+}
 
-TEST(external_macro, bad_library)
+TEST(external_macro, bad_begin)
 {
     std::string input =
         R"(
  MAC
  MAC
 )";
-    for (int i = 0; i < 2; ++i)
-    {
-        bad_mock m(i);
-        analyzer a(input, analyzer_options { &m });
-        a.analyze();
-        a.collect_diags();
-        EXPECT_EQ(dynamic_cast<diagnosable*>(&*m.a)->diags().size(), (size_t)1);
-        EXPECT_EQ(a.diags().size(), (size_t)2);
-        EXPECT_EQ(a.parser().getNumberOfSyntaxErrors(), (size_t)0);
-    }
+    std::string content_bad_begin =
+        R"(  aMACRO
+       MAC   &VAR
+       LR    &VAR,&VAR
+       MEND
+)";
+
+    mock_parse_lib_provider lib_provider { { "MAC", content_bad_begin } };
+    analyzer a(input, analyzer_options { &lib_provider });
+    a.analyze();
+    a.collect_diags();
+    ASSERT_EQ(lib_provider.analyzers.count("MAC"), 1U);
+    EXPECT_EQ(lib_provider.analyzers["MAC"]->diags().size(), 1U);
+    EXPECT_EQ(a.diags().size(), 2U);
+    EXPECT_EQ(a.parser().getNumberOfSyntaxErrors(), 0U);
 }
 
 TEST(external_macro, library_with_begin_comment)
@@ -607,13 +574,21 @@ TEST(external_macro, library_with_begin_comment)
  MAC 1
  MAC 1
 )";
-    bad_mock m(2);
-    analyzer a(input, analyzer_options { &m });
+    std::string content_comment =
+        R"(**********  
+       MACRO
+       MAC   &VAR
+       LR    &VAR,&VAR
+       MEND
+)";
+    mock_parse_lib_provider lib_provider { { "MAC", content_comment } };
+    analyzer a(input, analyzer_options { &lib_provider });
     a.analyze();
     a.collect_diags();
-    EXPECT_EQ(dynamic_cast<diagnosable*>(&*m.a)->diags().size(), (size_t)0);
-    EXPECT_EQ(a.diags().size(), (size_t)0);
-    EXPECT_EQ(a.parser().getNumberOfSyntaxErrors(), (size_t)0);
+    ASSERT_EQ(lib_provider.analyzers.count("MAC"), 1U);
+    EXPECT_EQ(lib_provider.analyzers["MAC"]->diags().size(), 0U);
+    EXPECT_EQ(a.diags().size(), 0U);
+    EXPECT_EQ(a.parser().getNumberOfSyntaxErrors(), 0U);
 }
 
 TEST(variable_argument_passing, positive_sublist)
diff --git a/parser_library/test/context/ord_sym_test.cpp b/parser_library/test/context/ord_sym_test.cpp
index 9a182b96f..fbfecb149 100644
--- a/parser_library/test/context/ord_sym_test.cpp
+++ b/parser_library/test/context/ord_sym_test.cpp
@@ -15,7 +15,7 @@
 #include "gtest/gtest.h"
 
 #include "../common_testing.h"
-
+#include "../mock_parse_lib_provider.h"
 // tests for ordinary symbols feature:
 // relocatable/absolute value and attribute value
 // space/alignment creation
@@ -282,25 +282,6 @@ X3 EQU F-E
     ASSERT_EQ(a.diags().size(), (size_t)0);
 }
 
-class loc_mock : public workspaces::parse_lib_provider
-{
-public:
-    workspaces::parse_result parse_library(
-        const std::string& library, analyzing_context ctx, workspaces::library_data data) override
-    {
-        std::string lib_data("XXX EQU 1");
-        analyzer a(lib_data, analyzer_options { library, this, std::move(ctx), data });
-        a.analyze();
-        return true;
-    }
-
-    bool has_library(const std::string&, const std::string&) const override { return true; }
-    std::optional<std::string> get_library(const std::string&, const std::string&, std::string*) const override
-    {
-        return "XXX EQU 1";
-    }
-};
-
 TEST(ordinary_symbols, symbol_location)
 {
     std::string input = R"(
@@ -314,8 +295,9 @@ X EQU 1
  COPY COPYF
 
 )";
-    loc_mock tmp;
-    analyzer a(input, analyzer_options { "test", &tmp });
+    std::string lib_data("XXX EQU 1");
+    mock_parse_lib_provider mock { { "COPYF", lib_data } };
+    analyzer a(input, analyzer_options { "test", &mock });
     a.analyze();
     a.collect_diags();
 
diff --git a/parser_library/test/copy_mock.h b/parser_library/test/copy_mock.h
deleted file mode 100644
index 9bedbd418..000000000
--- a/parser_library/test/copy_mock.h
+++ /dev/null
@@ -1,211 +0,0 @@
-/*
- * Copyright (c) 2019 Broadcom.
- * The term "Broadcom" refers to Broadcom Inc. and/or its subsidiaries.
- *
- * This program and the accompanying materials are made
- * available under the terms of the Eclipse Public License 2.0
- * which is available at https://www.eclipse.org/legal/epl-2.0/
- *
- * SPDX-License-Identifier: EPL-2.0
- *
- * Contributors:
- *   Broadcom, Inc. - initial API and implementation
- */
-
-#ifndef HLASMPLUGIN_PARSERLIBRARY_TEST_COPY_MOCK_H
-#define HLASMPLUGIN_PARSERLIBRARY_TEST_COPY_MOCK_H
-
-#include "analyzer.h"
-
-namespace hlasm_plugin::parser_library {
-
-class copy_mock : public workspaces::parse_lib_provider
-{
-    const std::string* find_content(const std::string& library) const
-    {
-        if (library == "COPYR")
-            return &content_COPYR;
-        else if (library == "COPYF")
-            return &content_COPYF;
-        else if (library == "COPYD")
-            return &content_COPYD;
-        else if (library == "COPYREC")
-            return &content_COPYREC;
-        else if (library == "COPYU")
-            return &content_COPYU;
-        else if (library == "COPYL")
-            return &content_COPYL;
-        else if (library == "COPYN")
-            return &content_COPYN;
-        else if (library == "MAC")
-            return &content_MAC;
-        else if (library == "COPYM")
-            return &content_COPYM;
-        else if (library == "COPYJ")
-            return &content_COPYJ;
-        else if (library == "COPYJF")
-            return &content_COPYJF;
-        else if (library == "COPYND1")
-            return &content_COPYND1;
-        else if (library == "COPYND2")
-            return &content_COPYND2;
-        else if (library == "COPYBM")
-            return &content_COPYBM;
-        else if (library == "EMPTY")
-            return &content_EMPTY;
-        else if (library == "COPYEMPTY")
-            return &content_COPYEMPTY;
-        else
-            return nullptr;
-    }
-
-public:
-    workspaces::parse_result parse_library(
-        const std::string& library, analyzing_context ctx, workspaces::library_data data) override
-    {
-        current_content = find_content(library);
-        if (!current_content)
-            return false;
-
-        holder.push_back(std::move(a));
-        a = std::make_unique<analyzer>(*current_content, analyzer_options { library, this, std::move(ctx), data });
-        a->analyze();
-        a->collect_diags();
-        return true;
-    }
-    bool has_library(const std::string& library, const std::string&) const override { return find_content(library); }
-    std::optional<std::string> get_library(const std::string& library, const std::string&, std::string*) const override
-    {
-        const auto* content = find_content(library);
-        if (content)
-            return *content;
-        return std::nullopt;
-    }
-
-    std::vector<std::unique_ptr<analyzer>> holder;
-    std::unique_ptr<analyzer> a;
-
-private:
-    const std::string* current_content;
-
-    const std::string content_COPYR =
-        R"(   
- LR 1,1
- MACRO
- M1
- LR 1,1
- 
- MACRO
- M2
- LR 2,2
- MEND
- AGO .A
-.A ANOP
- MEND
-
-&VARX SETA &VARX+1
-.A ANOP
-.B ANOP
-&VAR SETA &VAR+1
-)";
-    const std::string content_COPYF =
-        R"(  
- LR 1,1
-&VARX SETA &VARX+1
- COPY COPYR
-&VAR SETA &VAR+1
-.C ANOP
-)";
-
-    const std::string content_COPYD =
-        R"(  
-
- LR 1,
-)";
-
-    const std::string content_COPYREC =
-        R"(  
- ANOP
- COPY COPYREC
- ANOP
-)";
-
-    const std::string content_COPYU =
-        R"(  
- ANOP
- MACRO
- M
- MEND
- MEND
- ANOP
-)";
-
-    const std::string content_COPYL =
-        R"(  
- LR 1,1
-.A ANOP
-&VARX SETA &VARX+1
- AGO .X
-&VAR SETA &VAR+1
-.A ANOP
-.C ANOP
-)";
-
-    const std::string content_COPYN =
-        R"( 
- MAC
-)";
-
-    const std::string content_MAC =
-        R"( MACRO
- MAC
- LR 1,1
- COPY COPYM
- MEND
-)";
-
-    const std::string content_COPYM =
-        R"(
-.A ANOP
- GBLA &X
-&X SETA 4
-)";
-
-    const std::string content_COPYJ =
-        R"(
- AGO .X
- ;%
-.X ANOP
-)";
-    const std::string content_COPYJF =
-        R"(
- AGO .X
- LR
-)";
-
-    const std::string content_COPYND1 =
-        R"(
- COPY COPYND2
-)";
-
-    const std::string content_COPYND2 =
-        R"(
-
-
-
- LR 1,)";
-
-    const std::string content_COPYBM =
-        R"( 
- MACRO
- M
- LR 1
- MEND
-)";
-    const std::string content_EMPTY = "";
-    const std::string content_COPYEMPTY = " COPY EMPTY";
-};
-
-} // namespace hlasm_plugin::parser_library
-
-#endif
diff --git a/parser_library/test/expressions/arithmetic_expression_test.cpp b/parser_library/test/expressions/arithmetic_expression_test.cpp
index 41a29e432..65f2be944 100644
--- a/parser_library/test/expressions/arithmetic_expression_test.cpp
+++ b/parser_library/test/expressions/arithmetic_expression_test.cpp
@@ -93,19 +93,9 @@ TEST(arithmetic_expressions, substitution_to_character_expression)
     a.collect_diags();
     ASSERT_EQ(a.diags().size(), (size_t)0);
 
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("C1"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<C_t>()
-                  ->get_value(),
-        "5-10*10");
-
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("C2"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<C_t>()
-                  ->get_value(),
-        "5-10*10");
+    EXPECT_EQ(get_var_value<C_t>(a.hlasm_ctx(), "C1"), "5-10*10");
+
+    EXPECT_EQ(get_var_value<C_t>(a.hlasm_ctx(), "C2"), "5-10*10");
 }
 
 TEST(arithmetic_expressions, subscript_use)
diff --git a/parser_library/test/expressions/ca_constant_test.cpp b/parser_library/test/expressions/ca_constant_test.cpp
index d89f44317..a7a3ef929 100644
--- a/parser_library/test/expressions/ca_constant_test.cpp
+++ b/parser_library/test/expressions/ca_constant_test.cpp
@@ -14,7 +14,6 @@
 
 #include "gmock/gmock.h"
 
-#include "expr_mocks.h"
 #include "expressions/conditional_assembly/terms/ca_constant.h"
 #include "expressions/evaluation_context.h"
 
@@ -24,10 +23,9 @@ using namespace hlasm_plugin::parser_library;
 
 TEST(ca_constant, undefined_attributes)
 {
-    lib_prov_mock lib;
-    evaluation_context eval_ctx {
-        analyzing_context { std::make_shared<context::hlasm_context>(), std::make_shared<lsp::lsp_context>() }, lib
-    };
+    evaluation_context eval_ctx { analyzing_context { std::make_shared<context::hlasm_context>(),
+                                      std::make_shared<lsp::lsp_context>() },
+        workspaces::empty_parse_lib_provider::instance };
 
     ca_constant c(1, range());
 
diff --git a/parser_library/test/expressions/ca_expr_list_test.cpp b/parser_library/test/expressions/ca_expr_list_test.cpp
index 30497e07e..42c81f4f3 100644
--- a/parser_library/test/expressions/ca_expr_list_test.cpp
+++ b/parser_library/test/expressions/ca_expr_list_test.cpp
@@ -14,7 +14,6 @@
 
 #include "gmock/gmock.h"
 
-#include "expr_mocks.h"
 #include "expressions/conditional_assembly/terms/ca_constant.h"
 #include "expressions/conditional_assembly/terms/ca_expr_list.h"
 #include "expressions/conditional_assembly/terms/ca_function.h"
@@ -30,10 +29,9 @@ using namespace hlasm_plugin::parser_library;
 
 TEST(ca_expr_list, unknown_function_to_operator)
 {
-    lib_prov_mock lib;
-    evaluation_context eval_ctx {
-        analyzing_context { std::make_shared<context::hlasm_context>(), std::make_shared<lsp::lsp_context>() }, lib
-    };
+    evaluation_context eval_ctx { analyzing_context { std::make_shared<context::hlasm_context>(),
+                                      std::make_shared<lsp::lsp_context>() },
+        workspaces::empty_parse_lib_provider::instance };
 
     std::string name = "AND";
     auto c = std::make_unique<ca_constant>(1, range());
@@ -59,10 +57,9 @@ TEST(ca_expr_list, unknown_function_to_operator)
 
 TEST(ca_expr_list, resolve_C_type)
 {
-    lib_prov_mock lib;
-    evaluation_context eval_ctx {
-        analyzing_context { std::make_shared<context::hlasm_context>(), std::make_shared<lsp::lsp_context>() }, lib
-    };
+    evaluation_context eval_ctx { analyzing_context { std::make_shared<context::hlasm_context>(),
+                                      std::make_shared<lsp::lsp_context>() },
+        workspaces::empty_parse_lib_provider::instance };
 
     std::string name = "UPPER";
     auto sym = std::make_unique<ca_symbol>(&name, range());
@@ -99,10 +96,9 @@ TEST(ca_expr_list, get_undefined_attributed_symbols)
     // (L'X 'low')
     ca_expr_list expr_list(std::move(list), range());
 
-    lib_prov_mock lib;
-    evaluation_context eval_ctx {
-        analyzing_context { std::make_shared<context::hlasm_context>(), std::make_shared<lsp::lsp_context>() }, lib
-    };
+    evaluation_context eval_ctx { analyzing_context { std::make_shared<context::hlasm_context>(),
+                                      std::make_shared<lsp::lsp_context>() },
+        workspaces::empty_parse_lib_provider::instance };
     auto res = expr_list.get_undefined_attributed_symbols(eval_ctx);
 
     ASSERT_TRUE(res.size());
diff --git a/parser_library/test/expressions/ca_function_test.cpp b/parser_library/test/expressions/ca_function_test.cpp
index 8962ebda9..02edfc92b 100644
--- a/parser_library/test/expressions/ca_function_test.cpp
+++ b/parser_library/test/expressions/ca_function_test.cpp
@@ -77,10 +77,9 @@ class set_expr : public ca_expression
 class ca_func : public ::testing::TestWithParam<func_test_param>
 {
 protected:
-    lib_prov_mock lib;
-    evaluation_context eval_ctx {
-        analyzing_context { std::make_shared<context::hlasm_context>(), std::make_shared<lsp::lsp_context>() }, lib
-    };
+    evaluation_context eval_ctx { analyzing_context { std::make_shared<context::hlasm_context>(),
+                                      std::make_shared<lsp::lsp_context>() },
+        workspaces::empty_parse_lib_provider::instance };
 
     context::SET_t get_result()
     {
diff --git a/parser_library/test/expressions/ca_operator_test.cpp b/parser_library/test/expressions/ca_operator_test.cpp
index a6267bb03..38e0eeafe 100644
--- a/parser_library/test/expressions/ca_operator_test.cpp
+++ b/parser_library/test/expressions/ca_operator_test.cpp
@@ -14,7 +14,6 @@
 
 #include "gmock/gmock.h"
 
-#include "expr_mocks.h"
 #include "expressions/conditional_assembly/ca_operator_binary.h"
 #include "expressions/conditional_assembly/ca_operator_unary.h"
 #include "expressions/conditional_assembly/terms/ca_constant.h"
@@ -58,10 +57,9 @@ struct stringer
 class ca_op : public ::testing::TestWithParam<op_test_param>
 {
 protected:
-    lib_prov_mock lib;
-    evaluation_context eval_ctx {
-        analyzing_context { std::make_shared<context::hlasm_context>(), std::make_shared<lsp::lsp_context>() }, lib
-    };
+    evaluation_context eval_ctx { analyzing_context { std::make_shared<context::hlasm_context>(),
+                                      std::make_shared<lsp::lsp_context>() },
+        workspaces::empty_parse_lib_provider::instance };
 
     SET_t get_result()
     {
diff --git a/parser_library/test/expressions/ca_string_test.cpp b/parser_library/test/expressions/ca_string_test.cpp
index 3c156ef71..cfd7ebbba 100644
--- a/parser_library/test/expressions/ca_string_test.cpp
+++ b/parser_library/test/expressions/ca_string_test.cpp
@@ -27,8 +27,8 @@ using namespace hlasm_plugin::parser_library;
 TEST(ca_string, undefined_attributes)
 {
     auto hlasm_ctx = std::make_shared<context::hlasm_context>();
-    lib_prov_mock lib;
-    evaluation_context eval_ctx { analyzing_context { hlasm_ctx, std::make_shared<lsp::lsp_context>() }, lib };
+    evaluation_context eval_ctx { analyzing_context { hlasm_ctx, std::make_shared<lsp::lsp_context>() },
+        workspaces::empty_parse_lib_provider::instance };
 
     concat_chain value;
     value.push_back(std::make_unique<char_str_conc>("gfds", range()));
@@ -81,10 +81,9 @@ TEST(ca_string, test)
 
     ca_string s(std::move(value), std::move(dupl), ca_string::substring_t(), range());
 
-    lib_prov_mock lib;
-    evaluation_context eval_ctx {
-        analyzing_context { std::make_shared<context::hlasm_context>(), std::make_shared<lsp::lsp_context>() }, lib
-    };
+    evaluation_context eval_ctx { analyzing_context { std::make_shared<context::hlasm_context>(),
+                                      std::make_shared<lsp::lsp_context>() },
+        workspaces::empty_parse_lib_provider::instance };
 
     auto res = s.evaluate(eval_ctx);
 
@@ -102,10 +101,9 @@ TEST_P(ca_string_suite, dupl)
 
     ca_string s(std::move(value), std::move(dupl), ca_string::substring_t(), range());
 
-    lib_prov_mock lib;
-    evaluation_context eval_ctx {
-        analyzing_context { std::make_shared<context::hlasm_context>(), std::make_shared<lsp::lsp_context>() }, lib
-    };
+    evaluation_context eval_ctx { analyzing_context { std::make_shared<context::hlasm_context>(),
+                                      std::make_shared<lsp::lsp_context>() },
+        workspaces::empty_parse_lib_provider::instance };
 
     auto res = s.evaluate(eval_ctx);
 
diff --git a/parser_library/test/expressions/ca_symbol_attribute_test.cpp b/parser_library/test/expressions/ca_symbol_attribute_test.cpp
index 3ae9ed1f7..3a352bbba 100644
--- a/parser_library/test/expressions/ca_symbol_attribute_test.cpp
+++ b/parser_library/test/expressions/ca_symbol_attribute_test.cpp
@@ -15,7 +15,6 @@
 #include "gmock/gmock.h"
 
 #include "ebcdic_encoding.h"
-#include "expr_mocks.h"
 #include "expressions/conditional_assembly/terms/ca_constant.h"
 #include "expressions/conditional_assembly/terms/ca_symbol_attribute.h"
 #include "expressions/evaluation_context.h"
@@ -27,8 +26,8 @@ using namespace hlasm_plugin::parser_library;
 TEST(ca_symbol_attr, undefined_attributes)
 {
     auto hlasm_ctx = std::make_shared<context::hlasm_context>();
-    lib_prov_mock lib;
-    evaluation_context eval_ctx { analyzing_context { hlasm_ctx, std::make_shared<lsp::lsp_context>() }, lib };
+    evaluation_context eval_ctx { analyzing_context { hlasm_ctx, std::make_shared<lsp::lsp_context>() },
+        workspaces::empty_parse_lib_provider::instance };
 
     std::string name = "n";
     std::vector<ca_expr_ptr> subscript;
@@ -54,8 +53,8 @@ ca_symbol_attribute create_var_sym_attr(context::data_attr_kind kind, context::i
 TEST(ca_symbol_attr, evaluate_undef_varsym)
 {
     auto hlasm_ctx = std::make_shared<context::hlasm_context>();
-    lib_prov_mock lib;
-    evaluation_context eval_ctx { analyzing_context { hlasm_ctx, std::make_shared<lsp::lsp_context>() }, lib };
+    evaluation_context eval_ctx { analyzing_context { hlasm_ctx, std::make_shared<lsp::lsp_context>() },
+        workspaces::empty_parse_lib_provider::instance };
 
     auto res = create_var_sym_attr(context::data_attr_kind::D, hlasm_ctx->ids().add("n")).evaluate(eval_ctx);
 
@@ -66,8 +65,8 @@ TEST(ca_symbol_attr, evaluate_undef_varsym)
 TEST(ca_symbol_attr, evaluate_substituted_varsym_not_char)
 {
     auto hlasm_ctx = std::make_shared<context::hlasm_context>();
-    lib_prov_mock lib;
-    evaluation_context eval_ctx { analyzing_context { hlasm_ctx, std::make_shared<lsp::lsp_context>() }, lib };
+    evaluation_context eval_ctx { analyzing_context { hlasm_ctx, std::make_shared<lsp::lsp_context>() },
+        workspaces::empty_parse_lib_provider::instance };
 
     auto name = hlasm_ctx->ids().add("n");
 
@@ -83,8 +82,8 @@ TEST(ca_symbol_attr, evaluate_substituted_varsym_not_char)
 TEST(ca_symbol_attr, evaluate_substituted_varsym_char_not_sym)
 {
     auto hlasm_ctx = std::make_shared<context::hlasm_context>();
-    lib_prov_mock lib;
-    evaluation_context eval_ctx { analyzing_context { hlasm_ctx, std::make_shared<lsp::lsp_context>() }, lib };
+    evaluation_context eval_ctx { analyzing_context { hlasm_ctx, std::make_shared<lsp::lsp_context>() },
+        workspaces::empty_parse_lib_provider::instance };
 
     auto name = hlasm_ctx->ids().add("n");
 
@@ -120,8 +119,8 @@ class ca_attr : public ::testing::TestWithParam<attr_test_param>
 {
 protected:
     std::shared_ptr<context::hlasm_context> hlasm_ctx = std::make_shared<context::hlasm_context>();
-    lib_prov_mock lib;
-    evaluation_context eval_ctx { analyzing_context { hlasm_ctx, std::make_shared<lsp::lsp_context>() }, lib };
+    evaluation_context eval_ctx { analyzing_context { hlasm_ctx, std::make_shared<lsp::lsp_context>() },
+        workspaces::empty_parse_lib_provider::instance };
 };
 
 INSTANTIATE_TEST_SUITE_P(ca_attr_suite,
diff --git a/parser_library/test/expressions/ca_symbol_test.cpp b/parser_library/test/expressions/ca_symbol_test.cpp
index 9aeb2a9a9..97e0a3e3e 100644
--- a/parser_library/test/expressions/ca_symbol_test.cpp
+++ b/parser_library/test/expressions/ca_symbol_test.cpp
@@ -15,7 +15,6 @@
 #include "gmock/gmock.h"
 
 #include "diagnostic_adder.h"
-#include "expr_mocks.h"
 #include "expressions/conditional_assembly/terms/ca_symbol.h"
 #include "expressions/evaluation_context.h"
 
@@ -25,10 +24,9 @@ using namespace hlasm_plugin::parser_library;
 
 TEST(ca_symbol, undefined_attributes)
 {
-    lib_prov_mock lib;
-    evaluation_context eval_ctx {
-        analyzing_context { std::make_shared<context::hlasm_context>(), std::make_shared<lsp::lsp_context>() }, lib
-    };
+    evaluation_context eval_ctx { analyzing_context { std::make_shared<context::hlasm_context>(),
+                                      std::make_shared<lsp::lsp_context>() },
+        workspaces::empty_parse_lib_provider::instance };
     std::string name = "n";
 
     ca_symbol sym(&name, range());
diff --git a/parser_library/test/expressions/ca_var_sym_test.cpp b/parser_library/test/expressions/ca_var_sym_test.cpp
index 0650d23af..4f2fcd3fc 100644
--- a/parser_library/test/expressions/ca_var_sym_test.cpp
+++ b/parser_library/test/expressions/ca_var_sym_test.cpp
@@ -14,7 +14,6 @@
 
 #include "gmock/gmock.h"
 
-#include "expr_mocks.h"
 #include "expressions/conditional_assembly/terms/ca_constant.h"
 #include "expressions/conditional_assembly/terms/ca_var_sym.h"
 #include "expressions/evaluation_context.h"
@@ -26,10 +25,9 @@ using namespace hlasm_plugin::parser_library;
 
 TEST(ca_var_sym_basic, undefined_attributes)
 {
-    lib_prov_mock lib;
-    evaluation_context eval_ctx {
-        analyzing_context { std::make_shared<context::hlasm_context>(), std::make_shared<lsp::lsp_context>() }, lib
-    };
+    evaluation_context eval_ctx { analyzing_context { std::make_shared<context::hlasm_context>(),
+                                      std::make_shared<lsp::lsp_context>() },
+        workspaces::empty_parse_lib_provider::instance };
 
     std::string name = "n";
     std::vector<ca_expr_ptr> subscript;
@@ -47,10 +45,9 @@ TEST(ca_var_sym_basic, undefined_attributes)
 
 TEST(ca_var_sym_created, undefined_attributes)
 {
-    lib_prov_mock lib;
-    evaluation_context eval_ctx {
-        analyzing_context { std::make_shared<context::hlasm_context>(), std::make_shared<lsp::lsp_context>() }, lib
-    };
+    evaluation_context eval_ctx { analyzing_context { std::make_shared<context::hlasm_context>(),
+                                      std::make_shared<lsp::lsp_context>() },
+        workspaces::empty_parse_lib_provider::instance };
 
     std::string name = "n";
     concat_chain created_name;
diff --git a/parser_library/test/expressions/expr_mocks.h b/parser_library/test/expressions/expr_mocks.h
index 076337d6e..212f7e1ac 100644
--- a/parser_library/test/expressions/expr_mocks.h
+++ b/parser_library/test/expressions/expr_mocks.h
@@ -16,30 +16,6 @@
 #ifndef HLASMPLUGIN_PARSERLIBRARY_TEST_EXPR_MOCK_H
 #define HLASMPLUGIN_PARSERLIBRARY_TEST_EXPR_MOCK_H
 
-#include "workspaces/parse_lib_provider.h"
-
-using namespace hlasm_plugin::parser_library;
-
-class dep_sol_mock : public context::dependency_solver
-{
-    const context::symbol* get_symbol(context::id_index) const override { return nullptr; };
-};
-
-class lib_prov_mock : public workspaces::parse_lib_provider
-{
-public:
-    workspaces::parse_result parse_library(const std::string&, analyzing_context, workspaces::library_data) override
-    {
-        return false;
-    };
-
-    bool has_library(const std::string&, const std::string&) const override { return false; }
-    std::optional<std::string> get_library(const std::string&, const std::string&, std::string*) const override
-    {
-        return std::nullopt;
-    }
-};
-
 inline std::string big_string(char c = '1')
 {
     std::string s;
diff --git a/parser_library/test/lsp/lsp_context_copy_in_macro_test.cpp b/parser_library/test/lsp/lsp_context_copy_in_macro_test.cpp
index 188bf4fe6..2b5c5e157 100644
--- a/parser_library/test/lsp/lsp_context_copy_in_macro_test.cpp
+++ b/parser_library/test/lsp/lsp_context_copy_in_macro_test.cpp
@@ -14,13 +14,15 @@
 
 #include "gtest/gtest.h"
 
+#include "../mock_parse_lib_provider.h"
 #include "analyzer_fixture.h"
 
 using namespace hlasm_plugin::parser_library;
 using namespace hlasm_plugin::parser_library::lsp;
 
-struct lsp_context_copy_in_macro : public analyzer_fixture
+struct lsp_context_copy_in_macro : public ::testing::Test
 {
+    const static inline std::string opencode_file_name = "source";
     const static inline std::string opencode =
         R"(
        MAC 1
@@ -50,89 +52,65 @@ SYM    LR &VAR,1
 &VAR   SETA 1
 
 )";
-    class lib_provider_mock : public workspaces::parse_lib_provider
-    {
-        workspaces::parse_result parse_library(
-            const std::string& library, analyzing_context ctx, workspaces::library_data data) override
-        {
-            const std::string* text;
-            if (library == copyfile_file_name)
-                text = &copyfile;
-            else if (library == macro_file_name)
-                text = &macro;
-            else
-                return false;
-
-            analyzer lib_analyzer(*text, analyzer_options { library, this, ctx, data });
-            lib_analyzer.analyze();
-            return true;
-        };
-
-        bool has_library(const std::string& library, const std::string&) const override
-        {
-            return library == copyfile_file_name || library == macro_file_name;
-        };
-        std::optional<std::string> get_library(
-            const std::string& library, const std::string&, std::string*) const override
-        {
-            if (library == copyfile_file_name)
-                return copyfile;
-            if (library == macro_file_name)
-                return macro;
-            return std::nullopt;
-        }
-    };
-    static inline lib_provider_mock lib_prov_instance;
+
+    mock_parse_lib_provider lib_prov_instance;
+    std::unique_ptr<analyzer> a;
     lsp_context_copy_in_macro()
-        : analyzer_fixture(opencode, lib_prov_instance)
+        : lib_prov_instance({ { macro_file_name, macro }, { copyfile_file_name, copyfile } })
     {}
+
+    void SetUp() override
+    {
+        a = std::make_unique<analyzer>(opencode, analyzer_options { opencode_file_name, &lib_prov_instance });
+        a->analyze();
+    }
 };
 
 TEST_F(lsp_context_copy_in_macro, definition_macro)
 {
-    location res = a.context().lsp_ctx->definition(opencode_file_name, { 1, 8 });
+    location res = a->context().lsp_ctx->definition(opencode_file_name, { 1, 8 });
     EXPECT_EQ(res.file, macro_file_name);
     EXPECT_EQ(res.pos, position(1, 7));
 }
 
 TEST_F(lsp_context_copy_in_macro, definition_copyfile_from_opencode)
 {
-    location res = a.context().lsp_ctx->definition(opencode_file_name, { 3, 13 });
+    location res = a->context().lsp_ctx->definition(opencode_file_name, { 3, 13 });
     EXPECT_EQ(res.file, copyfile_file_name);
     EXPECT_EQ(res.pos, position(0, 0));
 }
 
 TEST_F(lsp_context_copy_in_macro, definition_copyfile_from_macro)
 {
-    location res = a.context().lsp_ctx->definition(macro_file_name, { 3, 13 });
+    location res = a->context().lsp_ctx->definition(macro_file_name, { 3, 13 });
     EXPECT_EQ(res.file, copyfile_file_name);
     EXPECT_EQ(res.pos, position(0, 0));
 }
 
 TEST_F(lsp_context_copy_in_macro, definition_macro_param_from_copyfile)
 {
-    location res = a.context().lsp_ctx->definition(copyfile_file_name, { 2, 11 });
+    location res = a->context().lsp_ctx->definition(copyfile_file_name, { 2, 11 });
     EXPECT_EQ(res.file, macro_file_name);
     EXPECT_EQ(res.pos, position(1, 11));
 }
 
 TEST_F(lsp_context_copy_in_macro, definition_var_from_macro)
 {
-    location res = a.context().lsp_ctx->definition(macro_file_name, { 5, 11 });
+    location res = a->context().lsp_ctx->definition(macro_file_name, { 5, 11 });
     EXPECT_EQ(res.file, copyfile_file_name);
     EXPECT_EQ(res.pos, position(3, 0));
 }
 
 TEST_F(lsp_context_copy_in_macro, definition_var_from_opencode)
 {
-    location res = a.context().lsp_ctx->definition(opencode_file_name, { 4, 11 });
+    location res = a->context().lsp_ctx->definition(opencode_file_name, { 4, 11 });
     EXPECT_EQ(res.file, copyfile_file_name);
     EXPECT_EQ(res.pos, position(3, 0));
 }
 
 TEST_F(lsp_context_copy_in_macro, definition_no_exist_copyfile)
 {
-    location res = a.context().lsp_ctx->definition(opencode_file_name, { 7, 15 });
+    location res = a->context().lsp_ctx->definition(opencode_file_name, { 7, 15 });
     EXPECT_EQ(res.file, opencode_file_name);
     EXPECT_EQ(res.pos, position(7, 15));
 }
diff --git a/parser_library/test/lsp/lsp_features_test.cpp b/parser_library/test/lsp/lsp_features_test.cpp
index c45ffc438..11f31b816 100644
--- a/parser_library/test/lsp/lsp_features_test.cpp
+++ b/parser_library/test/lsp/lsp_features_test.cpp
@@ -22,11 +22,22 @@
 
 using namespace hlasm_plugin::parser_library;
 
+constexpr const char* MACRO_FILE = "MAC";
+constexpr const char* SOURCE_FILE = "OPEN";
+constexpr const char* COPY_FILE = "COPYFILE";
+
 class lsp_features_test : public testing::Test
 {
 public:
     lsp_features_test()
-        : a(contents, analyzer_options { SOURCE_FILE, &lib_provider })
+        : lib_provider({ { "MAC",
+                             R"(   MACRO
+       MAC   &VAR
+       LR    &VAR,&VAR
+       MEND)" },
+            { "COPYFILE", R"(R2 EQU 2
+            LR R2,R2)" } })
+        , a(contents, analyzer_options { SOURCE_FILE, &lib_provider })
         , instruction_count(context::instruction::machine_instructions.size()
               + context::instruction::assembler_instructions.size() + context::instruction::ca_instructions.size()
               + context::instruction::mnemonic_codes.size()) {};
@@ -73,38 +84,27 @@ R1      MAC   R2
 TEST_F(lsp_features_test, go_to)
 {
     // jump from source to macro, macro MAC
-    EXPECT_TRUE(
-        (location { position(1, 7), MACRO_FILE }) == a.context().lsp_ctx->definition(SOURCE_FILE, position(0, 4)));
+    EXPECT_EQ(location(position(1, 7), MACRO_FILE), a.context().lsp_ctx->definition(SOURCE_FILE, position(0, 4)));
     // no jump
-    EXPECT_TRUE(
-        (location { position(0, 8), SOURCE_FILE }) == a.context().lsp_ctx->definition(SOURCE_FILE, position(0, 8)));
+    EXPECT_EQ(location(position(0, 8), SOURCE_FILE), a.context().lsp_ctx->definition(SOURCE_FILE, position(0, 8)));
     // jump in source, open code, var symbol &VAR
-    EXPECT_TRUE(
-        (location { position(1, 0), SOURCE_FILE }) == a.context().lsp_ctx->definition(SOURCE_FILE, position(2, 13)));
+    EXPECT_EQ(location(position(1, 0), SOURCE_FILE), a.context().lsp_ctx->definition(SOURCE_FILE, position(2, 13)));
     // jump in source, open code, seq symbol .HERE
-    EXPECT_TRUE(
-        (location { position(5, 0), SOURCE_FILE }) == a.context().lsp_ctx->definition(SOURCE_FILE, position(3, 13)));
+    EXPECT_EQ(location(position(5, 0), SOURCE_FILE), a.context().lsp_ctx->definition(SOURCE_FILE, position(3, 13)));
     // jump in source, macro, seq symbol .HERE
-    EXPECT_TRUE(
-        (location { position(15, 0), SOURCE_FILE }) == a.context().lsp_ctx->definition(SOURCE_FILE, position(12, 15)));
+    EXPECT_EQ(location(position(15, 0), SOURCE_FILE), a.context().lsp_ctx->definition(SOURCE_FILE, position(12, 15)));
     // jump in source, macro, var symbol &LABEL
-    EXPECT_TRUE(
-        (location { position(8, 0), SOURCE_FILE }) == a.context().lsp_ctx->definition(SOURCE_FILE, position(11, 20)));
+    EXPECT_EQ(location(position(8, 0), SOURCE_FILE), a.context().lsp_ctx->definition(SOURCE_FILE, position(11, 20)));
     // jump in source, macro, var symbol &VAR
-    EXPECT_TRUE(
-        (location { position(8, 13), SOURCE_FILE }) == a.context().lsp_ctx->definition(SOURCE_FILE, position(11, 15)));
+    EXPECT_EQ(location(position(8, 13), SOURCE_FILE), a.context().lsp_ctx->definition(SOURCE_FILE, position(11, 15)));
     // forward jump in source, open code, ord symbol R1
-    EXPECT_TRUE(
-        (location { position(22, 0), SOURCE_FILE }) == a.context().lsp_ctx->definition(SOURCE_FILE, position(21, 10)));
+    EXPECT_EQ(location(position(22, 0), SOURCE_FILE), a.context().lsp_ctx->definition(SOURCE_FILE, position(21, 10)));
     // jump from source to copy file, ord symbol R2 on machine instrution
-    EXPECT_TRUE(
-        (location { position(0, 0), COPY_FILE }) == a.context().lsp_ctx->definition(SOURCE_FILE, position(21, 13)));
+    EXPECT_EQ(location(position(0, 0), COPY_FILE), a.context().lsp_ctx->definition(SOURCE_FILE, position(21, 13)));
     // jump from source to copy file, ord symbol R2 on macro MAC
-    EXPECT_TRUE(
-        (location { position(0, 0), COPY_FILE }) == a.context().lsp_ctx->definition(SOURCE_FILE, position(23, 14)));
+    EXPECT_EQ(location(position(0, 0), COPY_FILE), a.context().lsp_ctx->definition(SOURCE_FILE, position(23, 14)));
     // jump from source to first instruction in copy file, COPY COPYFILE
-    EXPECT_TRUE(
-        (location { position(0, 3), COPY_FILE }) == a.context().lsp_ctx->definition(SOURCE_FILE, position(20, 14)));
+    EXPECT_EQ(location(position(0, 3), COPY_FILE), a.context().lsp_ctx->definition(SOURCE_FILE, position(20, 14)));
 }
 
 TEST_F(lsp_features_test, refs)
diff --git a/parser_library/test/metrics_test.cpp b/parser_library/test/metrics_test.cpp
index baf20826c..9e146cc8d 100644
--- a/parser_library/test/metrics_test.cpp
+++ b/parser_library/test/metrics_test.cpp
@@ -53,12 +53,21 @@ class diagnostic_counter_mock : public hlasm_plugin::parser_library::diagnostics
 class benchmark_test : public testing::Test
 {
 public:
-    benchmark_test() {};
+    benchmark_test()
+        : lib_provider({ { "MAC",
+                             R"(   MACRO
+       MAC   &VAR
+       LR    &VAR,&VAR
+       MEND
+)" },
+            { "COPYFILE",
+                R"(R2 EQU 2
+            LR R2,R2)" } }) {};
     void SetUp() override {}
     void TearDown() override {}
     void setUpAnalyzer(const std::string& content)
     {
-        a = std::make_unique<analyzer>(content, analyzer_options { SOURCE_FILE, &lib_provider });
+        a = std::make_unique<analyzer>(content, analyzer_options { "OPENCODE", &lib_provider });
         a->analyze();
     }
 
diff --git a/parser_library/test/mock_parse_lib_provider.h b/parser_library/test/mock_parse_lib_provider.h
index 62b917dd5..afa664717 100644
--- a/parser_library/test/mock_parse_lib_provider.h
+++ b/parser_library/test/mock_parse_lib_provider.h
@@ -14,51 +14,55 @@
 
 #include "analyzer.h"
 
-constexpr const char* MACRO_FILE = "MAC";
-constexpr const char* SOURCE_FILE = "OPEN";
-constexpr const char* COPY_FILE = "path/COPYFILE";
+
 
 namespace hlasm_plugin::parser_library {
 
 class mock_parse_lib_provider : public workspaces::parse_lib_provider
 {
+    std::unordered_map<std::string, std::string> m_files;
+
 public:
+    std::unordered_map<std::string, std::unique_ptr<analyzer>> analyzers;
+
+    mock_parse_lib_provider() = default;
+    mock_parse_lib_provider(std::initializer_list<std::pair<std::string, std::string>> entries)
+        : m_files(entries.begin(), entries.end())
+    {}
+    template<typename T>
+    mock_parse_lib_provider(T&& c)
+        : m_files(c.begin(), c.end())
+    {}
+
     workspaces::parse_result parse_library(
-        const std::string&, analyzing_context ctx, workspaces::library_data data) override
+        const std::string& library, analyzing_context ctx, workspaces::library_data data) override
     {
-        analyzer a(data.proc_kind == processing::processing_kind::MACRO ? macro_contents : copy_contents,
-            analyzer_options {
-                data.proc_kind == processing::processing_kind::MACRO ? MACRO_FILE : COPY_FILE,
-                this,
-                std::move(ctx),
-                data,
-            });
+        auto it = m_files.find(library);
+        if (it == m_files.end())
+            return false;
 
-        a.analyze();
+        auto a = std::make_unique<analyzer>(it->second, analyzer_options { library, this, std::move(ctx), data });
+        a->analyze();
+        a->collect_diags();
+        analyzers[library] = std::move(a);
         return true;
     }
-    bool has_library(const std::string&, const std::string&) const override { return true; }
+
+    bool has_library(const std::string& library, const std::string&) const override { return m_files.count(library); }
+
+
     std::optional<std::string> get_library(
-        const std::string& library, const std::string& program, std::string*) const override
+        const std::string& library, const std::string&, std::string* uri) const override
     {
-        if (library == "MAC")
-            return macro_contents;
-        else if (library == "COPYFILE")
-            return copy_contents;
-        else
+        auto it = m_files.find(library);
+        if (it == m_files.end())
             return std::nullopt;
-    }
 
-private:
-    const std::string macro_contents =
-        R"(   MACRO
-       MAC   &VAR
-       LR    &VAR,&VAR
-       MEND
-)";
-    const std::string copy_contents =
-        R"(R2 EQU 2
-            LR R2,R2)";
+        if (uri)
+            *uri = library;
+
+        return it->second;
+    }
 };
 
 } // namespace hlasm_plugin::parser_library
\ No newline at end of file
diff --git a/parser_library/test/processing/aread_test.cpp b/parser_library/test/processing/aread_test.cpp
index 3c7dd71ce..7e743c1bb 100644
--- a/parser_library/test/processing/aread_test.cpp
+++ b/parser_library/test/processing/aread_test.cpp
@@ -15,6 +15,7 @@
 #include "gtest/gtest.h"
 
 #include "../common_testing.h"
+#include "../mock_parse_lib_provider.h"
 
 // tests for
 // AREAD handling
@@ -309,46 +310,10 @@ Line5
     EXPECT_EQ(diags[0].diag_range.start.line, 15);
 }
 
-namespace {
-class asm_options_invalid_lib_provider : public parse_lib_provider
-{
-    std::unordered_map<std::string, std::string> m_files;
-
-public:
-    parse_result parse_library(const std::string& library, analyzing_context ctx, library_data data) override
-    {
-        auto it = m_files.find(library);
-        if (it == m_files.end())
-            return false;
-
-        auto a = std::make_unique<analyzer>(it->second, analyzer_options { library, this, std::move(ctx), data });
-        a->analyze();
-        a->collect_diags();
-        return true;
-    }
-
-    bool has_library(const std::string& library, const std::string&) const override { return m_files.count(library); }
-
-    asm_options_invalid_lib_provider(std::initializer_list<std::pair<std::string, std::string>> entries)
-    {
-        for (const auto& e : entries)
-            m_files.insert(e);
-    }
-    std::optional<std::string> get_library(const std::string& library, const std::string&, std::string*) const override
-    {
-        auto it = m_files.find(library);
-        if (it == m_files.end())
-            return std::nullopt;
-
-        return it->second;
-    }
-};
-} // namespace
-
 TEST(aread, macro_called_in_copybook)
 {
     std::string input = " COPY  COPYBOOK";
-    asm_options_invalid_lib_provider lib_provider {
+    mock_parse_lib_provider lib_provider {
         { "COPYBOOK", R"(
           MACRO
           M
@@ -379,7 +344,7 @@ TEST(aread, macro_called_in_copybook)
 TEST(aread, aread_from_source_stack)
 {
     std::string input = " COPY  COPYCOPY";
-    asm_options_invalid_lib_provider lib_provider {
+    mock_parse_lib_provider lib_provider {
         { "MAC", R"(*
           MACRO
           MAC
@@ -416,7 +381,7 @@ TEST(aread, aread_from_opencode)
           COPY  COPYCOPY
 &A1       SETA  1                                                      X this line is removed by the macro
 &A2       SETA  2)";
-    asm_options_invalid_lib_provider lib_provider {
+    mock_parse_lib_provider lib_provider {
         { "MAC", R"(*
           MACRO
           MAC
@@ -450,7 +415,7 @@ TEST(aread, aread_across_stack)
 &A1       SETA  1                                                      X this line is removed by the macro
 &A2       SETA  2
 )";
-    asm_options_invalid_lib_provider lib_provider {
+    mock_parse_lib_provider lib_provider {
         { "MAC", R"(*
           MACRO
           MAC
@@ -492,7 +457,7 @@ TEST(aread, aread_from_macro_invoked_from_ainsert)
 &A1       SETA  1                                                      X this line is removed by the macro
 &A2       SETA  2
 )";
-    asm_options_invalid_lib_provider lib_provider {
+    mock_parse_lib_provider lib_provider {
         { "MAC", R"(*
           MACRO
           MAC
@@ -534,7 +499,7 @@ TEST(aread, last_statements_in_copy)
 &A1       SETA  1                                                      X this line is removed by the macro
 &A2       SETA  2
 )";
-    asm_options_invalid_lib_provider lib_provider {
+    mock_parse_lib_provider lib_provider {
         { "MAC", R"(*
           MACRO
           MAC
@@ -564,7 +529,7 @@ TEST(aread, last_statements_in_copy)
 TEST(aread, interleave_aread_ainsert)
 {
     std::string input = R"( COPY  COPYBOOK)";
-    asm_options_invalid_lib_provider lib_provider {
+    mock_parse_lib_provider lib_provider {
         { "MAC", R"(*
           MACRO
           MAC &CALL=1
@@ -601,7 +566,7 @@ removed on first call                                                  X
 TEST(aread, copy_in_macro)
 {
     std::string input = R"( COPY  COPYBOOK)";
-    asm_options_invalid_lib_provider lib_provider {
+    mock_parse_lib_provider lib_provider {
         { "MAC", R"(*
           MACRO
           MAC
@@ -635,7 +600,7 @@ TEST(aread, copy_in_macro)
 TEST(aread, normal_processing_recovery)
 {
     std::string input = R"( COPY  COPYBOOK)";
-    asm_options_invalid_lib_provider lib_provider {
+    mock_parse_lib_provider lib_provider {
         { "MAC", R"(*
           MACRO
           MAC
@@ -668,7 +633,7 @@ TEST(aread, normal_processing_recovery)
 TEST(aread, normal_processing_recovery_line_skipped)
 {
     std::string input = R"( COPY  COPYBOOK)";
-    asm_options_invalid_lib_provider lib_provider {
+    mock_parse_lib_provider lib_provider {
         { "MAC", R"(*
           MACRO
           MAC
diff --git a/parser_library/test/processing/copy_test.cpp b/parser_library/test/processing/copy_test.cpp
index e68da74a0..b427a6eea 100644
--- a/parser_library/test/processing/copy_test.cpp
+++ b/parser_library/test/processing/copy_test.cpp
@@ -13,11 +13,148 @@
  */
 
 #include "../common_testing.h"
-#include "../copy_mock.h"
+#include "../mock_parse_lib_provider.h"
 
 // test for COPY instruction
 // various cases of instruction occurence in the source
+namespace {
+mock_parse_lib_provider create_copy_mock()
+{
+    static const std::string content_COPYR =
+        R"(   
+ LR 1,1
+ MACRO
+ M1
+ LR 1,1
+ 
+ MACRO
+ M2
+ LR 2,2
+ MEND
+ AGO .A
+.A ANOP
+ MEND
 
+&VARX SETA &VARX+1
+.A ANOP
+.B ANOP
+&VAR SETA &VAR+1
+)";
+    static const std::string content_COPYF =
+        R"(  
+ LR 1,1
+&VARX SETA &VARX+1
+ COPY COPYR
+&VAR SETA &VAR+1
+.C ANOP
+)";
+
+    static const std::string content_COPYD =
+        R"(  
+
+ LR 1,
+)";
+
+    static const std::string content_COPYREC =
+        R"(  
+ ANOP
+ COPY COPYREC
+ ANOP
+)";
+
+    static const std::string content_COPYU =
+        R"(  
+ ANOP
+ MACRO
+ M
+ MEND
+ MEND
+ ANOP
+)";
+
+    static const std::string content_COPYL =
+        R"(  
+ LR 1,1
+.A ANOP
+&VARX SETA &VARX+1
+ AGO .X
+&VAR SETA &VAR+1
+.A ANOP
+.C ANOP
+)";
+
+    static const std::string content_COPYN =
+        R"( 
+ MAC
+)";
+
+    static const std::string content_MAC =
+        R"( MACRO
+ MAC
+ LR 1,1
+ COPY COPYM
+ MEND
+)";
+
+    static const std::string content_COPYM =
+        R"(
+.A ANOP
+ GBLA &X
+&X SETA 4
+)";
+
+    static const std::string content_COPYJ =
+        R"(
+ AGO .X
+ ;%
+.X ANOP
+)";
+    static const std::string content_COPYJF =
+        R"(
+ AGO .X
+ LR
+)";
+
+    static const std::string content_COPYND1 =
+        R"(
+ COPY COPYND2
+)";
+
+    static const std::string content_COPYND2 =
+        R"(
+
+
+
+ LR 1,)";
+
+    static const std::string content_COPYBM =
+        R"( 
+ MACRO
+ M
+ LR 1
+ MEND
+)";
+    static const std::string content_EMPTY = "";
+    static const std::string content_COPYEMPTY = " COPY EMPTY";
+
+    return mock_parse_lib_provider { { "COPYR", content_COPYR },
+        { "COPYF", content_COPYF },
+        { "COPYD", content_COPYD },
+        { "COPYREC", content_COPYREC },
+        { "COPYU", content_COPYU },
+        { "COPYL", content_COPYL },
+        { "COPYN", content_COPYN },
+        { "MAC", content_MAC },
+        { "COPYM", content_COPYM },
+        { "COPYJ", content_COPYJ },
+        { "COPYJF", content_COPYJF },
+        { "COPYND1", content_COPYND1 },
+        { "COPYND2", content_COPYND2 },
+        { "COPYBM", content_COPYBM },
+        { "EMPTY", content_EMPTY },
+        { "COPYEMPTY", content_COPYEMPTY } };
+}
+} // namespace
 TEST(copy, copy_enter_fail)
 {
     std::string input =
@@ -25,8 +162,8 @@ TEST(copy, copy_enter_fail)
  COPY A+1
  COPY UNKNOWN
 )";
-    copy_mock mock;
-    analyzer a(input, analyzer_options { &mock });
+    auto lib_provider = create_copy_mock();
+    analyzer a(input, analyzer_options { &lib_provider });
     a.analyze();
 
     a.collect_diags();
@@ -43,8 +180,8 @@ TEST(copy, copy_enter_success)
         R"(
  COPY COPYR
 )";
-    copy_mock mock;
-    analyzer a(input, analyzer_options { &mock });
+    auto lib_provider = create_copy_mock();
+    analyzer a(input, analyzer_options { &lib_provider });
     a.analyze();
 
     a.collect_diags();
@@ -64,8 +201,8 @@ TEST(copy, copy_enter_diag_test)
         R"(
  COPY COPYD
 )";
-    copy_mock mock;
-    analyzer a(input, analyzer_options { "start", &mock });
+    auto lib_provider = create_copy_mock();
+    analyzer a(input, analyzer_options { "start", &lib_provider });
     a.analyze();
 
     a.collect_diags();
@@ -92,8 +229,8 @@ TEST(copy, copy_jump)
  COPY COPYF
  AIF (&VAR LT 4).A
 )";
-    copy_mock mock;
-    analyzer a(input, analyzer_options { &mock });
+    auto lib_provider = create_copy_mock();
+    analyzer a(input, analyzer_options { &lib_provider });
     a.analyze();
 
     a.collect_diags();
@@ -102,18 +239,8 @@ TEST(copy, copy_jump)
 
     EXPECT_EQ(a.diags().size(), (size_t)0);
 
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("VAR"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<context::A_t>()
-                  ->get_value(),
-        4);
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("VARX"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<context::A_t>()
-                  ->get_value(),
-        2);
+    EXPECT_EQ(get_var_value<context::A_t>(a.hlasm_ctx(), "VAR"), 4);
+    EXPECT_EQ(get_var_value<context::A_t>(a.hlasm_ctx(), "VARX"), 2);
 }
 
 TEST(copy, copy_unbalanced_macro)
@@ -122,8 +249,8 @@ TEST(copy, copy_unbalanced_macro)
         R"(
  COPY COPYU
 )";
-    copy_mock mock;
-    analyzer a(input, analyzer_options { &mock });
+    auto lib_provider = create_copy_mock();
+    analyzer a(input, analyzer_options { &lib_provider });
     a.analyze();
 
     a.collect_diags();
@@ -132,7 +259,8 @@ TEST(copy, copy_unbalanced_macro)
 
     EXPECT_EQ(a.diags().size(), (size_t)0);
 
-    EXPECT_EQ(mock.a->diags().size(), (size_t)1);
+    EXPECT_EQ(lib_provider.analyzers.count("COPYU"), 1U);
+    EXPECT_EQ(lib_provider.analyzers["COPYU"]->diags().size(), 1U);
 }
 
 TEST(copy, copy_twice)
@@ -142,8 +270,8 @@ TEST(copy, copy_twice)
  COPY COPYR
  COPY COPYR
 )";
-    copy_mock mock;
-    analyzer a(input, analyzer_options { &mock });
+    auto lib_provider = create_copy_mock();
+    analyzer a(input, analyzer_options { &lib_provider });
     a.analyze();
 
     a.collect_diags();
@@ -161,8 +289,8 @@ TEST(copy, macro_call_from_copy_enter)
  M1
  M2
 )";
-    copy_mock mock;
-    analyzer a(input, analyzer_options { &mock });
+    auto lib_provider = create_copy_mock();
+    analyzer a(input, analyzer_options { &lib_provider });
     a.analyze();
 
     a.collect_diags();
@@ -187,8 +315,8 @@ TEST(copy, copy_enter_from_macro_call)
 
  M
 )";
-    copy_mock mock;
-    analyzer a(input, analyzer_options { "start", &mock });
+    auto lib_provider = create_copy_mock();
+    analyzer a(input, analyzer_options { "start", &lib_provider });
     a.analyze();
 
     a.collect_diags();
@@ -226,20 +354,15 @@ TEST(copy, copy_enter_from_lookahead)
 &V SETA &V+1
  
 )";
-    copy_mock mock;
-    analyzer a(input, analyzer_options { "start", &mock });
+    auto lib_provider = create_copy_mock();
+    analyzer a(input, analyzer_options { "start", &lib_provider });
     a.analyze();
 
     a.collect_diags();
 
     EXPECT_EQ(a.hlasm_ctx().copy_members().size(), (size_t)1);
 
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("V"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<context::A_t>()
-                  ->get_value(),
-        1);
+    EXPECT_EQ(get_var_value<context::A_t>(a.hlasm_ctx(), "V"), 1);
 
     ASSERT_EQ(a.diags().size(), (size_t)1);
 
@@ -257,8 +380,8 @@ TEST(copy, nested_macro_copy_call)
  COPY COPYN
  
 )";
-    copy_mock mock;
-    analyzer a(input, analyzer_options { &mock });
+    auto lib_provider = create_copy_mock();
+    analyzer a(input, analyzer_options { &lib_provider });
     a.analyze();
 
     a.collect_diags();
@@ -288,8 +411,8 @@ TEST(copy, macro_from_copy_call)
  M
  
 )";
-    copy_mock mock;
-    analyzer a(input, analyzer_options { "start", &mock });
+    auto lib_provider = create_copy_mock();
+    analyzer a(input, analyzer_options { "start", &lib_provider });
     a.analyze();
 
     a.collect_diags();
@@ -316,8 +439,8 @@ TEST(copy, inner_copy_jump)
  LR
  
 )";
-    copy_mock mock;
-    analyzer a(input, analyzer_options { &mock });
+    auto lib_provider = create_copy_mock();
+    analyzer a(input, analyzer_options { &lib_provider });
     a.analyze();
 
     a.collect_diags();
@@ -334,8 +457,8 @@ TEST(copy, jump_from_copy_fail)
         R"(
  COPY COPYJF
 )";
-    copy_mock mock;
-    analyzer a(input, analyzer_options { "start", &mock });
+    auto lib_provider = create_copy_mock();
+    analyzer a(input, analyzer_options { "start", &lib_provider });
     a.analyze();
 
     a.collect_diags();
@@ -369,8 +492,8 @@ TEST(copy, jump_in_macro_from_copy_fail)
 
  m
 )";
-    copy_mock mock;
-    analyzer a(input, analyzer_options { "start", &mock });
+    auto lib_provider = create_copy_mock();
+    analyzer a(input, analyzer_options { "start", &lib_provider });
     a.analyze();
 
     a.collect_diags();
@@ -401,8 +524,8 @@ TEST(copy, macro_nested_diagnostics)
  
  MAC  
 )";
-    copy_mock mock;
-    analyzer a(input, analyzer_options { "start", &mock });
+    auto lib_provider = create_copy_mock();
+    analyzer a(input, analyzer_options { "start", &lib_provider });
     a.analyze();
 
     a.collect_diags();
@@ -431,8 +554,8 @@ TEST(copy, copy_call_with_jump_before_comment)
 ***
  ANOP
 )";
-    copy_mock mock;
-    analyzer a(input, analyzer_options { "start", &mock });
+    auto lib_provider = create_copy_mock();
+    analyzer a(input, analyzer_options { "start", &lib_provider });
     a.analyze();
 
     a.collect_diags();
@@ -457,8 +580,8 @@ TEST(copy, copy_empty_file)
  COPY EMPTY
  MEND
 )";
-    copy_mock mock;
-    analyzer a(input, analyzer_options { "start", &mock });
+    auto lib_provider = create_copy_mock();
+    analyzer a(input, analyzer_options { "start", &lib_provider });
     a.analyze();
 
     a.collect_diags();
diff --git a/parser_library/test/processing/db2_preprocessor_test.cpp b/parser_library/test/processing/db2_preprocessor_test.cpp
index ce6c9496d..b73b8e171 100644
--- a/parser_library/test/processing/db2_preprocessor_test.cpp
+++ b/parser_library/test/processing/db2_preprocessor_test.cpp
@@ -15,9 +15,9 @@
 #include <unordered_map>
 
 #include "../common_testing.h"
+#include "../mock_parse_lib_provider.h"
 #include "preprocessor_options.h"
 #include "processing/preprocessor.h"
-
 // test db2 preprocessor emulator
 
 using namespace hlasm_plugin::parser_library::processing;
@@ -369,56 +369,9 @@ TEST(db2_preprocessor, ignore_comments)
     EXPECT_EQ(RES.value().find("*        EXEC SQL SELECT 1 FROM SYSIBM.SYSDUMMY1"), 0);
 }
 
-namespace {
-class library_provider_with_uri final : public parse_lib_provider
-{
-    std::unordered_map<std::string, std::string> m_files;
-
-    const std::pair<const std::string, std::string>* find_file(const std::string& f) const
-    {
-        if (auto it = m_files.find(f); it != m_files.end())
-            return &*it;
-        return nullptr;
-    }
-
-public:
-    parse_result parse_library(const std::string& l, analyzing_context ctx, library_data data) override
-    {
-        const auto* f = find_file(l);
-        if (!f)
-            return false;
-
-        analyzer a(f->second, analyzer_options { l, this, std::move(ctx), data });
-        a.analyze();
-        return true;
-    };
-    bool has_library(const std::string& l, const std::string&) const override { return find_file(l) != nullptr; };
-    std::optional<std::string> get_library(const std::string& l, const std::string&, std::string* uri) const override
-    {
-        const auto* f = find_file(l);
-        if (!f)
-            return std::nullopt;
-
-        if (uri)
-            *uri = f->first;
-
-        return f->second;
-    }
-
-    library_provider_with_uri(std::initializer_list<std::pair<std::string, std::string>> files)
-        : m_files(files.begin(), files.end())
-    {}
-
-    template<typename T>
-    library_provider_with_uri(T&& c)
-        : m_files(c.begin(), c.end())
-    {}
-};
-} // namespace
-
 TEST(db2_preprocessor, continuation_in_buffer)
 {
-    library_provider_with_uri libs({
+    mock_parse_lib_provider libs({
         { "MEMBER", R"(
 &A SETA 1                                                              X
                comment to be ignored
@@ -438,7 +391,7 @@ TEST(db2_preprocessor, continuation_in_buffer)
 
 TEST(db2_preprocessor, include_empty)
 {
-    library_provider_with_uri libs({
+    mock_parse_lib_provider libs({
         { "MEMBER", "" },
     });
     std::string input = " EXEC SQL INCLUDE MEMBER ";
@@ -465,7 +418,7 @@ TEST(db2_preprocessor, include_nonexistent)
 
 TEST(db2_preprocessor, ago_in_include)
 {
-    library_provider_with_uri libs({
+    mock_parse_lib_provider libs({
         { "MEMBER", R"(
         AGO  .HERE
 .HERE   ANOP
@@ -486,7 +439,7 @@ TEST(db2_preprocessor, ago_in_include)
 
 TEST(db2_preprocessor, ago_into_include)
 {
-    library_provider_with_uri libs({
+    mock_parse_lib_provider libs({
         { "MEMBER", R"(
 .HERE   ANOP
 &A      SETA 1
@@ -511,7 +464,7 @@ TEST(db2_preprocessor, ago_into_include)
 
 TEST(db2_preprocessor, ago_from_include)
 {
-    library_provider_with_uri libs({
+    mock_parse_lib_provider libs({
         { "MEMBER", R"(
 &A      SETA 1
  AGO .HERE
@@ -536,7 +489,7 @@ TEST(db2_preprocessor, ago_from_include)
 
 TEST(db2_preprocessor, ago_around_include)
 {
-    library_provider_with_uri libs({
+    mock_parse_lib_provider libs({
         { "MEMBER", R"(
 &A      SETA &A+1
 )" },
@@ -564,7 +517,7 @@ TEST(db2_preprocessor, ago_around_include)
 
 TEST(db2_preprocessor, copy_in_include)
 {
-    library_provider_with_uri libs({
+    mock_parse_lib_provider libs({
         { "COPY1", "&A1 SETA 1" },
         { "COPY2", "&A2 SETA 2" },
         { "MEMBER", R"(
@@ -696,7 +649,7 @@ A
 
     for (const auto& t : testcases)
     {
-        library_provider_with_uri libs(t.deps);
+        mock_parse_lib_provider libs(t.deps);
         analyzer a(t.opencode, analyzer_options { &libs, db2_preprocessor_options {} });
         a.analyze();
         a.collect_diags();
diff --git a/parser_library/test/processing/lookahead_test.cpp b/parser_library/test/processing/lookahead_test.cpp
index 72ba3c0f8..b8d5eb757 100644
--- a/parser_library/test/processing/lookahead_test.cpp
+++ b/parser_library/test/processing/lookahead_test.cpp
@@ -15,7 +15,7 @@
 #include "gtest/gtest.h"
 
 #include "../common_testing.h"
-#include "../expressions/expr_mocks.h"
+#include "../mock_parse_lib_provider.h"
 
 // tests for lookahead feature:
 // forward/backward jums
@@ -193,8 +193,7 @@ TEST(attribute_lookahead, lookup_triggered)
     analyzer a(input);
     auto& expr = a.parser().expr()->ca_expr;
 
-    lib_prov_mock lib;
-    evaluation_context eval_ctx { analyzing_context { a.context() }, lib };
+    evaluation_context eval_ctx { analyzing_context { a.context() }, workspaces::empty_parse_lib_provider::instance };
 
     EXPECT_EQ(expr->get_undefined_attributed_symbols(eval_ctx).size(), (size_t)1);
 
@@ -207,8 +206,7 @@ TEST(attribute_lookahead, nested_lookup_triggered)
     analyzer a(input);
     auto& expr = a.parser().expr()->ca_expr;
 
-    lib_prov_mock lib;
-    evaluation_context eval_ctx { analyzing_context { a.context() }, lib };
+    evaluation_context eval_ctx { analyzing_context { a.context() }, workspaces::empty_parse_lib_provider::instance };
 
     auto v1 = a.hlasm_ctx().create_local_variable<context::C_t>(a.hlasm_ctx().ids().add("V1"), false);
     v1->access_set_symbol<context::C_t>()->set_value("A", 0);
@@ -237,8 +235,7 @@ TEST(attribute_lookahead, lookup_not_triggered)
     analyzer a(input);
     auto& expr = a.parser().expr()->ca_expr;
 
-    lib_prov_mock lib;
-    evaluation_context eval_ctx { analyzing_context { a.context() }, lib };
+    evaluation_context eval_ctx { analyzing_context { a.context() }, workspaces::empty_parse_lib_provider::instance };
 
     // define symbol with undefined length
     auto tmp = a.hlasm_ctx().ord_ctx.create_symbol(
@@ -257,8 +254,7 @@ TEST(attribute_lookahead, lookup_of_two_refs)
     analyzer a(input);
     auto& expr = a.parser().expr()->ca_expr;
 
-    lib_prov_mock lib;
-    evaluation_context eval_ctx { analyzing_context { a.context() }, lib };
+    evaluation_context eval_ctx { analyzing_context { a.context() }, workspaces::empty_parse_lib_provider::instance };
 
     EXPECT_EQ(expr->get_undefined_attributed_symbols(eval_ctx).size(), (size_t)2);
 
@@ -271,8 +267,7 @@ TEST(attribute_lookahead, lookup_of_two_refs_but_one_symbol)
     analyzer a(input);
     auto& expr = a.parser().expr()->ca_expr;
 
-    lib_prov_mock lib;
-    evaluation_context eval_ctx { analyzing_context { a.context() }, lib };
+    evaluation_context eval_ctx { analyzing_context { a.context() }, workspaces::empty_parse_lib_provider::instance };
 
     EXPECT_EQ(expr->get_undefined_attributed_symbols(eval_ctx).size(), (size_t)1);
 
@@ -294,24 +289,9 @@ Y EQU X+1
     a.analyze();
     a.collect_diags();
 
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("A"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<C_t>()
-                  ->get_value(),
-        "T");
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("B"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<A_t>()
-                  ->get_value(),
-        10);
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("C"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<A_t>()
-                  ->get_value(),
-        10);
+    EXPECT_EQ(get_var_value<C_t>(a.hlasm_ctx(), "A"), "T");
+    EXPECT_EQ(get_var_value<A_t>(a.hlasm_ctx(), "B"), 10);
+    EXPECT_EQ(get_var_value<A_t>(a.hlasm_ctx(), "C"), 10);
 
     EXPECT_EQ(a.diags().size(), (size_t)0);
 }
@@ -328,12 +308,7 @@ X EQU 1,10,C'T'
     a.analyze();
     a.collect_diags();
 
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("A"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<A_t>()
-                  ->get_value(),
-        0);
+    EXPECT_EQ(get_var_value<A_t>(a.hlasm_ctx(), "A"), 0);
 
     EXPECT_EQ(a.diags().size(), (size_t)1);
 }
@@ -350,12 +325,7 @@ X EQU 1,Y+11,C'T'
     a.analyze();
     a.collect_diags();
 
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("A"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<A_t>()
-                  ->get_value(),
-        1);
+    EXPECT_EQ(get_var_value<A_t>(a.hlasm_ctx(), "A"), 1);
 
     EXPECT_EQ(a.diags().size(), (size_t)1);
     EXPECT_EQ(a.diags().front().diag_range.start.line, (size_t)2);
@@ -375,12 +345,7 @@ X EQU 1,2,**&
     a.analyze();
     a.collect_diags();
 
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("A"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<A_t>()
-                  ->get_value(),
-        2);
+    EXPECT_EQ(get_var_value<A_t>(a.hlasm_ctx(), "A"), 2);
 
     EXPECT_EQ(a.diags().size(), (size_t)0);
 }
@@ -399,12 +364,7 @@ X EQU 1,2,&a
     a.analyze();
     a.collect_diags();
 
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("A"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<A_t>()
-                  ->get_value(),
-        2);
+    EXPECT_EQ(get_var_value<A_t>(a.hlasm_ctx(), "A"), 2);
 
     EXPECT_EQ(a.diags().size(), (size_t)0);
 }
@@ -423,12 +383,7 @@ X EQU &a,2
     a.analyze();
     a.collect_diags();
 
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("A"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<A_t>()
-                  ->get_value(),
-        1);
+    EXPECT_EQ(get_var_value<A_t>(a.hlasm_ctx(), "A"), 1);
 
     EXPECT_EQ(a.diags().size(), (size_t)1);
 }
@@ -447,72 +402,11 @@ X EQU =**)-,2
     a.analyze();
     a.collect_diags();
 
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("A"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<A_t>()
-                  ->get_value(),
-        1);
+    EXPECT_EQ(get_var_value<A_t>(a.hlasm_ctx(), "A"), 1);
 
     EXPECT_EQ(a.diags().size(), (size_t)1);
 }
 
-class look_parse_lib_prov : public parse_lib_provider
-{
-    std::unique_ptr<analyzer> a;
-
-    std::string LIB =
-        R"( 
-X EQU 1,2,C'X'
-&WAS_IN SETB 1
-)";
-
-    std::string LIB2 =
-        R"( 
-&A SETA L'X
-&WAS_IN SETB 1
-)";
-
-    std::string LIB3 =
-        R"( 
- MAC 
-&AFTER_MAC SETB 1
-)";
-
-public:
-    parse_result parse_library(const std::string& library, analyzing_context ctx, library_data data) override
-    {
-        std::string* content;
-        if (library == "LIB")
-            content = &LIB;
-        else if (library == "LIB2")
-            content = &LIB2;
-        else if (library == "LIB3")
-            content = &LIB3;
-        else
-            return false;
-
-        a = std::make_unique<analyzer>(*content, analyzer_options { library, this, std::move(ctx), data });
-        a->analyze();
-        a->collect_diags();
-        return true;
-    }
-
-    bool has_library(const std::string&, const std::string&) const override { return false; }
-    std::optional<std::string> get_library(
-        const std::string& library, const std::string& program, std::string*) const override
-    {
-        if (library == "LIB")
-            return LIB;
-        else if (library == "LIB2")
-            return LIB2;
-        else if (library == "LIB3")
-            return LIB3;
-        else
-            return std::nullopt;
-    }
-};
-
 TEST(attribute_lookahead, lookup_to_copy)
 {
     std::string input(
@@ -522,36 +416,21 @@ TEST(attribute_lookahead, lookup_to_copy)
  COPY LIB
 &WAS_AFTER SETB 1
 )");
+    std::string LIB =
+        R"( 
+X EQU 1,2,C'X'
+&WAS_IN SETB 1
+)";
 
-    look_parse_lib_prov mock;
+    mock_parse_lib_provider mock { { "LIB", LIB } };
     analyzer a(input, analyzer_options { &mock });
     a.analyze();
     a.collect_diags();
 
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("A"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<A_t>()
-                  ->get_value(),
-        2);
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("WAS_BEFORE"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<B_t>()
-                  ->get_value(),
-        true);
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("WAS_IN"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<B_t>()
-                  ->get_value(),
-        true);
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("WAS_AFTER"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<B_t>()
-                  ->get_value(),
-        true);
+    EXPECT_EQ(get_var_value<A_t>(a.hlasm_ctx(), "A"), 2);
+    EXPECT_EQ(get_var_value<B_t>(a.hlasm_ctx(), "WAS_BEFORE"), true);
+    EXPECT_EQ(get_var_value<B_t>(a.hlasm_ctx(), "WAS_IN"), true);
+    EXPECT_EQ(get_var_value<B_t>(a.hlasm_ctx(), "WAS_AFTER"), true);
 
     EXPECT_EQ(a.diags().size(), (size_t)0);
 }
@@ -566,35 +445,21 @@ X EQU 1,2
 &WAS_AFTER SETB 1
 )");
 
-    look_parse_lib_prov mock;
+    std::string LIB2 =
+        R"( 
+&A SETA L'X
+&WAS_IN SETB 1
+)";
+
+    mock_parse_lib_provider mock { { "LIB2", LIB2 } };
     analyzer a(input, analyzer_options { &mock });
     a.analyze();
     a.collect_diags();
 
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("A"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<A_t>()
-                  ->get_value(),
-        2);
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("WAS_BEFORE"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<B_t>()
-                  ->get_value(),
-        true);
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("WAS_IN"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<B_t>()
-                  ->get_value(),
-        true);
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("WAS_AFTER"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<B_t>()
-                  ->get_value(),
-        true);
+    EXPECT_EQ(get_var_value<A_t>(a.hlasm_ctx(), "A"), 2);
+    EXPECT_EQ(get_var_value<B_t>(a.hlasm_ctx(), "WAS_BEFORE"), true);
+    EXPECT_EQ(get_var_value<B_t>(a.hlasm_ctx(), "WAS_IN"), true);
+    EXPECT_EQ(get_var_value<B_t>(a.hlasm_ctx(), "WAS_AFTER"), true);
 
     EXPECT_EQ(a.diags().size(), (size_t)0);
 }
@@ -613,8 +478,13 @@ X EQU 2,3
  COPY LIB3
 X EQU 1,2
 )");
+    std::string LIB3 =
+        R"( 
+ MAC 
+&AFTER_MAC SETB 1
+)";
 
-    look_parse_lib_prov mock;
+    mock_parse_lib_provider mock { { "LIB3", LIB3 } };
     analyzer a(input, analyzer_options { &mock });
     a.analyze();
     a.collect_diags();
@@ -626,12 +496,7 @@ X EQU 1,2
                   ->access_set_symbol<A_t>()
                   ->get_value(),
         2);
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("AFTER_MAC"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<B_t>()
-                  ->get_value(),
-        true);
+    EXPECT_EQ(get_var_value<B_t>(a.hlasm_ctx(), "AFTER_MAC"), true);
 
     EXPECT_EQ(a.diags().size(), (size_t)1);
 }
@@ -645,8 +510,7 @@ TEST(attribute_lookahead, lookup_from_macro_last_line)
  mend
          GETMAIN   b=svc)");
 
-    look_parse_lib_prov mock;
-    analyzer a(input, analyzer_options { &mock });
+    analyzer a(input);
     a.analyze();
     a.collect_diags();
 
@@ -663,8 +527,7 @@ TEST(attribute_lookahead, lookup_from_macro_one_to_last_line)
          GETMAIN   b=svc
 )");
 
-    look_parse_lib_prov mock;
-    analyzer a(input, analyzer_options { &mock });
+    analyzer a(input);
     a.analyze();
     a.collect_diags();
 
@@ -684,12 +547,7 @@ Y EQU 2,11
     a.analyze();
     a.collect_diags();
 
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("A"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<A_t>()
-                  ->get_value(),
-        21);
+    EXPECT_EQ(get_var_value<A_t>(a.hlasm_ctx(), "A"), 21);
 
     EXPECT_EQ(a.diags().size(), (size_t)0);
 }
@@ -707,18 +565,8 @@ X LR 1,1
     a.analyze();
     a.collect_diags();
 
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("A"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<A_t>()
-                  ->get_value(),
-        2);
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("B"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<C_t>()
-                  ->get_value(),
-        "I");
+    EXPECT_EQ(get_var_value<A_t>(a.hlasm_ctx(), "A"), 2);
+    EXPECT_EQ(get_var_value<C_t>(a.hlasm_ctx(), "B"), "I");
 
     EXPECT_EQ(a.diags().size(), (size_t)0);
 }
@@ -736,18 +584,8 @@ X CSECT
     a.analyze();
     a.collect_diags();
 
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("A"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<A_t>()
-                  ->get_value(),
-        1);
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("B"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<C_t>()
-                  ->get_value(),
-        "J");
+    EXPECT_EQ(get_var_value<A_t>(a.hlasm_ctx(), "A"), 1);
+    EXPECT_EQ(get_var_value<C_t>(a.hlasm_ctx(), "B"), "J");
 
     EXPECT_EQ(a.diags().size(), (size_t)0);
 }
@@ -766,24 +604,9 @@ X DC FS24'6'       remark
     a.analyze();
     a.collect_diags();
 
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("A"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<A_t>()
-                  ->get_value(),
-        4);
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("B"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<C_t>()
-                  ->get_value(),
-        "F");
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("C"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<A_t>()
-                  ->get_value(),
-        24);
+    EXPECT_EQ(get_var_value<A_t>(a.hlasm_ctx(), "A"), 4);
+    EXPECT_EQ(get_var_value<C_t>(a.hlasm_ctx(), "B"), "F");
+    EXPECT_EQ(get_var_value<A_t>(a.hlasm_ctx(), "C"), 24);
 
     EXPECT_EQ(a.diags().size(), (size_t)0);
 }
@@ -800,12 +623,7 @@ X DC C'A'
     a.analyze();
     a.collect_diags();
 
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("A"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<A_t>()
-                  ->get_value(),
-        0);
+    EXPECT_EQ(get_var_value<A_t>(a.hlasm_ctx(), "A"), 0);
 
     EXPECT_EQ(a.diags().size(), (size_t)1);
 }
@@ -823,12 +641,7 @@ Y EQU 2,11
     a.analyze();
     a.collect_diags();
 
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("A"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<A_t>()
-                  ->get_value(),
-        21);
+    EXPECT_EQ(get_var_value<A_t>(a.hlasm_ctx(), "A"), 21);
 
     EXPECT_EQ(a.diags().size(), (size_t)0);
 }
@@ -845,12 +658,7 @@ X EQU 1,10
     a.analyze();
     a.collect_diags();
 
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("A"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<A_t>()
-                  ->get_value(),
-        11);
+    EXPECT_EQ(get_var_value<A_t>(a.hlasm_ctx(), "A"), 11);
 
     EXPECT_EQ(a.diags().size(), (size_t)1);
 }
@@ -869,12 +677,7 @@ B EQU 2,22
     a.analyze();
     a.collect_diags();
 
-    EXPECT_EQ(a.hlasm_ctx()
-                  .get_var_sym(a.hlasm_ctx().ids().add("A"))
-                  ->access_set_symbol_base()
-                  ->access_set_symbol<A_t>()
-                  ->get_value(),
-        22);
+    EXPECT_EQ(get_var_value<A_t>(a.hlasm_ctx(), "A"), 22);
 
     EXPECT_EQ(a.diags().size(), (size_t)0);
 }
diff --git a/parser_library/test/processing/opsyn_test.cpp b/parser_library/test/processing/opsyn_test.cpp
index 78b3d5fc9..70828a3be 100644
--- a/parser_library/test/processing/opsyn_test.cpp
+++ b/parser_library/test/processing/opsyn_test.cpp
@@ -15,6 +15,7 @@
 #include "gtest/gtest.h"
 
 #include "../common_testing.h"
+#include "../mock_parse_lib_provider.h"
 
 // tests for OPSYN instruction
 
@@ -261,46 +262,18 @@ X OPSYN LR
     ASSERT_EQ(a.diags().size(), (size_t)1);
 }
 
-class opsyn_parse_lib_prov : public parse_lib_provider
-{
-    std::unique_ptr<analyzer> a;
-
-    std::string LIB =
-        R"( MACRO
- LR
- MEND)";
-
-public:
-    parse_result parse_library(const std::string& library, analyzing_context ctx, library_data data) override
-    {
-        std::string* content;
-        if (library == "LR")
-            content = &LIB;
-        else
-            return false;
-
-        a = std::make_unique<analyzer>(*content, analyzer_options { library, this, std::move(ctx), data });
-        a->analyze();
-        a->collect_diags();
-        return true;
-    }
-
-    bool has_library(const std::string&, const std::string&) const override { return false; }
-    std::optional<std::string> get_library(const std::string& library, const std::string&, std::string*) const override
-    {
-        if (library == "LR")
-            return LIB;
-        return std::nullopt;
-    }
-};
-
 TEST(OPSYN, macro_after_delete)
 {
     std::string input(R"(
 LR OPSYN
    LR
 )");
-    opsyn_parse_lib_prov mock;
+
+    std::string LIB =
+        R"( MACRO
+ LR
+ MEND)";
+    mock_parse_lib_provider mock { { "LR", LIB } };
     analyzer a(input, analyzer_options { &mock });
     a.analyze();
     a.collect_diags();
diff --git a/parser_library/test/workspace/macro_cache_test.cpp b/parser_library/test/workspace/macro_cache_test.cpp
index adc35d3be..68f724bb4 100644
--- a/parser_library/test/workspace/macro_cache_test.cpp
+++ b/parser_library/test/workspace/macro_cache_test.cpp
@@ -330,6 +330,10 @@ TEST(macro_cache_test, overwrite_by_inline)
     auto opencode = file_mngr.add_opencode(opencode_file_name, opencode_text);
     auto& [macro, macro_c] = file_mngr.add_macro_or_copy(macro_file_name, macro_text);
 
+    opencode->parse(file_mngr, {}, {});
+    opencode->collect_diags();
+    opencode->diags().clear();
+
     opencode->parse(file_mngr, {}, {});
     opencode->collect_diags();
     EXPECT_EQ(opencode->diags().size(), 2U);