@NullAndEmptySource
    @ValueSource(strings = { "", "share1", "\\\\server\\share", "C$", "ADMIN$", "IPC$" })
    void testConstructorWithDifferentSharenames(String sharename) {
        // Test with various sharename values
        MsrpcShareGetInfo shareGetInfo = new MsrpcShareGetInfo(testServer, sharename);
        assertNotNull(shareGetInfo);
        assertEquals(sharename, shareGetInfo.sharename);

    cache.put(20, 22);
    cache.put(5, 10);

    fakeTicker.advance(501, MILLISECONDS);

    assertThat(cache.asMap().values().contains(22)).isTrue();
    assertThat(cache.asMap().values().contains(10)).isTrue();
    assertThat(cache.asMap().values().contains(20)).isFalse();
  }

  @Test
  public void asMapKeySet() {
    Cache<Integer, Integer> cache =

        }
    }

    private static void validateSynonymString(final FessBaseAction action, final String[] values, final String propertyName,
            final VaErrorHook hook) {
        if (values.length == 0) {
            return;
        }
        for (final String value : values) {
            if (value.indexOf(',') >= 0) {
                action.throwValidationError(messages -> {

        if (StringUtil.isNotEmpty(path)) {
            final String[] values = path.split("/", 2);
            if (values.length == 2) {
                return values;
            }
            if (values.length == 1 && StringUtil.isNotEmpty(values[0])) {
                return new String[] { values[0], StringUtil.EMPTY };
            }
        }

    SerializableTester.reserializeAndAssert(multimap.asMap());
    Collection<Integer> valuesCopy = SerializableTester.reserialize(multimap.values());
    assertEquals(HashMultiset.create(multimap.values()), HashMultiset.create(valuesCopy));
  }

  @J2ktIncompatible
  @GwtIncompatible // SerializableTester
  public void testEmptySerialization() {

    }

    @Test
    void testReadParameterWordsWireFormat_bufDataStartIsZero() {
        // Test case when bufDataStart is initially 0.
        byte[] buffer = new byte[37]; // 3 reserved + 8*4 bytes for int4 values + 2 bytes for setupCount
        int bufferIndex = 0;

        // Reserved bytes
        buffer[bufferIndex++] = 0x00;
        buffer[bufferIndex++] = 0x00;
        buffer[bufferIndex++] = 0x00;

    public void clear() {
      assertTrue(Thread.holdsLock(mutex));
      delegate.clear();
    }

    @Override
    public Collection<V> values() {
      assertTrue(Thread.holdsLock(mutex));
      /* TODO: verify that the Collection is also synchronized? */
      return delegate.values();
    }

    @Override
    public Set<Cell<R, C, V>> cellSet() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.cellSet();

        if (value == null) {
            final String servletPath = request.getServletPath();
            final String[] values = servletPath.replaceAll("/+", "/").split("/");
            if (values.length > 2) {
                value = values[2];
            }
        }
        if (value == null) {
            return FormatType.SEARCH;
        }

 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.core.misc;

/**
 * A tuple of four values.
 *
 * @param <T1>
 *            The type of the first value
 * @param <T2>
 *            The type of the second value
 * @param <T3>
 *            The type of the third value
 * @param <T4>

    do {
      int entryIndex = next - 1;
      int entry = entries[entryIndex];
      if (getHashPrefix(entry, mask) == hashPrefix
          && Objects.equals(key, keys[entryIndex])
          && (values == null || Objects.equals(value, values[entryIndex]))) {
        int newNext = getNext(entry, mask);
        if (lastEntryIndex == -1) {
          // we need to update the root link from table[]
          tableSet(table, tableIndex, newNext);