Arrays.asList(ValidationReportLevel.INLINE, ValidationReportLevel.BRIEF));

    private enum ValidationReportLevel {
        NONE, // mute validation completely (validation issue collection still happens, it is just not reported!)
        INLINE, // inline, each "internal" problem one line next to mojo invocation

pkg syscall (freebsd-riscv64), const IP_MAX_MEMBERSHIPS = 4095 #53466
pkg syscall (freebsd-riscv64), const IP_MAX_MEMBERSHIPS ideal-int #53466
pkg syscall (freebsd-riscv64), const IP_MAX_SOCK_MUTE_FILTER = 128 #53466
pkg syscall (freebsd-riscv64), const IP_MAX_SOCK_MUTE_FILTER ideal-int #53466
pkg syscall (freebsd-riscv64), const IP_MAX_SOCK_SRC_FILTER = 128 #53466
pkg syscall (freebsd-riscv64), const IP_MAX_SOCK_SRC_FILTER ideal-int #53466

pkg syscall (darwin-arm64), const IP_MAX_MEMBERSHIPS = 4095
pkg syscall (darwin-arm64), const IP_MAX_MEMBERSHIPS ideal-int
pkg syscall (darwin-arm64), const IP_MAX_SOCK_MUTE_FILTER = 128
pkg syscall (darwin-arm64), const IP_MAX_SOCK_MUTE_FILTER ideal-int
pkg syscall (darwin-arm64), const IP_MAX_SOCK_SRC_FILTER = 128
pkg syscall (darwin-arm64), const IP_MAX_SOCK_SRC_FILTER ideal-int
pkg syscall (darwin-arm64), const IP_MF = 8192

pkg syscall (freebsd-arm64), const IP_MAX_MEMBERSHIPS = 4095
pkg syscall (freebsd-arm64), const IP_MAX_MEMBERSHIPS ideal-int
pkg syscall (freebsd-arm64), const IP_MAX_SOCK_MUTE_FILTER = 128
pkg syscall (freebsd-arm64), const IP_MAX_SOCK_MUTE_FILTER ideal-int
pkg syscall (freebsd-arm64), const IP_MAX_SOCK_SRC_FILTER = 128
pkg syscall (freebsd-arm64), const IP_MAX_SOCK_SRC_FILTER ideal-int

    TestMap<K, V> inner = new TestMap<>(innermost, mutex);
    NavigableMap<K, V> outer = Synchronized.navigableMap(inner, mutex);
    return outer;
  }

  static class TestEntry<K, V> extends ForwardingMapEntry<K, V> implements Serializable {
    private final Entry<K, V> delegate;
    private final Object mutex;

    TestEntry(Entry<K, V> delegate, Object mutex) {
      this.delegate = delegate;
      this.mutex = mutex;

    final Set<E> delegate;
    public Object mutex;

    public TestSet(Set<E> delegate, @Nullable Object mutex) {
      this.delegate = delegate;
      this.mutex = mutex;
    }

    @Override
    protected Set<E> delegate() {
      return delegate;
    }

    @Override
    public String toString() {
      assertTrue(Thread.holdsLock(mutex));
      return super.toString();
    }

    @Override

    public TestBiMap(BiMap<K, V> delegate, Object mutex) {
      super(delegate, mutex);
      this.delegate = delegate;
    }

    @Override
    public @Nullable V forcePut(K key, V value) {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.forcePut(key, value);
    }

    @Override
    public BiMap<V, K> inverse() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.inverse();
    }

    inner.mutex = outer;
    outer.add("foo"); // necessary because we try to remove elements later on
    return outer;
  }

  private static final class TestQueue<E> implements Queue<E> {
    private final Queue<E> delegate = Lists.newLinkedList();
    public Object mutex;

    @Override
    public boolean offer(E o) {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.offer(o);
    }

      return delegate.offer(o);
    }

    @Override
    public @Nullable E poll() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.poll();
    }

    @Override
    public E remove() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.remove();
    }

    @Override
    public boolean remove(Object object) {
      assertTrue(Thread.holdsLock(mutex));

    assertSame(MUTEX, ((SynchronizedNavigableSet<String>) descendingSet).mutex);
  }

  public void testHeadSet_E() {
    NavigableSet<String> map = create();
    SortedSet<String> headSet = map.headSet("a");
    assertTrue(headSet instanceof SynchronizedSortedSet);
    assertSame(MUTEX, ((SynchronizedSortedSet<String>) headSet).mutex);
  }

  public void testHeadSet_E_B() {