lastDriveStatsRefresh time.Time
)

// PeerResourceMetrics represents the resource metrics
// retrieved from a peer, along with errors if any
type PeerResourceMetrics struct {
	Metrics map[MetricSubsystem]ResourceMetrics
	Errors  []string
}

// ResourceMetrics is a map of unique key identifying
// a resource metric (e.g. reads_per_sec_{node}_{drive})
// to its data
type ResourceMetrics map[string]ResourceMetric

{
  "resources": [
    {"pattern": "okhttp3/internal/publicsuffix/PublicSuffixDatabase.list"}
  ]

   * this class ({@code Resources}) will be used instead.
   *
   * @throws IllegalArgumentException if the resource is not found
   */
  @CanIgnoreReturnValue // being used to check if a resource exists
  // TODO(cgdecker): maybe add a better way to check if a resource exists
  // e.g. Optional<URL> tryGetResource or boolean resourceExists

        Resource resource = resources.get(0);
        assertEquals(Path.of("src/main/resources").toString(), resource.getDirectory());
        assertTrue(resource.getIncludes().isEmpty(), "Initially should have no includes");

        // Add an include - this should work now
        resource.addInclude("test");

        // Verify the include was added
        assertEquals(1, resource.getIncludes().size(), "Should have one include");

    }

    /**
     * Create a managed resource wrapper
     *
     * @param <T> resource type
     * @param resource the resource to wrap
     * @return managed resource
     */
    public <T extends AutoCloseable> ManagedResource<T> manage(T resource) {
        String resourceId = registerResource(resource);
        return new ManagedResource<>(resource, resourceId, this);
    }

    /**

    }

    @Test
    @DisplayName("Test resource close tracking")
    void testResourceCloseTracking() throws Exception {
        TestResource resource = new TestResource("test2");
        String resourceId = resourceManager.registerResource(resource);

        resource.close();
        resourceManager.markClosed(resourceId);

        Map<String, Object> stats = resourceManager.getStatistics();

	}

	// No locks held on the all resources, so claim write
	// lock on all resources at once.
	now := UTCNow()
	for i, resource := range args.Resources {
		l.lockMap[resource] = []lockRequesterInfo{
			{
				Name:            resource,
				Writer:          true,
				Source:          args.Source,
				Owner:           args.Owner,
				UID:             args.UID,
				Timestamp:       now.UnixNano(),

        // Then
        assertNotNull(resource1, "First resource should be created");
        assertNotNull(resource2, "Second resource should be created");
        assertNotNull(pipe1, "First pipe should be created");
        assertNotNull(pipe2, "Second pipe should be created");

        assertNotSame(resource1, resource2, "Different resources should be different instances");

            assertTrue(resource.exists(), "Resource should exist");
            assertTrue(resource.isFile(), "Should be a file");
            assertTrue(resource.canWrite(), "Should be writable");

            // Should be able to perform file operations
            assertDoesNotThrow(() -> {
                resource.setReadOnly();
                resource.setReadWrite();
                resource.setAttributes(0x20);

    <testSourceDirectory>${project.basedir}/src/test/java</testSourceDirectory>
    <resources>
      <resource>
        <directory>${project.basedir}/src/main/resources</directory>
      </resource>
      <resource>
        <directory>${project.basedir}/src/main/resources-filtered</directory>
        <filtering>true</filtering>
      </resource>
    </resources>
    <testResources>
      <testResource>