diff --git a/BUILD.bazel b/BUILD.bazel
new file mode 100644
index 000000000..365854e05
--- /dev/null
+++ b/BUILD.bazel
@@ -0,0 +1,151 @@
+load(
+    "@gz//bazel/skylark:build_defs.bzl",
+    "GZ_FEATURES",
+    "GZ_ROOT",
+    "GZ_VISIBILITY",
+    "gz_configure_header",
+    "gz_export_header",
+    "gz_include_header",
+)
+load("@gz//bazel/skylark:gz_py.bzl", "gz_py_binary")
+
+package(
+    default_visibility = GZ_VISIBILITY,
+    features = GZ_FEATURES,
+)
+
+licenses(["notice"])  # Apache-2.0
+
+exports_files(["LICENSE"])
+
+gz_configure_header(
+    name = "config",
+    src = "include/sdf/config.hh.in",
+    cmakelists = ["CMakeLists.txt"],
+    defines = {
+        "CMAKE_INSTALL_FULL_DATAROOTDIR": "",
+    },
+    package = "sdformat",
+)
+
+gz_py_binary(
+    name = "embed_sdf",
+    srcs = ["sdf/embedSdf.py"],
+)
+
+genrule(
+    name = "embed_sdf_genrule",
+    srcs = glob([
+        "sdf/**/*.sdf",
+        "sdf/**/*.convert",
+    ]),
+    outs = ["EmbeddedSdf.cc"],
+    cmd = "$(execpath :embed_sdf) --output-file $@ --sdf-root ./sdformat/sdf --input-files $(SRCS)", # noqa
+    tools = [":embed_sdf"],
+)
+
+public_headers_no_gen = glob([
+    "include/sdf/*.h",
+    "include/sdf/*.hh",
+])
+
+private_headers = glob(["src/*.hh"])
+
+sources = glob(
+    ["src/*.cc"],
+    exclude = [
+        "src/*_TEST.cc",
+        "src/gz.cc",
+    ],
+)
+
+gz_export_header(
+    name = "include/sdf/Export.hh",
+    export_base = "GZ_SDFORMAT",
+    lib_name = "sdf",
+    visibility = ["//visibility:private"],
+)
+
+gz_include_header(
+    name = "sdformat_hh_genrule",
+    out = "include/sdformat.hh",
+    hdrs = public_headers_no_gen + [
+        "include/sdf/config.hh",
+        "include/sdf/Export.hh",
+    ],
+)
+
+public_headers = public_headers_no_gen + [
+    "include/sdf/Export.hh",
+    "include/sdf/config.hh",
+    "include/sdformat.hh",
+]
+
+cc_library(
+    name = "urdf",
+    srcs = [
+        "src/urdf/urdf_parser/joint.cpp",
+        "src/urdf/urdf_parser/link.cpp",
+        "src/urdf/urdf_parser/model.cpp",
+        "src/urdf/urdf_parser/pose.cpp",
+        "src/urdf/urdf_parser/twist.cpp",
+        "src/urdf/urdf_parser/urdf_model_state.cpp",
+        "src/urdf/urdf_parser/urdf_sensor.cpp",
+        "src/urdf/urdf_parser/world.cpp",
+    ],
+    hdrs = glob(
+        ["src/urdf/**/*.h"],
+    ),
+    copts = ["-Wno-unknown-pragmas"],
+    includes = ["src/urdf"],
+    deps = [
+        "@tinyxml2",
+    ],
+)
+
+cc_library(
+    name = "sdformat",
+    srcs = sources + private_headers + ["EmbeddedSdf.cc"],
+    hdrs = public_headers,
+    includes = [
+        "include",
+        "src",
+    ],
+    defines = [
+      'SDF_SHARE_PATH=\\".\\"',
+      'SDF_VERSION_PATH=\\"sdformat\\"',
+    ],
+    deps = [
+        ":urdf",
+        GZ_ROOT + "math",
+        GZ_ROOT + "utils",
+        "@tinyxml2",
+    ],
+)
+
+test_sources = glob(
+    ["src/*_TEST.cc"],
+    exclude = ["src/gz_TEST.cc"],
+)
+
+[cc_test(
+    name = src.replace("/", "_").replace(".cc", "").replace("src_", ""),
+    srcs = [src],
+    data = [
+        "sdf",
+        GZ_ROOT + "sdformat/test:integration",
+        GZ_ROOT + "sdformat/test:sdf",
+    ],
+    env = {
+        "GZ_BAZEL": "1",
+        "GZ_BAZEL_PATH": "sdformat",
+    },
+    deps = [
+        ":sdformat",
+        GZ_ROOT + "sdformat/test:test_utils",
+        "@gtest",
+        "@gtest//:gtest_main",
+    ],
+) for src in test_sources]
+
+exports_files(["sdf"])
diff --git a/include/sdf/config.hh.in b/include/sdf/config.hh.in
index d1b3db532..7b128ebad 100644
--- a/include/sdf/config.hh.in
+++ b/include/sdf/config.hh.in
@@ -47,7 +47,12 @@
 
 #cmakedefine SDFORMAT_DISABLE_CONSOLE_LOGFILE 1
 
+#ifndef SDF_SHARE_PATH
 #define SDF_SHARE_PATH "${CMAKE_INSTALL_FULL_DATAROOTDIR}/"
+#endif
+
+#ifndef SDF_VERSION_PATH
 #define SDF_VERSION_PATH "${CMAKE_INSTALL_FULL_DATAROOTDIR}/sdformat${SDF_MAJOR_VERSION}/${SDF_PKG_VERSION}"
+#endif 
 
 #endif  // #ifndef SDF_CONFIG_HH_
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index feab8e716..fbf8cd0cf 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -61,6 +61,13 @@ if (BUILD_TESTING)
       XmlUtils.cc)
   endif()
 
+  if (TARGET UNIT_gz_TEST)
+    target_compile_definitions(UNIT_gz_TEST PRIVATE
+      -DGZ_PATH="${GZ_PROGRAM}"
+      -DGZ_CONFIG_PATH="${CMAKE_BINARY_DIR}/test/conf"
+      -DGZ_TEST_LIBRARY_PATH="${PROJECT_BINARY_DIR}/src")
+  endif()
+
   if (TARGET UNIT_FrameSemantics_TEST)
     target_sources(UNIT_FrameSemantics_TEST PRIVATE FrameSemantics.cc Utils.cc)
     target_link_libraries(UNIT_FrameSemantics_TEST TINYXML2::TINYXML2)
