public int count;
        public DfsInfo1[] s;

        public void encode(NdrBuffer _dst) throws NdrException {
            _dst.align(4);
            _dst.enc_ndr_long(count);
            _dst.enc_ndr_referent(s, 1);

            if (s != null) {
                _dst = _dst.deferred;
                int _ss = count;
                _dst.enc_ndr_long(_ss);

            return;
        }
        ValidateNegotiateInfoResponse out = resp.getOutputData(ValidateNegotiateInfoResponse.class);

        if ( nego.getSecurityMode() != out.getSecurityMode() || nego.getCapabilities() != out.getCapabilities()
                || nego.getDialectRevision() != out.getDialect() || !Arrays.equals(nego.getServerGuid(), out.getServerGuid()) ) {
            log.debug("Secure negotiation failure");

  public void testAddOccurrences() {
    int originalCount = getMultiset().count(e0());
    assertEquals("old count", originalCount, getMultiset().add(e0(), 2));
    assertEquals("old count", originalCount + 2, getMultiset().count(e0()));
  }

  @CollectionFeature.Require(SUPPORTS_ADD)
  public void testAddSeveralTimes() {
    int originalCount = getMultiset().count(e0());
    assertEquals(originalCount, getMultiset().add(e0(), 2));

    AtomicInteger initial = new AtomicInteger(INITIAL_COUNT);
    when(backingMap.get(KEY)).thenReturn(initial);

    assertEquals(INITIAL_COUNT, multiset.add(KEY, COUNT_TO_ADD));
    assertEquals(INITIAL_COUNT + COUNT_TO_ADD, initial.get());
  }

  public void testAdd_laterFewWithOverflow() {
    final int INITIAL_COUNT = 92384930;
    final int COUNT_TO_ADD = Integer.MAX_VALUE - INITIAL_COUNT + 1;

  void setCountCheckReturnValue(E element, int count) {
    assertEquals(
        "multiset.setCount() should return the old count",
        getMultiset().count(element),
        setCount(element, count));
  }

  @Override
  void setCountNoCheckReturnValue(E element, int count) {
    setCount(element, count);
  }

  @CanIgnoreReturnValue
  private int setCount(E element, int count) {

		uint32_t num_stores;
		[size_is(num_stores)] DfsStorageInfo *stores;
	} DfsInfo3;

	typedef struct {
		uint32_t count;
		[size_is(count)] DfsInfo3 *s;
	} DfsEnumArray3;

	typedef struct {
		[string] wchar_t *dfs_name;
	} DfsInfo200;

	typedef struct {
		uint32_t count;
		[size_is(count)] DfsInfo200 *s;
	} DfsEnumArray200;

	typedef struct {
		uint32_t flags;
		[string] wchar_t *dfs_name;

		uint32_t num_stores;
		[size_is(num_stores)] DfsStorageInfo *stores;
	} DfsInfo3;

	typedef struct {
		uint32_t count;
		[size_is(count)] DfsInfo3 *s;
	} DfsEnumArray3;

	typedef struct {
		[string] wchar_t *dfs_name;
	} DfsInfo200;

	typedef struct {
		uint32_t count;
		[size_is(count)] DfsInfo200 *s;
	} DfsEnumArray200;

	typedef struct {
		uint32_t flags;
		[string] wchar_t *dfs_name;

    int strCopyLen = len;
    int pos = 0;
    while (count != 0) {
      if ((count & 1) != 0) {
        System.arraycopy(strCopy, 0, array, pos, strCopyLen);
        pos += strCopyLen;
      }
      count >>= 1;
      if (count != 0) {
        System.arraycopy(strCopy, 0, strCopy, strCopyLen, strCopyLen);
        strCopyLen <<= 1;
      }
    }
    return new String(array);
  }

  @Benchmark

        }
    }

    public void setAccessType_Count() {
        setAccessType_Count(null);
    }

    public void setAccessType_Count(ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
        setAccessType_Count("accessType", opLambda);
    }

    public void setAccessType_Count(String name, ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {

      processCalled--; // don't count the tail invocation (makes tests a bit more understandable)
    }

    // ensures that the number of invocations looks sane
    void assertInvariants(int expectedBytes) {
      // we should have seen as many bytes as the next multiple of chunk after expectedBytes - 1
      assertEquals(out.toByteArray().length, ceilToMultiple(expectedBytes, chunkSize));