}

const _authType_name = "UnknownAnonymousPresignedPresignedV2PostPolicyStreamingSignedSignedSignedV2JWTSTSStreamingSignedTrailerStreamingUnsignedTrailer"

var _authType_index = [...]uint8{0, 7, 16, 25, 36, 46, 61, 67, 75, 78, 81, 103, 127}

func (i authType) String() string {
	if i < 0 || i >= authType(len(_authType_index)-1) {
		return "authType(" + strconv.FormatInt(int64(i), 10) + ")"
	}

                    });
                    when(mock.read(any(byte[].class), any(int.class), any(int.class))).thenAnswer(inv -> {
                        byte[] buffer = inv.getArgument(0);
                        int offset = inv.getArgument(1);
                        int length = inv.getArgument(2);
                        int remaining = includeContent.length - index[0];
                        if (remaining <= 0) {

        private final String name;
        private final int value;

        public CustomTestObject(String name, int value) {
            this.name = name;
            this.value = value;
        }

        public String getName() {
            return name;
        }

        public int getValue() {
            return value;
        }

        @Override

    }

    public void test_setIndexUpdaterPriority() {
        int priority = Thread.MAX_PRIORITY;
        webFsIndexHelper.setIndexUpdaterPriority(priority);
        assertEquals(priority, webFsIndexHelper.indexUpdaterPriority);
    }

    public void test_setIndexUpdaterPriority_withMinValue() {
        int priority = Thread.MIN_PRIORITY;
        webFsIndexHelper.setIndexUpdaterPriority(priority);

   * though we also allow it to "succeed" if neither is permitted.
   */

  private void assertSetCount(E element, int count) {
    setCountCheckReturnValue(element, count);

    assertEquals(
        "multiset.count() should return the value passed to setCount()",
        count,
        getMultiset().count(element));

    int size = 0;
    for (Multiset.Entry<E> entry : getMultiset().entrySet()) {
      size += entry.getCount();
    }

    return fromLongBits(UnsignedLongs.remainder(value, checkNotNull(val).value));
  }

  /** Returns the value of this {@code UnsignedLong} as an {@code int}. */
  @Override
  public int intValue() {
    return (int) value;
  }

  /**
   * Returns the value of this {@code UnsignedLong} as a {@code long}. This is an inverse operation
   * to {@link #fromLongBits}.
   *

        return AbstractValueGraph.this.successors(node);
      }

      @Override
      public int degree(N node) {
        return AbstractValueGraph.this.degree(node);
      }

      @Override
      public int inDegree(N node) {
        return AbstractValueGraph.this.inDegree(node);
      }

      @Override
      public int outDegree(N node) {
        return AbstractValueGraph.this.outDegree(node);
      }
    };

        int readAndWrite = Smb2LeaseState.SMB2_LEASE_READ_CACHING | Smb2LeaseState.SMB2_LEASE_WRITE_CACHING;
        assertEquals(Smb2LeaseState.SMB2_LEASE_READ_WRITE, readAndWrite);

        int readAndHandle = Smb2LeaseState.SMB2_LEASE_READ_CACHING | Smb2LeaseState.SMB2_LEASE_HANDLE_CACHING;
        assertEquals(Smb2LeaseState.SMB2_LEASE_READ_HANDLE, readAndHandle);

        int fullLease =

        byte[] buffer = new byte[10];
        int result = smbCom.readParameterWordsWireFormat(buffer, 0);
        assertEquals(0, result);
    }

    @Test
    void testReadBytesWireFormat() {
        // This method is empty, so it should return 0
        SmbComCreateDirectory smbCom = new SmbComCreateDirectory(mockConfig, "testDir");
        byte[] buffer = new byte[10];
        int result = smbCom.readBytesWireFormat(buffer, 0);

        testRule.setResponseProcessor(processor);

        for (int i = 0; i < threadCount; i++) {
            final int threadId = i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        startLatch.await();
                        for (int j = 0; j < iterationsPerThread; j++) {
                            // Read properties