throws RepositoryMetadataStoreException {
        try {
            updateRepositoryMetadata(localRepository, remoteRepository);
        } catch (IOException | XMLStreamException e) {
            throw new RepositoryMetadataStoreException("Error updating group repository metadata", e);
        }
    }

        try {
            return accessTokenService.getPermissions(request)
                    .map(permissions -> fessConfig.isApiAdminAccessAllowed(permissions))
                    .orElse(false);
        } catch (final InvalidAccessTokenException e) {
            if (logger.isDebugEnabled()) {
                logger.debug("Invalid access token.", e);
            }
            return false;
        }
    }

            return 4;
        }

        try {
            securityDescriptor = new SecurityDescriptor();
            bufferIndex += securityDescriptor.decode(buffer, bufferIndex, len);
        } catch (final IOException ioe) {
            throw new RuntimeException(ioe.getMessage());
        }

        return bufferIndex - start;
    }

    @Override
    public String toString() {

        getLabelType(form).ifPresent(entity -> {
            try {
                labelTypeService.store(entity);
                saveInfo(messages -> messages.addSuccessCrudCreateCrudTable(GLOBAL));
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);
                throwValidationError(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)),

    try {
      joiner.appendTo(NASTY_APPENDABLE, set);
    } catch (IOException e) {
      throw new AssertionError(e);
    }

    try {
      joiner.appendTo(NASTY_APPENDABLE, set.iterator());
    } catch (IOException e) {
      throw new AssertionError(e);
    }

    try {
      joiner.appendTo(NASTY_APPENDABLE, array);
    } catch (IOException e) {
      throw new AssertionError(e);
    }
  }

        try {
            Field f = SmbTreeConnection.class.getDeclaredField("tree");
            f.setAccessible(true);
            f.set(c, tree);
        } catch (Exception e) {
            throw new AssertionError(e);
        }
    }

    // Helper to set private flag 'treeAcquired'
    private static void setTreeAcquired(SmbTreeConnection c, boolean val) {
        try {

# This Dockerfile creates an image that has:
# - the correct MTU setting for networking from inside the container to work.
# - Visual Studio 2022 Build Tools
# - MSVC 14.39
# - LLVM/Clang 18.1.4
# - MSYS2 + curl, git, patch, vim, unzip, zip
# - Python 3.9 - 3.14
# - Bazelisk 1.22.1
# - JDK 21 (Azul Zulu)

FROM mcr.microsoft.com/windows/servercore:ltsc2022

SHELL ["powershell.exe", "-ExecutionPolicy", "Bypass", "-Command", \

                throw new IllegalArgumentException(
                        "File path is outside allowed directory: path=" + canonicalPath + ", allowed=" + allowedPaths);
            }
        } catch (final IOException e) {
            throw new IllegalArgumentException("Invalid file path: path=" + path, e);
        }
    }

    /**
     * Gets the servlet context.
     *

    }

    @Override
    public void remove() {
      iterator.remove();
    }
  }

  public void testPeekingIteratorDoesntAdvancePrematurely() throws Exception {
    /*
     * This test will catch problems where the underlying iterator
     * throws a RuntimeException when retrieving the nth element.
     *
     * If the PeekingIterator is caching elements too aggressively,

                    @Override
                    public void execute(Task task) {
                        try {
                            Files.createDirectories(testfixturesDir.toPath());
                        } catch (IOException e) {
                            throw new UncheckedIOException(e);
                        }
                    }
                });
            });