diff --git a/src/SDF.cc b/src/SDF.cc
index 395119a01..c28ba4400 100644
--- a/src/SDF.cc
+++ b/src/SDF.cc
@@ -43,6 +43,15 @@ inline namespace SDF_VERSION_NAMESPACE
 // returns the version string when possible.
 std::string SDF::version = SDF_VERSION;  // NOLINT(runtime/string)
 
+std::string sdfSharePath()
+{
+#ifdef SDF_SHARE_PATH
+  if (std::string(SDF_SHARE_PATH) != "/")
+    return SDF_SHARE_PATH;
+#endif
+  return "";
+}
+
 /////////////////////////////////////////////////
 void setFindCallback(std::function<std::string(const std::string &)> _cb)
 {
@@ -98,14 +107,14 @@ std::string findFile(const std::string &_filename, bool _searchLocalPath,
   }
 
   // Next check the install path.
-  std::string path = sdf::filesystem::append(SDF_SHARE_PATH, filename);
+  std::string path = sdf::filesystem::append(sdfSharePath(), filename);
   if (sdf::filesystem::exists(path))
   {
     return path;
   }
 
   // Next check the versioned install path.
-  path = sdf::filesystem::append(SDF_SHARE_PATH,
+  path = sdf::filesystem::append(sdfSharePath(),
                                  "sdformat" SDF_MAJOR_VERSION_STR,
                                  sdf::SDF::Version(), filename);
   if (sdf::filesystem::exists(path))
diff --git a/src/gz_TEST.cc b/src/gz_TEST.cc
index 9d4bde234..266bea8c7 100644
--- a/src/gz_TEST.cc
+++ b/src/gz_TEST.cc
@@ -22,6 +22,7 @@
 #include <string>
 
 #include <gz/utils/ExtraTestMacros.hh>
+#include <gz/utils/Environment.hh>
 
 #include "sdf/Error.hh"
 #include "sdf/Filesystem.hh"
@@ -70,12 +71,9 @@ std::string custom_exec_str(std::string _cmd)
 /////////////////////////////////////////////////
 TEST(checkUnrecognizedElements, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 {
-  std::string pathBase = PROJECT_SOURCE_PATH;
-  pathBase += "/test/sdf";
-
   // Check an SDFormat file with unrecognized elements
   {
-    std::string path = pathBase +"/unrecognized_elements.sdf";
+    const auto path = sdf::testing::TestFile("sdf", "unrecognized_elements.sdf");
 
     std::string output =
       custom_exec_str(GzCommand() + " sdf -k " + path + SdfVersion());
@@ -100,7 +98,7 @@ TEST(checkUnrecognizedElements, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 
   // Check an SDFormat file with unrecognized elements with XML namespaces
   {
-    std::string path = pathBase +"/unrecognized_elements_with_namespace.sdf";
+    const auto path = sdf::testing::TestFile("sdf", "unrecognized_elements_with_namespace.sdf");
 
     std::string output =
       custom_exec_str(GzCommand() + " sdf -k " + path + SdfVersion());
@@ -118,12 +116,10 @@ TEST(checkUnrecognizedElements, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 /////////////////////////////////////////////////
 TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 {
-  std::string pathBase = PROJECT_SOURCE_PATH;
-  pathBase += "/test/sdf";
-
   // Check a good SDF file
   {
-    std::string path = pathBase +"/box_plane_low_friction_test.world";
+    const auto path =
+      sdf::testing::TestFile("sdf", "box_plane_low_friction_test.world");
 
     // Check box_plane_low_friction_test.world
     std::string output =
@@ -133,7 +129,8 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 
   // Check a bad SDF file
   {
-    std::string path = pathBase +"/box_bad_test.world";
+    const auto path =
+      sdf::testing::TestFile("sdf", "box_bad_test.world");
 
     // Check box_bad_test.world
     std::string output =
@@ -145,7 +142,8 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
   // Check an SDF file with sibling elements of the same type (world)
   // that have duplicate names.
   {
-    std::string path = pathBase +"/world_duplicate.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf", "world_duplicate.world");
 
     // Check world_duplicate.sdf
     std::string output =
@@ -157,7 +155,8 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
   // Check an SDF file with sibling elements of different types (model, light)
   // that have duplicate names.
   {
-    std::string path = pathBase +"/world_sibling_same_names.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf", "world_sibling_same_names.sdf");
 
     // Check world_sibling_same_names.sdf
     std::string output =
@@ -167,7 +166,8 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
   }
   // Check an SDF world file is allowed to have duplicate plugin names
   {
-    std::string path = pathBase +"/world_duplicate_plugins.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf", "world_duplicate_plugins.sdf");
 
     std::string output =
       custom_exec_str(GzCommand() + " sdf -k " + path + SdfVersion());
@@ -177,7 +177,8 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
   // Check an SDF file with sibling elements of the same type (link)
   // that have duplicate names.
   {
-    std::string path = pathBase +"/model_duplicate_links.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf", "model_duplicate_links.sdf");
 
     // Check model_duplicate_links.sdf
     std::string output =
@@ -189,7 +190,8 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
   // Check an SDF file with sibling elements of the same type (joint)
   // that have duplicate names.
   {
-    std::string path = pathBase +"/model_duplicate_joints.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf", "model_duplicate_joints.sdf");
 
     // Check model_duplicate_joints.sdf
     std::string output =
@@ -201,7 +203,8 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
   // Check an SDF file with sibling elements of different types (link, joint)
   // that have duplicate names.
   {
-    std::string path = pathBase +"/model_link_joint_same_name.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf", "model_link_joint_same_name.sdf");
 
     // Check model_link_joint_same_name.sdf
     std::string output =
@@ -212,7 +215,8 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 
   // Check an SDF model file is allowed to have duplicate plugin names
   {
-    std::string path = pathBase +"/model_duplicate_plugins.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf", "model_link_duplicate_plugins.sdf");
 
     std::string output =
       custom_exec_str(GzCommand() + " sdf -k " + path + SdfVersion());
@@ -222,7 +226,9 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
   // Check an SDF file with sibling elements of the same type (collision)
   // that have duplicate names.
   {
-    std::string path = pathBase +"/link_duplicate_sibling_collisions.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "link_duplicate_sibling_collisions.sdf");
 
     // Check link_duplicate_sibling_collisions.sdf
     std::string output =
@@ -235,7 +241,9 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
   // Check an SDF file with sibling elements of the same type (visual)
   // that have duplicate names.
   {
-    std::string path = pathBase +"/link_duplicate_sibling_visuals.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "link_duplicate_sibling_visuals.sdf");
 
     // Check link_duplicate_sibling_visuals.sdf
     std::string output =
@@ -247,7 +255,9 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
   // Check an SDF file with cousin elements of the same type (collision)
   // that have duplicate names. This is a valid file.
   {
-    std::string path = pathBase +"/link_duplicate_cousin_collisions.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "link_duplicate_cousin_collisions.sdf");
 
     // Check link_duplicate_cousin_collisions.sdf
     std::string output =
@@ -258,7 +268,9 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
   // Check an SDF file with cousin elements of the same type (visual)
   // that have duplicate names. This is a valid file.
   {
-    std::string path = pathBase +"/link_duplicate_cousin_visuals.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "link_duplicate_cousin_visuals.sdf");
 
     // Check link_duplicate_cousin_visuals.sdf
     std::string output =
@@ -268,7 +280,8 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 
   // Check an SDF file with a joint with an invalid child link.
   {
-    std::string path = pathBase +"/joint_invalid_child.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf", "joint_invalid_child.sdf");
 
     // Check joint_invalid_child.sdf
     std::string output =
@@ -281,7 +294,8 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 
   // Check an SDF file with a joint with an invalid parent link.
   {
-    std::string path = pathBase +"/joint_invalid_parent.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf", "joint_invalid_parent.sdf");
 
     // Check joint_invalid_parent.sdf
     std::string output =
@@ -294,7 +308,8 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 
   // Check an SDF file with a joint that names itself as the child frame.
   {
-    std::string path = pathBase +"/joint_invalid_self_child.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf", "joint_invalid_self_child.sdf");
 
     // Check joint_invalid_self_child.sdf
     std::string output =
@@ -306,7 +321,8 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 
   // Check an SDF file with a joint that names itself as the parent frame.
   {
-    std::string path = pathBase +"/joint_invalid_self_parent.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf", "joint_invalid_self_parent.sdf");
 
     // Check joint_invalid_self_parent.sdf
     std::string output =
@@ -319,7 +335,9 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 
   // Check an SDF file with a joint with identical parent and child.
   {
-    std::string path = pathBase +"/joint_invalid_parent_same_as_child.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "joint_invalid_parent_same_as_child.sdf");
 
     // Check joint_invalid_parent_same_as_child.sdf
     std::string output =
@@ -333,8 +351,9 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
   // Check an SDF file with a joint with parent parent frame that resolves
   // to the same value as the child.
   {
-    std::string path =
-        pathBase + "/joint_invalid_resolved_parent_same_as_child.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "joint_invalid_resolved_parent_same_as_child.sdf");
 
     // Check joint_invalid_resolved_parent_same_as_child.sdf
     std::string output =
@@ -347,7 +366,8 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 
   // Check an SDF file with the world specified as a child link.
   {
-    std::string path = pathBase +"/joint_child_world.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf", "joint_child_world.sdf");
 
     // Check joint_child_world.sdf
     std::string output =
@@ -363,7 +383,8 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
   // Check an SDF file with the world specified as a parent link.
   // This is a valid file.
   {
-    std::string path = pathBase +"/joint_parent_world.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf", "joint_parent_world.sdf");
 
     // Check joint_parent_world.sdf
     std::string output =
@@ -374,7 +395,8 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
   // Check an SDF file with a frame specified as the joint child.
   // This is a valid file.
   {
-    std::string path = pathBase +"/joint_child_frame.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf", "joint_child_frame.sdf");
 
     // Check joint_child_frame.sdf
     std::string output =
@@ -385,7 +407,8 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
   // Check an SDF file with a frame specified as the joint parent.
   // This is a valid file.
   {
-    std::string path = pathBase +"/joint_parent_frame.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf", "joint_parent_frame.sdf");
 
     // Check joint_parent_frame.sdf
     std::string output =
@@ -396,7 +419,8 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
   // Check an SDF file with the infinite values for joint axis limits.
   // This is a valid file.
   {
-    std::string path = pathBase +"/joint_axis_infinite_limits.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf", "joint_axis_infinite_limits.sdf");
 
     // Check joint_axis_infinite_limits.sdf
     std::string output =
@@ -407,7 +431,8 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
   // Check an SDF file with the second link specified as the canonical link.
   // This is a valid file.
   {
-    std::string path = pathBase +"/model_canonical_link.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf", "model_canonical_link.sdf");
 
     // Check model_canonical_link.sdf
     std::string output =
@@ -417,7 +442,8 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 
   // Check an SDF file with an invalid link specified as the canonical link.
   {
-    std::string path = pathBase +"/model_invalid_canonical_link.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf", "model_invalid_canonical_link.sdf");
 
     // Check model_invalid_canonical_link.sdf
     std::string output =
@@ -429,7 +455,9 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 
   // Check an SDF file with an invalid model without links.
   {
-    std::string path = pathBase +"/model_without_links.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "model_without_links.sdf");
 
     // Check model_without_links.sdf
     std::string output =
@@ -440,7 +468,9 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 
   // Check an SDF file with a nested model.
   {
-    std::string path = pathBase +"/nested_model.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "nested_model.sdf");
 
     // Check nested_model.sdf
     std::string output =
@@ -450,7 +480,9 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 
   // Check an SDF file with a model that has a nested canonical link.
   {
-    std::string path = pathBase +"/nested_canonical_link.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "nested_canonical_link.sdf");
 
     // Check nested_canonical_link.sdf
     std::string output =
@@ -462,7 +494,9 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
   // that is explicitly specified by //model/@canonical_link using ::
   // syntax.
   {
-    std::string path = pathBase +"/nested_explicit_canonical_link.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "nested_explicit_canonical_link.sdf");
 
     // Check nested_explicit_canonical_link.sdf
     std::string output =
@@ -472,7 +506,9 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 
   // Check an SDF file with a model that a nested model without a link.
   {
-    std::string path = pathBase +"/nested_without_links_invalid.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "nested_without_links_invalid.sdf");
 
     // Check nested_without_links_invalid.sdf
     std::string output =
@@ -483,7 +519,9 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 
   // Check an invalid SDF file that uses reserved names.
   {
-    std::string path = pathBase +"/model_invalid_reserved_names.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "nested_invalid_reserved_names.sdf");
 
     // Check model_invalid_reserved_names.sdf
     std::string output =
@@ -509,7 +547,9 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 
   // Check that validity checks are disabled inside <plugin> elements
   {
-    std::string path = pathBase +"/ignore_sdf_in_plugin.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "ignore_sdf_in_plugin.sdf");
 
     std::string output =
       custom_exec_str(GzCommand() + " sdf -k " + path + SdfVersion());
@@ -518,7 +558,9 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 
   // Check that validity checks are disabled inside namespaced elements
   {
-    std::string path = pathBase +"/ignore_sdf_in_namespaced_elements.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "ignore_sdf_in_namespaced_elements.sdf");
 
     std::string output =
       custom_exec_str(GzCommand() + " sdf -k " + path + SdfVersion());
@@ -528,7 +570,9 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
   // Check an SDF file with model frames using the attached_to attribute.
   // This is a valid file.
   {
-    std::string path = pathBase +"/model_frame_attached_to.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "model_frame_attached_to.sdf");
 
     // Check model_frame_attached_to.sdf
     std::string output =
@@ -539,7 +583,9 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
   // Check an SDF file with model frames attached_to joints.
   // This is a valid file.
   {
-    std::string path = pathBase +"/model_frame_attached_to_joint.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "model_frame_attached_to_joint.sdf");
 
     // Check model_frame_attached_to_joint.sdf
     std::string output =
@@ -550,7 +596,9 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
   // Check an SDF file with model frames attached_to a nested model.
   // This is a valid file.
   {
-    std::string path = pathBase +"/model_frame_attached_to_nested_model.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "model_frame_attached_to_nested_model.sdf");
 
     // Check model_frame_attached_to_nested_model.sdf
     std::string output =
@@ -560,7 +608,9 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 
   // Check an SDF file with model frames with invalid attached_to attributes.
   {
-    std::string path = pathBase +"/model_frame_invalid_attached_to.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "model_frame_invalid_attached_to.sdf");
 
     // Check model_frame_invalid_attached_to.sdf
     std::string output =
@@ -578,7 +628,9 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 
   // Check an SDF file with a cycle in its FrameAttachedTo graph
   {
-    std::string path = pathBase +"/model_frame_invalid_attached_to_cycle.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "model_frame_invalid_attached_to_cycle.sdf");
 
     // Check model_frame_invalid_attached_to_cycle.sdf
     std::string output =
@@ -596,7 +648,9 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
   // Check an SDF file with model frames using the attached_to attribute.
   // This is a valid file.
   {
-    std::string path = pathBase +"/world_frame_attached_to.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "world_frame_attached_to.sdf");
 
     // Check world_frame_attached_to.sdf
     std::string output =
@@ -606,7 +660,9 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 
   // Check an SDF file with world frames with invalid attached_to attributes.
   {
-    std::string path = pathBase +"/world_frame_invalid_attached_to.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "world_frame_invalid_attached_to.sdf");
 
     // Check world_frame_invalid_attached_to.sdf
     std::string output =
@@ -626,7 +682,9 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
   // Check an SDF file with links using the relative_to attribute.
   // This is a valid file.
   {
-    std::string path = pathBase +"/model_link_relative_to.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "model_link_relative_to.sdf");
 
     // Check model_link_relative_to.sdf
     std::string output =
@@ -636,7 +694,9 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 
   // Check an SDF file with model links with invalid relative_to attributes.
   {
-    std::string path = pathBase +"/model_invalid_link_relative_to.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "model_invalid_link_relative_to.sdf");
 
     // Check model_invalid_link_relative_to.sdf
     std::string output =
@@ -655,7 +715,9 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
   // Check an SDF file with nested_models using the relative_to attribute.
   // This is a valid file.
   {
-    std::string path = pathBase +"/model_nested_model_relative_to.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "model_nested_model_relative_to.sdf");
 
     // Check model_nested_model_relative_to.sdf
     std::string output =
@@ -667,7 +729,9 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
   // parent or child frames.
   // This is a valid file.
   {
-    std::string path = pathBase +"/joint_nested_parent_child.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "joint_nested_parent_child.sdf");
 
     // Check model_nested_model_relative_to.sdf
     std::string output =
@@ -678,7 +742,9 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
   // Check an SDF file with joints using the relative_to attribute.
   // This is a valid file.
   {
-    std::string path = pathBase +"/model_joint_relative_to.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "model_joint_relative_to.sdf");
 
     // Check model_joint_relative_to.sdf
     std::string output =
@@ -688,7 +754,9 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 
   // Check an SDF file with model joints with invalid relative_to attributes.
   {
-    std::string path = pathBase +"/model_invalid_joint_relative_to.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "model_invalid_joint_relative_to.sdf");
 
     // Check model_invalid_joint_relative_to.sdf
     std::string output =
@@ -707,7 +775,9 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
   // Check an SDF file with model frames using the relative_to attribute.
   // This is a valid file.
   {
-    std::string path = pathBase +"/model_frame_relative_to.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "model_frame_relative_to.sdf");
 
     // Check model_frame_relative_to.sdf
     std::string output =
@@ -718,7 +788,9 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
   // Check an SDF file with model frames relative_to joints.
   // This is a valid file.
   {
-    std::string path = pathBase +"/model_frame_relative_to_joint.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "model_frame_relative_to_joint.sdf");
 
     // Check model_frame_relative_to_joint.sdf
     std::string output =
@@ -728,7 +800,9 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 
   // Check an SDF file with model frames with invalid relative_to attributes.
   {
-    std::string path = pathBase +"/model_invalid_frame_relative_to.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "model_invalid_frame_relative_to.sdf");
 
     // Check model_invalid_frame_relative_to.sdf
     std::string output =
@@ -746,7 +820,9 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 
   // Check an SDF file with a cycle in its PoseRelativeTo graph
   {
-    std::string path = pathBase +"/model_invalid_frame_relative_to_cycle.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "model_invalid_frame_relative_to_cycle.sdf");
 
     // Check model_invalid_frame_relative_to_cycle.sdf
     std::string output =
@@ -764,7 +840,9 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
   // Check an SDF file with model frames using the attached_to attribute.
   // This is a valid file.
   {
-    std::string path = pathBase +"/world_frame_relative_to.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "world_frame_relative_to.sdf");
 
     // Check world_frame_relative_to.sdf
     std::string output =
@@ -774,7 +852,9 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 
   // Check an SDF file with world frames with invalid relative_to attributes.
   {
-    std::string path = pathBase +"/world_frame_invalid_relative_to.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "world_frame_invalid_relative_to.sdf");
 
     // Check world_frame_invalid_relative_to.sdf
     std::string output =
@@ -803,7 +883,9 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
   // Check an SDF file with an invalid frame specified as the placement_frame
   // attribute.
   {
-    std::string path = pathBase + "/model_invalid_placement_frame.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "model_invalid_placement_frame.sdf");
 
     // Check model_invalid_placement_frame.sdf
     std::string output =
@@ -816,7 +898,9 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 
   // Check an SDF file with an valid nested model cross references
   {
-    std::string path = pathBase + "/nested_model_cross_references.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "nested_model_cross_references.sdf");
 
     std::string output =
       custom_exec_str(GzCommand() + " sdf -k " + path + SdfVersion());
@@ -825,7 +909,9 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 
   // Check an SDF model file with an invalid usage of __root__
   {
-    std::string path = pathBase + "/model_invalid_root_reference.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "model_invalid_root_reference.sdf");
 
     std::string output =
       custom_exec_str(GzCommand() + " sdf -k " + path + SdfVersion());
@@ -844,8 +930,11 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
   {
     // Set SDF_PATH so that included models can be found
     gz::utils::setenv(
-      "SDF_PATH", sdf::testing::SourceFile("test", "integration", "model"));
-    std::string path = pathBase + "/world_invalid_root_reference.sdf";
+      "SDF_PATH", sdf::testing::TestFile("integration", "model"));
+
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "world_invalid_root_reference.sdf");
 
     std::string output =
       custom_exec_str(GzCommand() + " sdf -k " + path + SdfVersion());
@@ -892,7 +981,9 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
   }
   // Check an SDF world file with an valid usage of __root__
   {
-    std::string path = pathBase + "/world_valid_root_reference.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "world_valid_root_reference.sdf");
 
     std::string output =
       custom_exec_str(GzCommand() + " sdf -k " + path + SdfVersion());
@@ -900,7 +991,9 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
   }
   // Check an SDF with an invalid relative frame at the top level model
   {
-    std::string path = pathBase + "/model_invalid_top_level_frame.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "model_invalid_top_level_frame.sdf");
 
     std::string output =
         custom_exec_str(GzCommand() + " sdf -k " + path + SdfVersion());
@@ -914,11 +1007,10 @@ TEST(check, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 /////////////////////////////////////////////////
 TEST(check_shapes_sdf, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 {
-  std::string pathBase = PROJECT_SOURCE_PATH;
-  pathBase += "/test/sdf";
-
   {
-    std::string path = pathBase +"/shapes.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "shapes.sdf");
 
     std::string output =
       custom_exec_str(GzCommand() + " sdf -k " + path + SdfVersion());
@@ -926,7 +1018,9 @@ TEST(check_shapes_sdf, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
   }
 
   {
-    std::string path = pathBase +"/shapes_world.sdf";
+    const auto path =
+      sdf::testing::TestFile("sdf",
+          "shapes_world.sdf");
 
     std::string output =
       custom_exec_str(GzCommand() + " sdf -k " + path + SdfVersion());
@@ -937,12 +1031,11 @@ TEST(check_shapes_sdf, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 /////////////////////////////////////////////////
 TEST(check_model_sdf, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 {
-  std::string pathBase = PROJECT_SOURCE_PATH;
-  pathBase += "/test/integration/model/box";
-
   // Check a good SDF file by passing the absolute path
   {
-    std::string path = pathBase +"/model.sdf";
+    const auto path =
+      sdf::testing::TestFile("integration",
+          "model", "box", "model.sdf");
 
     std::string output =
       custom_exec_str(GzCommand() + " sdf -k " + path + SdfVersion());
@@ -951,7 +1044,9 @@ TEST(check_model_sdf, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 
   // Check a good SDF file from the same folder by passing a relative path
   {
-    std::string path = "model.sdf";
+    const auto pathBase = sdf::testing::TestFile("integration",
+        "model", "box");
+    const auto path = "model.sdf";
 
     std::string output =
       custom_exec_str("cd " + pathBase + " && " +
@@ -975,12 +1070,10 @@ TEST(describe, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 /////////////////////////////////////////////////
 TEST(print, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 {
-  std::string pathBase = PROJECT_SOURCE_PATH;
-  pathBase += "/test/sdf";
-
   // Check a good SDF file
   {
-    std::string path = pathBase +"/box_plane_low_friction_test.world";
+    const auto path =
+      sdf::testing::TestFile("sdf", "box_plane_low_friction_test.world");
     sdf::SDFPtr sdf(new sdf::SDF());
     EXPECT_TRUE(sdf::init(sdf));
     EXPECT_TRUE(sdf::readFile(path, sdf));
@@ -993,7 +1086,8 @@ TEST(print, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 
   // Check a bad SDF file
   {
-    std::string path = pathBase +"/box_bad_test.world";
+    const auto path =
+      sdf::testing::TestFile("sdf", "box_bad_test.world");
 
     // Check box_bad_test.world
     std::string output =
@@ -1361,7 +1455,7 @@ TEST(print_includes_rotations_in_quaternions,
 {
   // Set SDF_PATH so that included models can be found
   gz::utils::setenv(
-    "SDF_PATH", sdf::testing::SourceFile("test", "integration", "model"));
+    "SDF_PATH", sdf::testing::TestFile("integration", "model"));
   const auto path = sdf::testing::TestFile(
       "sdf", "includes_rotations_in_quaternions.sdf");
 
@@ -1639,11 +1733,9 @@ TEST(print_snap_to_degrees_tolerance_too_high,
 /////////////////////////////////////////////////
 TEST(GraphCmd, GZ_UTILS_TEST_DISABLED_ON_WIN32(WorldPoseRelativeTo))
 {
-  const std::string pathBase = std::string(PROJECT_SOURCE_PATH) + "/test/sdf";
-
   // world pose relative_to graph
   const std::string path =
-    pathBase + "/world_relative_to_nested_reference.sdf";
+    sdf::testing::TestFile("sdf", "world_relative_to_nested_reference.sdf");
 
   const std::string output =
     custom_exec_str(GzCommand() + " sdf -g pose " + path + SdfVersion());
@@ -1690,8 +1782,9 @@ TEST(GraphCmd, GZ_UTILS_TEST_DISABLED_ON_WIN32(WorldPoseRelativeTo))
 /////////////////////////////////////////////////
 TEST(GraphCmd, GZ_UTILS_TEST_DISABLED_ON_WIN32(ModelPoseRelativeTo))
 {
-  const std::string pathBase = std::string(PROJECT_SOURCE_PATH) + "/test/sdf";
-  const std::string path = pathBase + "/model_relative_to_nested_reference.sdf";
+  const auto path =
+    sdf::testing::TestFile("sdf", "model_relative_to_nested_reference.sdf");
+
   const std::string output =
     custom_exec_str(GzCommand() + " sdf -g pose " + path + SdfVersion());
 
@@ -1766,8 +1859,8 @@ TEST(GraphCmd, GZ_UTILS_TEST_DISABLED_ON_WIN32(ModelPoseRelativeTo))
 /////////////////////////////////////////////////
 TEST(GraphCmd, GZ_UTILS_TEST_DISABLED_ON_WIN32(WorldFrameAttachedTo))
 {
-  const std::string pathBase = std::string(PROJECT_SOURCE_PATH) + "/test/sdf";
-  const std::string path = pathBase + "/world_nested_frame_attached_to.sdf";
+  const auto path =
+    sdf::testing::TestFile("sdf", "world_nested_frame_attached_to.sdf");
   const std::string output =
       custom_exec_str(GzCommand() + " sdf -g frame " + path + SdfVersion());
 
@@ -1812,8 +1905,8 @@ TEST(GraphCmd, GZ_UTILS_TEST_DISABLED_ON_WIN32(WorldFrameAttachedTo))
 /////////////////////////////////////////////////
 TEST(GraphCmd, GZ_UTILS_TEST_DISABLED_ON_WIN32(ModelFrameAttachedTo))
 {
-  const std::string pathBase = std::string(PROJECT_SOURCE_PATH) + "/test/sdf";
-  const std::string path = pathBase + "/model_nested_frame_attached_to.sdf";
+  const auto path = sdf::testing::TestFile("sdf", "model_nested_frame_attached_to.sdf");
+
   const std::string output =
       custom_exec_str(GzCommand() + " sdf -g frame " + path + SdfVersion());
 
@@ -1863,9 +1956,6 @@ TEST(GraphCmd, GZ_UTILS_TEST_DISABLED_ON_WIN32(ModelFrameAttachedTo))
 /////////////////////////////////////////////////
 TEST(inertial_stats, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 {
-  std::string pathBase = PROJECT_SOURCE_PATH;
-  pathBase += "/test/sdf";
-
   std::string expectedOutput =
     "Inertial statistics for model: test_model\n"
     "---\n"
@@ -1884,7 +1974,7 @@ TEST(inertial_stats, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 
   // Check a good SDF file by passing the absolute path
   {
-    std::string path = pathBase +"/inertial_stats.sdf";
+    const auto path = sdf::testing::TestFile("sdf", "inertial_stats.sdf");
 
     std::string output =
       custom_exec_str(GzCommand() + " sdf --inertial-stats " +
@@ -1894,7 +1984,8 @@ TEST(inertial_stats, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 
   // Check a good SDF file from the same folder by passing a relative path
   {
-    std::string path = "inertial_stats.sdf";
+    const auto path = "inertial_stats.sdf";
+    const auto pathBase = sdf::testing::TestFile("sdf");
 
     std::string output =
       custom_exec_str("cd " + pathBase + " && " +
@@ -1925,7 +2016,7 @@ TEST(inertial_stats, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
 
   // Check an invalid SDF file by passing the absolute path
   {
-    std::string path = pathBase +"/inertial_invalid.sdf";
+    const auto path = sdf::testing::TestFile("sdf", "inertial_invalid.sdf");
 
     std::string output =
       custom_exec_str(GzCommand() + " sdf --inertial-stats " +
@@ -1937,7 +2028,7 @@ TEST(inertial_stats, GZ_UTILS_TEST_DISABLED_ON_WIN32(SDF))
           "Error: Expected a model file but received a world file.\n";
   // Check a valid world file.
   {
-    std::string path = pathBase +"/box_plane_low_friction_test.world";
+    const auto path = sdf::testing::TestFile("sdf", "box_plane_low_friction_test.world");
 
     std::string output =
       custom_exec_str(GzCommand() + " sdf --inertial-stats " +
@@ -1956,9 +2047,8 @@ TEST(HelpVsCompletionFlags, SDF)
   std::string helpOutput = custom_exec_str(GzCommand() + " sdf --help");
 
   // Call the output function in the bash completion script
-  std::string scriptPath = PROJECT_SOURCE_PATH;
-  scriptPath = sdf::filesystem::append(scriptPath, "src", "cmd",
-      "sdf.bash_completion.sh");
+  const auto scriptPath =
+    sdf::testing::SourceFile("src", "cmd","sdf.bash_completion.sh");
 
   // Equivalent to:
   // sh -c "bash -c \". /path/to/sdf.bash_completion.sh; _gz_sdf_flags\""
diff --git a/src/parser_TEST.cc b/src/parser_TEST.cc
index 3e06c945a..9614e34e6 100644
--- a/src/parser_TEST.cc
+++ b/src/parser_TEST.cc
@@ -23,9 +23,9 @@
 #include "sdf/Element.hh"
 #include "sdf/Console.hh"
 #include "sdf/Filesystem.hh"
-#include "test_config.hh"
 
 #include <gz/utils/Environment.hh>
+#include "test_config.hh"
 
 /////////////////////////////////////////////////
 TEST(Parser, initStringTrim)
@@ -840,7 +840,8 @@ int main(int argc, char **argv)
 {
   // temporarily set HOME
   std::string homeDir;
-  sdf::testing::TestSetHomePath(homeDir);
+  sdf::testing::TestTmpPath(homeDir);
+  gz::utils::setenv("HOME", homeDir);
   sdf::Console::Clear();
 
   ::testing::InitGoogleTest(&argc, argv);
diff --git a/test/BUILD.bazel b/test/BUILD.bazel
new file mode 100644
index 000000000..2743e75f0
--- /dev/null
+++ b/test/BUILD.bazel
@@ -0,0 +1,57 @@
+load(
+    "@gz//bazel/skylark:build_defs.bzl",
+    "GZ_ROOT",
+    "cmake_configure_file",
+)
+
+cmake_configure_file(
+  name = "config",
+  src = "test_config.hh.in",
+  out = "test_config.hh",
+  cmakelists = ["CMakeLists.txt"],
+  defines = []
+)
+
+cc_library(
+    name = "test_utils",
+    hdrs = ["test_utils.hh", "test_config.hh"],
+    includes = ["."],
+    visibility = ["//visibility:public"],
+)
+
+integration_test_sources = glob(
+    ["integration/*.cc"],
+    exclude = [
+        "integration/schema_test.cc",
+        "integration/element_memory_leak.cc",
+    ],
+)
+
+[cc_test(
+    name = src.replace("/", "_").replace(".cc", "").replace("integration_", "INTEGRATION_"),
+    srcs = [
+        src,
+        "integration/toml_parser.hh",
+    ],
+    data = [
+        GZ_ROOT + "sdformat:sdf",
+        "integration",
+        "sdf",
+    ],
+    env = {
+        "GZ_BAZEL": "1",
+        "GZ_BAZEL_PATH": "sdformat",
+    },
+    includes = ["integration"],
+    deps = [
+        GZ_ROOT + "sdformat:sdformat",
+        ":test_utils",
+        "@gtest",
+        "@gtest//:gtest_main",
+    ],
+) for src in integration_test_sources]
+
+exports_files([
+    "sdf",
+    "integration",
+])
diff --git a/test/integration/CMakeLists.txt b/test/integration/CMakeLists.txt
index 0635cfdf3..09a504260 100644
--- a/test/integration/CMakeLists.txt
+++ b/test/integration/CMakeLists.txt
@@ -72,11 +72,22 @@ else()
   gz_build_warning("xmllint not found. schema_test won't be run")
 endif()
 
-gz_build_tests(TYPE ${TEST_TYPE} SOURCES ${tests} INCLUDE_DIRS ${PROJECT_SOURCE_DIR}/test)
+gz_build_tests(TYPE ${TEST_TYPE}
+  SOURCES ${tests}
+  INCLUDE_DIRS ${PROJECT_SOURCE_DIR}/test
+)
 
-if (EXISTS ${XMLLINT_EXE})
-  # Need to run schema target (build .xsd files) before running schema_test
-  add_dependencies(${TEST_TYPE}_schema_test schema)
+
+if (TARGET ${TEST_TYPE}_schema_test)
+  target_compile_definitions(${TEST_TYPE}_schema_test
+    PRIVATE
+    -DSDF_ROOT_SCHEMA="${PROJECT_BINARY_DIR}/sdf/${SDF_PROTOCOL_VERSION}/root.xsd"
+  )
+
+  if (EXISTS ${XMLLINT_EXE})
+    # Need to run schema target (build .xsd files) before running schema_test
+    add_dependencies(${TEST_TYPE}_schema_test schema)
+  endif()
 endif()
 
 # Test symbols having the right name on linux only
diff --git a/test/integration/converter.cc b/test/integration/converter.cc
index ec062d5ad..1509de722 100644
--- a/test/integration/converter.cc
+++ b/test/integration/converter.cc
@@ -156,7 +156,7 @@ void ParserStringConverter(const std::string &_version)
 TEST(ConverterIntegration, UnflattenConversion)
 {
   const std::string filename =
-  sdf::testing::SourceFile("test", "sdf",
+    sdf::testing::TestFile("sdf",
                           "flattened_test_nested_model_with_frames.sdf");
 
   sdf::SDFPtr sdf(new sdf::SDF());
diff --git a/test/integration/default_elements.cc b/test/integration/default_elements.cc
index efad8d8ad..f07cee0c8 100644
--- a/test/integration/default_elements.cc
+++ b/test/integration/default_elements.cc
@@ -26,14 +26,14 @@
 #include "sdf/Root.hh"
 #include "sdf/World.hh"
 #include "sdf/Filesystem.hh"
+
 #include "test_config.hh"
 
 //////////////////////////////////////////////////
 TEST(ExplicitlySetInFile, EmptyRoadSphCoords)
 {
-  const std::string testFile =
-    sdf::filesystem::append(PROJECT_SOURCE_PATH, "test", "sdf",
-        "empty_road_sph_coords.sdf");
+  const auto testFile =
+    sdf::testing::TestFile("sdf", "empty_road_sph_coords.sdf");
 
   sdf::Root root;
   sdf::Errors errors = root.Load(testFile);
@@ -109,9 +109,8 @@ TEST(ExplicitlySetInFile, EmptyRoadSphCoords)
 //////////////////////////////////////////////////
 TEST(ExplicitlySetInFile, EmptyAxis)
 {
-  const std::string testFile =
-    sdf::filesystem::append(PROJECT_SOURCE_PATH, "test", "sdf",
-        "empty_axis.sdf");
+  const auto testFile =
+    sdf::testing::TestFile("sdf", "empty_axis.sdf");
 
   sdf::Root root;
   sdf::Errors errors = root.Load(testFile);
@@ -157,9 +156,8 @@ TEST(ExplicitlySetInFile, EmptyAxis)
 //////////////////////////////////////////////////
 TEST(ExplicitlySetInFile, ToString)
 {
-  const std::string testFile =
-    sdf::filesystem::append(PROJECT_SOURCE_PATH, "test", "sdf",
-        "empty_road_sph_coords.sdf");
+  const auto testFile =
+    sdf::testing::TestFile("sdf", "empty_road_sph_coords.sdf");
 
   sdf::Root root;
   sdf::Errors errors = root.Load(testFile);
diff --git a/test/integration/frame.cc b/test/integration/frame.cc
index 9e0438273..1ed67cd3a 100644
--- a/test/integration/frame.cc
+++ b/test/integration/frame.cc
@@ -1299,8 +1299,7 @@ TEST(DOMFrame, WorldIncludeModel)
 TEST(Frame, IncludeFrameWithSubmodel)
 {
   const std::string MODEL_PATH =
-    sdf::filesystem::append(PROJECT_SOURCE_PATH, "test", "integration",
-                            "model", "box_with_submodel");
+    sdf::testing::TestFile("integration", "model", "box_with_submodel");
 
   std::ostringstream stream;
   std::string version = SDF_VERSION;
diff --git a/test/integration/nested_model.cc b/test/integration/nested_model.cc
index ec9181c4e..0c63cbc43 100644
--- a/test/integration/nested_model.cc
+++ b/test/integration/nested_model.cc
@@ -623,7 +623,7 @@ TEST(NestedModel, NestedModelWithFramesDirectComparison)
   const std::string expectedSdfPath =
     sdf::testing::TestFile(
         "integration", "nested_model_with_frames_expected.sdf");
-  std::fstream fs;
+  std::ifstream fs;
   fs.open(expectedSdfPath);
   EXPECT_TRUE(fs.is_open());
   std::stringstream expected;
@@ -779,7 +779,7 @@ TEST(NestedModel, TwoLevelNestedModelWithFramesDirectComparison)
   const std::string expectedSdfPath =
       sdf::testing::TestFile(
           "integration", "two_level_nested_model_with_frames_expected.sdf");
-  std::fstream fs;
+  std::ifstream fs;
   fs.open(expectedSdfPath);
   EXPECT_TRUE(fs.is_open());
   std::stringstream expected;
diff --git a/test/integration/nested_multiple_elements_error.cc b/test/integration/nested_multiple_elements_error.cc
index 46c0e975a..7831d2271 100644
--- a/test/integration/nested_multiple_elements_error.cc
+++ b/test/integration/nested_multiple_elements_error.cc
@@ -26,17 +26,17 @@
 #include "sdf/Model.hh"
 #include "sdf/Root.hh"
 #include "sdf/World.hh"
+
 #include "test_config.hh"
 
 const auto g_testPath = sdf::testing::TestFile();
-const auto g_modelsPath =
-    sdf::filesystem::append(g_testPath, "integration", "model");
-const auto g_sdfPath = sdf::filesystem::append(g_testPath, "sdf");
+const auto g_modelsPath = sdf::testing::TestFile("integration", "model");
+const auto g_sdfPath = sdf::testing::TestFile("sdf");
 
 /////////////////////////////////////////////////
 std::string findFileCb(const std::string &_input)
 {
-  return sdf::filesystem::append(g_testPath, "integration", "model", _input);
+  return sdf::filesystem::append(g_modelsPath, _input);
 }
 
 //////////////////////////////////////////////////
diff --git a/test/integration/schema_test.cc b/test/integration/schema_test.cc
index 1fa5e5a8f..99a309fdb 100644
--- a/test/integration/schema_test.cc
+++ b/test/integration/schema_test.cc
@@ -31,9 +31,7 @@ class SDFSchemaGenerator : public testing::Test
   public:
     void runXMLlint(const std::string & model)
     {
-      const std::string sdfRootSchema = sdf::filesystem::append(
-          PROJECT_BINARY_DIR, "sdf", SDF_PROTOCOL_VERSION, "root.xsd");
-
+      const auto sdfRootSchema = sdf::filesystem::append(SDF_ROOT_SCHEMA);
       std::string xmllintCmd = "xmllint --noout --schema " +
                                 sdfRootSchema + " " + model;
       std::cout << "CMD[" << xmllintCmd << "]\n";
diff --git a/test/integration/toml_parser.hh b/test/integration/toml_parser.hh
index f142aad7c..528563cab 100644
--- a/test/integration/toml_parser.hh
+++ b/test/integration/toml_parser.hh
@@ -135,7 +135,7 @@ struct Document: public Value
 
 Document parseToml(const std::string &_filePath, sdf::Errors &_errors)
 {
-  std::fstream fs;
+  std::ifstream fs;
   fs.open(_filePath);
   if (!fs.good())
   {
diff --git a/test/test_config.hh.in b/test/test_config.hh.in
index a84d1cddd..f509cfc94 100644
--- a/test/test_config.hh.in
+++ b/test/test_config.hh.in
@@ -18,18 +18,25 @@
 #ifndef SDF_TEST_CONFIG_HH_
 #define SDF_TEST_CONFIG_HH_
 
-#define GZ_CONFIG_PATH "@CMAKE_BINARY_DIR@/test/conf"
-#define GZ_PATH "@GZ_PROGRAM@"
-#define GZ_TEST_LIBRARY_PATH "${PROJECT_BINARY_DIR}/src:"\
-  "@GZ-MSGS_LIBRARY_DIRS@:"
-#define PROJECT_SOURCE_PATH "${PROJECT_SOURCE_DIR}"
-#define PROJECT_BINARY_DIR  "${CMAKE_BINARY_DIR}"
-#define SDF_PROTOCOL_VERSION "${SDF_PROTOCOL_VERSION}"
-#define SDF_TMP_DIR "tmp-sdf/"
-
 #include <gz/utils/Environment.hh>
 
 #include <sdf/Filesystem.hh>
+
+#cmakedefine PROJECT_SOURCE_DIR
+#cmakedefine PROJECT_BINARY_DIR
+
+#ifdef PROJECT_SOURCE_DIR
+constexpr const char* kProjectSourceDir = PROJECT_SOURCE_DIR;
+#else
+constexpr const char* kProjectSourceDir = "";
+#endif
+
+#ifdef PROJECT_BINARY_DIR
+constexpr const char* kProjectBinaryDir = PROJECT_BINARY_DIR;
+#else
+constexpr const char* kProjectBinaryDir= "";
+#endif
+
 namespace sdf
 {
   namespace testing
@@ -41,17 +48,18 @@ namespace sdf
     /// \return True if directory is set correctly, false otherwise
     bool ProjectSourcePath(std::string &_sourceDir)
     {
+      std::string bazel_path;
       // Bazel builds set TEST_SRCDIR
-      if(gz::utils::env("TEST_SRCDIR", _sourceDir))
+      if(gz::utils::env("TEST_SRCDIR", _sourceDir) &&
+         gz::utils::env("GZ_BAZEL_PATH", bazel_path))
       {
         _sourceDir = sdf::filesystem::append(
-            _sourceDir, "__main__", "sdformat");
+            _sourceDir, "gz", bazel_path);
         return true;
       }
       else
       {
-        // CMake builds set PROJECT_SOURCE_PATH
-        _sourceDir = PROJECT_SOURCE_PATH;
+        _sourceDir = kProjectSourceDir;
         return true;
       }
 
@@ -71,7 +79,7 @@ namespace sdf
       }
       else
       {
-        _tmpDir = sdf::filesystem::append(PROJECT_BINARY_DIR, SDF_TMP_DIR);
+        _tmpDir = sdf::filesystem::append(kProjectBinaryDir, "sdf-tmp");
         return true;
       }
     }
@@ -93,7 +101,7 @@ namespace sdf
       }
       else
       {
-        _homeDir = PROJECT_BINARY_DIR;
+        _homeDir = kProjectBinaryDir;
         // Set both for linux and windows
         return gz::utils::setenv("HOME", _homeDir) &&
                gz::utils::setenv("HOMEPATH", _homeDir);