*
     * @return the owner group SID, <code>null</code> if not present
     * @throws IOException if an I/O error occurs
     */
    SID getOwnerGroup() throws IOException;

    /**
     * Return the owner group SID for this file or directory
     *
     * @param resolve
     *            whether to resolve the group name
     * @return the owner group SID, <code>null</code> if not present

    }

    @Test
    public void test_addSourceWithNullSources() {
        final ChatMessage message = new ChatMessage();
        message.setSources(null);

        final ChatSource source = new ChatSource();
        source.setTitle("New Source");

        message.addSource(source);

        assertNotNull(message.getSources());

        assertEquals("%2e%2e/test.log", AdminLogAction.sanitizeFilename("%2e%2e/test.log"));
    }

    @Test
    public void test_security_nullBytes() {
        // Null byte injection (the string contains literal null byte)
        assertEquals("fess.log\0.txt", AdminLogAction.sanitizeFilename("fess.log\0.txt"));
    }

    @Test
    public void test_security_unicodeCharacters() {

     *
     * @param value the string value to parse
     * @return the corresponding ChatIntent, defaults to UNCLEAR if not found
     */
    public static ChatIntent fromValue(final String value) {
        if (value == null) {
            return UNCLEAR;
        }
        for (final ChatIntent intent : values()) {
            if (intent.value.equalsIgnoreCase(value.trim())) {
                return intent;
            }
        }

        .build()
  }

  private fun newVirtualThreadPerTaskExecutor(): ExecutorService =
    Executors::class.java.getMethod("newVirtualThreadPerTaskExecutor").invoke(null) as ExecutorService

  @Test
  fun testRequest() {
    server.enqueue(MockResponse())

    val request = Request(server.url("/"))

    client.newCall(request).execute().use {

    this.singleKey = key;
    this.singleValue = value;
    this.inverse = inverse;
  }

  @Override
  public ImmutableBiMap<V, K> inverse() {
    ImmutableBiMap<V, K> result = inverse;
    if (result == null) {
      return inverse = new SingletonImmutableBiMap<V, K>(singleValue, singleKey, this);
    } else {
      return result;
    }
  }

  @Override
  public ImmutableSet<V> values() {

    return value;
  }

  final @Nullable Listener listeners() {
    return listeners;
  }

  final void releaseWaiters() {}

  AbstractFutureState() {}

  static final Object NULL = new Object();

  static final LazyLogger log = new LazyLogger(AbstractFuture.class);

  static final boolean GENERATE_CANCELLATION_CAUSES = false;

  private volatile @Nullable Object value;

  static final EmptyImmutableSetMultimap INSTANCE = new EmptyImmutableSetMultimap();

  private EmptyImmutableSetMultimap() {
    super(ImmutableMap.of(), 0, null);
  }

  /*
   * TODO(b/242884182): Figure out why this helps produce the same class file when we compile most
   * of common.collect a second time with the results of the first compilation on the classpath. Or

        assertThat(out.getNotify(), is("closed"));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testCloseNull() throws Exception {
        CloseableUtil.close((OutputStream) null);
    }

    /**
     * @throws Exception
     */
    @Test
    public void testClose_noThrowIOException() throws Exception {
        final OutputStream out = new IOExceptionOccurOutputStream();

            throw new IOException("unexpected EOF reading netbios retarget session response");
        }
        final int addr = readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        new NbtAddress(null, addr, false, NbtAddress.B_NODE);
        readInt2(buffer, bufferIndex);
        return this.length;
    }