}

  public void testTest_noData() {
    tester.test();
  }

  public void testTest() {
    Object group1Item1 = new TestObject(1, 1);
    Object group1Item2 = new TestObject(1, 2);
    Object group2Item1 = new TestObject(2, 1);
    Object group2Item2 = new TestObject(2, 2);

    equivalenceMock.expectEquivalent(group1Item1, group1Item2);
    equivalenceMock.expectDistinct(group1Item1, group2Item1);

  }

  @Override
  public int count(@Nullable Object element) {
    throw new AssertionError();
  }

  @Override
  public ImmutableSet<E> elementSet() {
    throw new AssertionError();
  }

  @Override
  Entry<E> getEntry(int index) {
    throw new AssertionError();
  }

  @Override
  boolean isPartialView() {
    throw new AssertionError();
  }

  @Override
  public int size() {

@NullMarked
public class CountTest extends TestCase {
  public void testGet() {
    assertEquals(20, new Count(20).get());
  }

  public void testGetAndAdd() {
    Count holder = new Count(20);
    assertEquals(20, holder.get());
    holder.add(1);
    assertEquals(21, holder.get());
  }

  public void testAddAndGet() {
    Count holder = new Count(20);
    assertEquals(21, holder.addAndGet(1));
  }

     */
    @Test
    void testConcurrentWatch() throws Exception {
        // Create a thread-safe implementation
        SmbWatchHandle concurrentHandle = new SmbWatchHandle() {
            private final Object lock = new Object();
            private int watchCount = 0;

            @Override
            public List<FileNotifyInformation> watch() throws CIFSException {
                synchronized (lock) {

  private static final Function<Integer, Long> TO_LONG =
      new Function<Integer, Long>() {
        @Override
        public Long apply(Integer n) {
          return Long.valueOf(n);
        }
      };

  /* Helper function to make a BigInteger value from a Long. */
  private static final Function<Long, BigInteger> TO_BIGINTEGER =
      new Function<Long, BigInteger>() {
        @Override

    @Nullable
    final Lifecycle.Phase phase;

    final Map<Integer, Map<String, MojoExecution>> mojos = new TreeMap<>();
    final Collection<BuildStep> predecessors = new HashSet<>();
    final Collection<BuildStep> successors = new HashSet<>();
    final AtomicInteger status = new AtomicInteger();
    final AtomicBoolean skip = new AtomicBoolean();
    volatile Exception exception;

        // Test parsing simple field
        String xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + "<doc>\n" + "  <field name=\"title\">Test Title</field>\n" + "</doc>";

        AccessResultDataImpl<?> accessResultData = new AccessResultDataImpl<>();
        accessResultData.setData(xml.getBytes("UTF-8"));
        accessResultData.setEncoding("UTF-8");

        Map<String, Object> dataMap = XmlUtil.getDataMap(accessResultData);

            return updateEntity(source, result);
        } catch (InstantiationException | IllegalAccessException e) {
            final String msg = "Cannot create a new instance: " + entityType.getName();
            throw new IllegalBehaviorStateException(msg, e);
        }
    }

    protected <RESULT extends BadWord> RESULT updateEntity(Map<String, Object> source, RESULT result) {
        return result;
    }

            return updateEntity(source, result);
        } catch (InstantiationException | IllegalAccessException e) {
            final String msg = "Cannot create a new instance: " + entityType.getName();
            throw new IllegalBehaviorStateException(msg, e);
        }
    }

    protected <RESULT extends BoostDocumentRule> RESULT updateEntity(Map<String, Object> source, RESULT result) {
        return result;

            return updateEntity(source, result);
        } catch (InstantiationException | IllegalAccessException e) {
            final String msg = "Cannot create a new instance: " + entityType.getName();
            throw new IllegalBehaviorStateException(msg, e);
        }
    }

    protected <RESULT extends DuplicateHost> RESULT updateEntity(Map<String, Object> source, RESULT result) {
        return result;