final Map<String, List<QueryBuilder>> geoMap = new HashMap<>();

        StreamUtil.stream(request.getParameterMap())
                .of(stream -> stream.filter(e -> e.getKey().startsWith("geo.") && e.getKey().endsWith(".point")).forEach(e -> {
                    final String key = e.getKey();
                    for (final String geoField : geoFields) {
                        if (key.startsWith("geo." + geoField + ".")) {

        assertTrue(result.contains("fileAttributes=0x0000"));
        assertTrue(result.contains("lastWriteTime=" + new Date(0L)));
        assertTrue(result.contains("fileSize=0"));
        assertTrue(result.endsWith("]"));
    }

        // Then
        assertNotNull(result);
        assertTrue(result.contains("SmbComTreeDisconnect"));
        assertTrue(result.startsWith("SmbComTreeDisconnect["));
        assertTrue(result.endsWith("]"));
    }

    /**
     * Test toString method behavior - requires valid configuration
     */
    @Test
    @DisplayName("Test toString requires valid configuration")

        if (!query.startsWith("*")) {
            queryBuf.append('*');
        }
        queryBuf.append(toLowercaseWildcard(query));
        if (!query.endsWith("*")) {
            queryBuf.append('*');
        }
        final String origQuery = queryBuf.toString();
        context.addFieldLog(Constants.DEFAULT_FIELD, origQuery);

        // Arrange: filter that accepts non-empty names ending with .txt
        SmbFileFilter filter = f -> {
            String n = f.getName();
            return n != null && !n.isEmpty() && n.endsWith(".txt");
        };
        when(smbFile.getName()).thenReturn(name);

        // Act
        boolean result = filter.accept(smbFile);

        // Assert
        assertEquals(expected, result);

            MojoDescriptor mojo, Parameter param, StringBuilder messageBuffer) {
        String expression = param.getExpression();

        if (param.isEditable()) {
            boolean isArray = param.getType().endsWith("[]");
            boolean isCollection = false;
            boolean isMap = false;
            boolean isProperties = false;
            if (!isArray) {
                try {

                            "${performanceTestCoverage.asConfigurationId(model)}_Trigger"
                        (performanceTests + previousPerformanceTestPasses).first {
                            it.id.toString().endsWith(
                                targetPerformanceTestPassBuildTypeId,
                            )
                        }
                    },
                ),
            )
        }
    }

    }
}

def currentClasspath = configurations.currentApiClasspath.incoming.artifactView { lenient(true) }.files
def currentDistroJars = currentClasspath.filter { it.name.startsWith('gradle-') && it.name.endsWith('.jar') }
def baselineJars = configurations.baselineJars
def baseVersion = gradleModule.identity.version.map { it.baseVersion.version }

dependencies {
    baseline("gradle:gradle:${compatibilityBaselineVersion}@zip")

      urlHost: String,
      domain: String,
    ): Boolean {
      if (urlHost == domain) {
        return true // As in 'example.com' matching 'example.com'.
      }

      return urlHost.endsWith(domain) &&
        urlHost[urlHost.length - domain.length - 1] == '.' &&
        !urlHost.canParseAsIpAddress()
    }

    private fun pathMatch(
      url: HttpUrl,
      path: String,
    ): Boolean {

        // Then
        assertTrue(result.startsWith("SmbComClose["));
        assertTrue(result.contains("fid=" + fid));
        assertTrue(result.contains("lastWriteTime=" + lastWriteTime));
        assertTrue(result.endsWith("]"));
    }

    /**
     * Test method for {@link jcifs.internal.smb1.com.SmbComClose#getResponse()}.
     */
    @Test
    public void testGetResponse() {
        // Given