) = "${jvmMainSourceSet.getTaskName(verb, target)}ForFakeMain"
    }
  extensions
    .getByType(JavaPluginExtension::class.java)
    .sourceSets
    .add(mainSourceSet)
  tasks.named { it.endsWith("ForFakeMain") }.configureEach { onlyIf { false } }

  val osgiApi = configurations.create("osgiApi")
  dependencies {
    osgiApi(kotlinOsgi)
  }

        final WebResource[] possibleJars = listResources("/WEB-INF/plugin", false);

        for (final WebResource possibleJar : possibleJars) {
            if (possibleJar.isFile() && possibleJar.getName().endsWith(".jar")) {
                try (final JarFile jarFile = new JarFile(possibleJar.getCanonicalPath())) {
                    final Manifest manifest = jarFile.getManifest();

    }

    private long countTmpFiles() {
        return Arrays.stream(Objects.requireNonNull(Curl.tmpDir.listFiles())).map(File::getName)
                .filter(s -> s.startsWith(PREFIX) && s.endsWith(SUFFIX)).count();
    }

        String s = msg.toString();
        assertNotNull(s, "toString should not be null");
        assertTrue(s.startsWith("SmbComLogoffAndX["), "expected prefix " + "SmbComLogoffAndX[" + " but got " + s);
        assertTrue(s.endsWith("]"), "expected suffix ] but got " + s);
        String inner = s.substring("SmbComLogoffAndX[".length(), s.length() - 1);
        assertFalse(inner.isEmpty(), "inner part of toString should not be empty");
    }

    @Test

      p--;
    }
    return a.subSequence(0, p).toString();
  }

  /**
   * Returns the longest string {@code suffix} such that {@code a.toString().endsWith(suffix) &&
   * b.toString().endsWith(suffix)}, taking care not to split surrogate pairs. If {@code a} and
   * {@code b} have no common suffix, returns the empty string.
   *
   * @since 11.0
   */

            if (Strings.isNullOrEmpty(q)) {
                queryBuilder = QueryBuilders.matchAllQuery();
            } else {
                final boolean prefixQuery = !q.endsWith(" ") && !q.endsWith("　");
                List<String> readingList = new ArrayList<>();

                final String[] langsArray = languages.toArray(new String[languages.size()]);

            String result = nc.toString();

            // The format is: NtlmChallenge[challenge=0x<hex>,dc=<dc_string>]
            assertTrue(result.startsWith("NtlmChallenge[challenge=0x"));
            assertTrue(result.endsWith(",dc=SERVER123]"));

            // Hexdump.toHexString with size = length * 2 produces 8 uppercase hex chars
            // The hex should be "010203FF"
            assertTrue(result.contains("010203FF"));
        }

    @Test
    void testToStringFormat() {
        String str = response.toString();
        assert (str.startsWith("TransTransactNamedPipeResponse["));
        assert (str.endsWith("]"));
    }
}

// We need to add a helper method to TransTransactNamedPipeResponse to make the test more precise
// Or create a visible subclass for testing.

        // 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")

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.internal.tls

import assertk.assertThat
import assertk.assertions.endsWith
import assertk.assertions.isEqualTo
import assertk.assertions.isNull
import assertk.assertions.startsWith
import java.io.IOException
import java.net.SocketException
import java.security.GeneralSecurityException