@CollectionSize.Require(absent = {ZERO, ONE})
  public void testIndexOf_duplicate() {
    E[] array = createSamplesArray();
    array[getNumElements() / 2] = e0();
    collection = getSubjectGenerator().create(array);
    assertEquals(
        "indexOf(duplicate) should return index of first occurrence", 0, getList().indexOf(e0()));
  }

  @CollectionFeature.Require(KNOWN_ORDER)
  public void testForEachKnownOrder() {
    List<E> elements = new ArrayList<>();
    collection.forEach(elements::add);
    List<E> expected = copyToList(getOrderedElements());
    assertEquals("Different ordered iteration", expected, elements);
  }

  public void testLastIndexOf_duplicate() {
    E[] array = createSamplesArray();
    array[getNumElements() / 2] = e0();
    collection = getSubjectGenerator().create(array);
    assertEquals(
        "lastIndexOf(duplicate) should return index of last occurrence",
        getNumElements() / 2,
        getList().lastIndexOf(e0()));
  }

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs.smb;

import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNotSame;

  }

  public void testHashCode() throws Exception {
    int h1 = Objects.hashCode(1, "two", 3.0);
    int h2 = Objects.hashCode(Integer.valueOf(1), new String("two"), Double.valueOf(3.0));
    // repeatable
    assertEquals(h1, h2);

    // These don't strictly need to be true, but they're nice properties.
    assertTrue(Objects.hashCode(1, 2, null) != Objects.hashCode(1, 2));

  @CollectionFeature.Require(SUPPORTS_REMOVE)
  public void testClear() {
    collection.clear();
    assertTrue("After clear(), a collection should be empty.", collection.isEmpty());
    assertEquals(0, collection.size());
    assertFalse(collection.iterator().hasNext());
  }

  @CollectionFeature.Require(absent = SUPPORTS_REMOVE)
  @CollectionSize.Require(absent = ZERO)
  public void testClear_unsupported() {

  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testClear() {
    getMap().clear();
    assertTrue("After clear(), a map should be empty.", getMap().isEmpty());
    assertEquals(0, getMap().size());
    assertFalse(getMap().entrySet().iterator().hasNext());
  }

  @MapFeature.Require({FAILS_FAST_ON_CONCURRENT_MODIFICATION, SUPPORTS_REMOVE})
  @CollectionSize.Require(SEVERAL)

              }));
    }
    threadPool.shutdown();
    assertTrue(threadPool.awaitTermination(300, SECONDS));
    long sum = 0;
    for (Future<Long> f : futures) {
      sum += f.get();
    }
    assertEquals(sum, map.get(key));
  }

            Field field = DataIndexHelper.class.getDeclaredField("crawlingExecutionInterval");
            field.setAccessible(true);
            long actualInterval = (Long) field.get(dataIndexHelper);
            assertEquals(interval, actualInterval);
        } catch (Exception e) {
            fail("Failed to verify crawlingExecutionInterval: " + e.getMessage());
        }
    }

    public void test_setCrawlerPriority() {

        QueryBuilder queryBuilder = QueryBuilders.matchAllQuery();
        UpdateLabelJob returnedJob = updateLabelJob.query(queryBuilder);

        assertSame(updateLabelJob, returnedJob); // Method chaining
        assertEquals(queryBuilder, updateLabelJob.queryBuilder);
    }

    // Test query() method with null
    public void test_query_withNull() {
        updateLabelJob.query(null);