doing less.

To wire this registered cluster into a `TestClusterAware` task (e.g. `RestIntegTest`) you can resolve the actual cluster from the provider instance:

    tasks.register('someClusterTest', RestIntegTestTask) {
        useCluster someClusterProvider

    }

    // Helper method for containsExactlyInAnyOrder assertion
    private static <T> void assertContainsExactlyInAnyOrder(Collection<T> actual, T... expected) {
        assertEquals(expected.length, actual.size(), "Collection size mismatch");
        for (T item : expected) {
            assertTrue(actual.contains(item), "Collection should contain: " + item);
        }
    }

    @Test

        assertFalse(svgMimetype.matches(noBackslash));
    }

    @Test
    public void test_isTarget_withSvgMimetype() {
        // Test isTarget method through actual execution path with SVG MIME type
        // This tests the full flow: addCondition -> isTarget -> conditionMap -> matches
        generator = new TestThumbnailGenerator();

        // Setup mock FessConfig

        SMBUtil.writeInt4(contextStartOffsetFromHeader, base, offsetFieldPos);
        SMBUtil.writeInt4(ctx.length, base, offsetFieldPos + 4);

        // Assemble full body: base (fixed-size fields only), but actual context bytes sit elsewhere in the full packet
        // Return just the base; caller is responsible for placing ctx at the correct absolute offset.

        assertEquals(35000, SmbConstants.DEFAULT_CONN_TIMEOUT);
        // Note: USE_UNICODE and FORCE_UNICODE don't exist in the interface
        // These tests should be removed or replaced with actual constants
    }

    /**
     * Test individual FLAGS2 constants.
     */
    @Test
    @DisplayName("FLAGS2 individual constants are correct")
    void flags2ConstantsTest() {

func (r *RequestRecorder) Size() int {
	return r.bytesRead
}

// Data returns the bytes that were recorded.
func (r *RequestRecorder) Data() []byte {
	// If body logging is enabled then we return the actual body
	if r.LogBody {
		return r.buf.Bytes()
	}
	// ... otherwise we return <BLOB> placeholder
	return blobBody

		}
		if i&(1<<2) != 0 {
			ofi.TransitionVersionID = inputs[1].remoteVersionID
		}
		actual := fi.TransitionInfoEquals(ofi)
		if i == 0 && !actual {
			t.Fatalf("Test %d: Expected FileInfo's transition info to be equal: fi %v ofi %v", i, fi, ofi)
		}
		if i != 0 && actual {
			t.Fatalf("Test %d: Expected FileInfo's transition info to be inequal: fi %v ofi %v", i, fi, ofi)
		}
	}
	fi := FileInfo{

          <type>DOM</type>
          <description>
            Toolchain identification information, which will be matched against project requirements.
            &lt;p>Actual content structure is completely open: each toolchain type will define its own format and
            semantics.
            &lt;p>This is generally a properties format: {@code &lt;name&gt;value&lt;/name&gt;} with predefined

        assertEquals("TestAgent", fessConfig.getUserAgentName());
    }

    private void assertArrays(final String[] expected, final String[] actual) {
        Arrays.sort(expected);
        Arrays.sort(actual);
        assertEquals(String.join(",", expected), String.join(",", actual));
    }

    @Test
    public void test_getEntraIdPermissionFields_withNewKey() {

    assertThat(new FreshValueGenerator().generateFresh(type)).isNull();
  }

  private static void assertValueAndTypeEquals(Object expected, Object actual) {
    assertEquals(expected, actual);
    assertEquals(expected.getClass(), actual.getClass());
  }