}

    public void test_execute_withSpecialCharactersInConfig() {
        // Configure field and index names with special characters
        expiresFieldName = "expires-field.with@special#chars";
        documentUpdateIndex = "fess.update-index$special%chars";

        // Re-register FessConfig with updated values
        fessConfig = new TestFessConfig() {
            @Override
            public String getIndexFieldExpires() {

        mockConfig = Mockito.mock(Configuration.class);
        mockCredentials = Mockito.mock(Credentials.class);
        mockCredentialsInternal = Mockito.mock(CredentialsInternal.class);

        Mockito.when(mockContext.getConfig()).thenReturn(mockConfig);
        Mockito.when(mockContext.getCredentials()).thenReturn(mockCredentials);
        Mockito.when(mockCredentials.unwrap(Mockito.any())).thenReturn(mockCredentialsInternal);

 *
 * <p>Most methods in this class treat absent values and zero values identically, as individually
 * documented. Exceptions to this are {@link #containsKey}, {@link #size}, {@link #isEmpty}, {@link
 * #asMap}, and {@link #toString}.
 *
 * <p>Instances of this class may be used by multiple threads concurrently. All operations are
 * atomic unless otherwise noted.
 *
 * <p>Instances of this class are serializable if the keys are serializable.

    }
  }

  // 128 - [chars 0x0000 to 0x007f]
  private static final long ONE_BYTE_ROUNDTRIPPABLE_CHARACTERS = 0x007f - 0x0000 + 1;

  // 128
  private static final long EXPECTED_ONE_BYTE_ROUNDTRIPPABLE_COUNT =
      ONE_BYTE_ROUNDTRIPPABLE_CHARACTERS;

  // 1920 [chars 0x0080 to 0x07FF]

  }

  @CollectionSize.Require(absent = ZERO)
  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testPropagatesClearToMultimap() {
    Collection<V> result = multimap().asMap().get(k0());
    result.clear();
    assertGet(k0());
    assertEmpty(result);
  }

  @CollectionSize.Require(absent = ZERO)
  @MapFeature.Require({SUPPORTS_PUT, ALLOWS_NULL_VALUES})
  public void testAddNullValue() {

            @Throws(IOException::class)
            override fun configureSocket(socket: Socket): Socket {
              socket.setSendBufferSize(SOCKET_BUFFER_SIZE)
              socket.setReceiveBufferSize(SOCKET_BUFFER_SIZE)
              return socket
            }
          },
        ).build()
  }

  @AfterEach
  fun tearDown() {
    Thread.interrupted() // Clear interrupted state.
  }

  @Test

import org.jspecify.annotations.Nullable;

/**
 * Tests for {@link ForwardingSortedMultiset}.
 *
 * @author Louis Wasserman
 */
@NullUnmarked
public class ForwardingSortedMultisetTest extends TestCase {
  static class StandardImplForwardingSortedMultiset<E> extends ForwardingSortedMultiset<E> {
    private final SortedMultiset<E> backingMultiset;

                    }
                    final String className = provider + "." + protocol + ".Handler";
                    try {
                        Class handlerClass = null;
                        try {
                            handlerClass = Class.forName(className);
                        } catch (final Exception ex) {}
                        if (handlerClass == null) {

      // TODO(kevinb): precompute random #s?
      queue.add(queue.poll() ^ random.nextInt());
    }
  }

  @Benchmark
  void populate(int reps) {
    for (int i = 0; i < reps; i++) {
      queue.clear();
      for (int j = 0; j < size; j++) {
        // TODO(kevinb): precompute random #s?
        queue.add(random.nextInt());
      }
    }
  }

  /**

							return
						}
					}
				}
			}
			zb0001Mask |= 0x1
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	// Clear omitted fields.
	if (zb0001Mask & 0x1) == 0 {
		z.ObjectV2 = nil
	}

	return
}

// EncodeMsg implements msgp.Encodable
func (z *xlMetaDataDirDecoder) EncodeMsg(en *msgp.Writer) (err error) {