@Singleton
public class DefaultToolchainsBuilder implements ToolchainsBuilder {
    private final Logger logger = LoggerFactory.getLogger(getClass());

    @Override
    public PersistedToolchains build(File userToolchainsFile) throws MisconfiguredToolchainException {
        PersistedToolchains toolchains = null;

        if (userToolchainsFile != null && userToolchainsFile.isFile()) {

        assertEquals(SsoResponseType.LOGOUT, SsoResponseType.valueOf("LOGOUT"));
    }

    @Test
    public void test_valueOf_invalidName() {
        // Test valueOf with invalid name throws exception
        try {
            SsoResponseType.valueOf("INVALID");
            fail("Expected IllegalArgumentException");
        } catch (IllegalArgumentException e) {
            // Expected exception

        assertTrue(bytesWritten > 68); // Should be larger due to scope
    }

    @Test
    @DisplayName("readTrailerWireFormat should read complete packet data")
    void testReadTrailerWireFormatSuccess() throws IOException {
        SessionRequestPacket writePacket =
                new SessionRequestPacket(mockConfig, new TestNetbiosName("SERVER", 0x20, null), new TestNetbiosName("CLIENT", 0x00, null));

    }

    public CommandRegistry[] getCommandRegistries() {
        return commandRegistries.toArray(new CommandRegistry[0]);
    }

    @Override
    public void close() throws Exception {
        ArrayList<Exception> exceptions = new ArrayList<>();
        for (CommandRegistry commandRegistry : commandRegistries) {
            if (commandRegistry instanceof AutoCloseable closeable) {

    @Deprecated
    @Override
    public void install(String basedir, String finalName, Artifact artifact, ArtifactRepository localRepository)
            throws ArtifactInstallationException {
        String extension = artifact.getArtifactHandler().getExtension();
        File source = new File(basedir, finalName + "." + extension);

        install(source, artifact, localRepository);

  protected CharEscaper() {}

  /**
   * Returns the escaped form of a given literal string.
   *
   * @param string the literal string to be escaped
   * @return the escaped form of {@code string}
   * @throws NullPointerException if {@code string} is null
   */
  @Override
  public String escape(String string) {
    checkNotNull(string); // GWT specific check (do not optimize)

    return new URLClassLoader(ClassPathUtil.getClassPathUrls(), classLoader) {
      @Override
      public Class<?> loadClass(String name) throws ClassNotFoundException {
        if (blocklist.contains(name)) {
          throw new ClassNotFoundException("I'm sorry Dave, I'm afraid I can't do that.");
        }
        if (name.startsWith(concurrentPackage)) {
          Class<?> c = findLoadedClass(name);

            .reduce(FileTree::plus)
            .orElse(projectLayout.files().getAsFileTree());
    }

    @TaskAction
    public void checkInvalidPermissions() throws IOException {
        if (Os.isFamily(Os.FAMILY_WINDOWS)) {
            throw new StopExecutionException();
        }
        List<String> failures = getFiles().getFiles()
            .stream()
            .filter(FilePermissionsTask::isExecutableFile)

     * @param queryCommand the query command implementation to add
     * @throws IllegalArgumentException if name or queryCommand is null
     */
    public void add(final String name, final QueryCommand queryCommand) {
        if (name == null || queryCommand == null) {
            throw new IllegalArgumentException(

            // for now, do not be lenient until we have better understanding of real-world scenarios where this happens
            throw new GradleException("unable to read the git revision", e);
        }
    }


    private static String findOriginUrl(final Path configFile) throws IOException {
        Map<String, String> props = new HashMap<>();