*/
    @Test
    public void testEmptyIterator() {
        final EmptyIterator<String> emptyIterator = new EmptyIterator<String>();
        assertThat(emptyIterator, is(notNullValue()));
    }

    /**
     * Test method for {@link org.codelibs.core.collection.EmptyIterator#remove()}
     * .
     */
    @Test
    public void testRemove() {

     */
    public void setLoc(final String loc) {
        this.loc = loc;
    }

    /**
     * Gets the caption of the image.
     * @return the caption
     */
    public String getCaption() {
        return caption;
    }

    /**
     * Sets the caption of the image.
     * @param caption the caption to set
     */
    public void setCaption(final String caption) {

            new DefaultChecksumAlgorithmFactorySelector(getChecksumAlgorithmFactories()));

    @Test
    void smokeTest() {
        Collection<String> algNames = service.getChecksumAlgorithmNames();
        assertEquals(4, algNames.size());
    }

    @Test
    void emptySha1Calculator() {
        ChecksumAlgorithmService.ChecksumCalculator calculator =
                service.select("SHA-1").getCalculator();

@GwtCompatible
@NullUnmarked
public class EscapersTest extends TestCase {
  public void testNullEscaper() throws IOException {
    Escaper escaper = Escapers.nullEscaper();
    EscaperAsserts.assertBasic(escaper);
    String s = "\0\n\t\\az09~\uD800\uDC00\uFFFF";
    assertWithMessage("null escaper should have no effect").that(escaper.escape(s)).isEqualTo(s);
  }

  public void testBuilderInitialStateNoReplacement() {

          .put("SHA-512", Hashing.sha512())
          .build();

  public void testHashing() {
    for (String stringToTest : INPUTS) {
      for (String algorithmToTest : ALGORITHMS.keySet()) {
        assertMessageDigestHashing(HashTestUtils.ascii(stringToTest), algorithmToTest);
      }
    }
  }

  public void testPutAfterHash() {
    Hasher sha1 = Hashing.sha1().newHasher();

    assertEquals(

        return HashMultiset.create(asList(elements));
      }
    };
  }

  public void testCreate() {
    Multiset<String> multiset = HashMultiset.create();
    multiset.add("foo", 2);
    multiset.add("bar");
    assertEquals(3, multiset.size());
    assertEquals(2, multiset.count("foo"));
  }

  public void testCreateWithSize() {
    Multiset<String> multiset = HashMultiset.create(50);
    multiset.add("foo", 2);

@Deprecated
class FileSizeFormatTest {

    @Test
    void testNegativeSize() {
        FileSizeFormat format = new FileSizeFormat();

        long negativeSize = -100L;
        assertThrows(IllegalArgumentException.class, () -> format.format(negativeSize));
    }

    @Test
    void testSize() {
        FileSizeFormat format = new FileSizeFormat();

     */
    protected abstract void doSendFragment(byte[] buf, int off, int length, boolean isDirect) throws IOException;

    /**
     * Receives a DCERPC fragment from the remote endpoint
     * @param buf the buffer to receive the fragment
     * @param isDirect whether to use direct reception
     * @throws IOException if an I/O error occurs
     */

    protected void checkEsInvalidAggregation(String name, Object value) {
        if (value == null || (value instanceof String && ((String) value).isEmpty())) {
            String msg = "Cannot register null or empty aggregation: name=" + name + " value=" + value;
            throw new InvalidQueryRegisteredException(msg);
        }
    }

class KerberosRelevantAuthDataTest {

    private MockedStatic<KerberosAuthData> mockedStaticAuthData;

    @BeforeEach
    void setUp() {
        // Mock the static parse method of KerberosAuthData
        mockedStaticAuthData = mockStatic(KerberosAuthData.class);
    }

    @AfterEach
    void tearDown() {
        // Close the static mock
        mockedStaticAuthData.close();
    }

    /**