* @throws UnsupportedOperationException always thrown as this method is not supported
     */
    @Override
    public boolean checkUserLoginable(final LoginCredential credential) {
        throw new UnsupportedOperationException("checkUserLoginable is not supported.");
    }

    /**
     * Checks the credential using the provided credential checker.
     * This method is not supported in the Fess implementation.

)

// ErrNoEntriesFound - Indicates no entries were found for the given key (directory)
var ErrNoEntriesFound = errors.New("No entries found for this key")

// ErrDomainMissing - Indicates domain is missing
var ErrDomainMissing = errors.New("domain is missing")

const etcdPathSeparator = "/"

// create a new coredns service record for the bucket.
func newCoreDNSMsg(ip string, port string, ttl uint32, t time.Time) ([]byte, error) {

            task.getReports().getXml().getOutputLocation().set(new File(checkstyle.getReportsDir(), "checkstyle-api.xml"));
        });
    }

    private static class DeduplicatePackageInfoFiles implements Spec<File> {

        private final Pattern pattern = Pattern.compile("package\\s*([^;\\s]+)\\s*;");

        private final Set<String> packagesSeenBefore = new HashSet<>();

            throw new InvalidQueryRegisteredException(msg);
        }
    }

    protected void checkEsInvalidQueryCollection(String name, Collection<?> values) {
        if (values == null || values.isEmpty()) {
            String msg = "Cannot register null or empty query collection: name=" + name + " values=" + values;
            throw new InvalidQueryRegisteredException(msg);
        }
    }

            return updateEntity(source, result);
        } catch (InstantiationException | IllegalAccessException e) {
            final String msg = "Cannot create a new instance: " + entityType.getName();
            throw new IllegalBehaviorStateException(msg, e);
        }
    }

    protected <RESULT extends ScheduledJob> RESULT updateEntity(Map<String, Object> source, RESULT result) {
        return result;

                final String baseCanonicalPath = new File(varPath).getCanonicalPath();
                if (!canonicalPath.startsWith(baseCanonicalPath)) {
                    throw new IllegalArgumentException("File path is outside allowed directory");
                }
            }
        } catch (final IOException e) {
            throw new IllegalArgumentException("Invalid file path", e);
        }
    }

 */
@J2ktIncompatible
@GwtIncompatible
public abstract class CharSink {

  /** Constructor for use by subclasses. */
  protected CharSink() {}

  /**
   * Opens a new {@link Writer} for writing to this sink. This method returns a new, independent
   * writer each time it is called.
   *
   * <p>The caller is responsible for ensuring that the returned writer is closed.
   *

     */
    @Test
    void testConstructor() {
        // The constructor should not throw any exceptions with valid inputs.
        new DosFileFilter("*.*", SmbFile.ATTR_ARCHIVE);
        new DosFileFilter("?", SmbFile.ATTR_DIRECTORY);
        new DosFileFilter("file.txt", SmbFile.ATTR_READONLY | SmbFile.ATTR_HIDDEN);
    }

    /**
     * Parameterized test for the {@link DosFileFilter#accept(SmbFile)} method.

@NullUnmarked
public class ThreadFactoryBuilderTest extends TestCase {
  private final Runnable monitoredRunnable =
      new Runnable() {
        @Override
        public void run() {
          completed = true;
        }
      };

  private static final UncaughtExceptionHandler UNCAUGHT_EXCEPTION_HANDLER =
      new UncaughtExceptionHandler() {
        @Override
        public void uncaughtException(Thread t, Throwable e) {

  }

  public void testListenersNotifiedOnError() throws Exception {
    CountDownLatch successLatch = new CountDownLatch(1);
    CountDownLatch listenerLatch = new CountDownLatch(1);

    ExecutorService exec = newCachedThreadPool();

    future.addListener(listenerLatch::countDown, exec);

    new Thread(
            () -> {
              assertThrows(CancellationException.class, future::get);