*            of a domain controller however a member server will work as well and a domain controller may not
     *            return names for SIDs corresponding to local accounts for which the domain controller is not an
     *            authority.
     * @param tc
     *            The context that should be used to communicate with the named server.
     * @param sids

    assertFalse(multiset.contains(s2));
    assertEquals(1, multiset.count(s1));
    assertEquals(0, multiset.count(s2));

    multiset.add(s1);
    multiset.add(s2, 3);
    assertEquals(2, multiset.count(s1));
    assertEquals(3, multiset.count(s2));

    multiset.remove(s1);
    assertEquals(1, multiset.count(s1));
    assertEquals(3, multiset.count(s2));
  }

  public void testLogicalKeyEquality_strongKeys() {

  }

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

  public void testGetAndSet() {
    Count holder = new Count(10);
    assertEquals(10, holder.getAndSet(20));
    assertEquals(20, holder.get());
  }

  public void testSet() {
    Count holder = new Count(10);
    holder.set(20);
    assertEquals(20, holder.get());
  }

        int count = 0;
        int prev = -1;
        Map<String, Object> source;
        while ((source = reader.read()) != null) {
            int current = Integer.parseInt(source.get("field2").toString());
            assertTrue(prev < current);
            prev = current;
            count++;
        }
        assertEquals(num, count);

        public int count;
        public SamrSamEntry[] entries;

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

            if (entries != null) {
                _dst = _dst.deferred;
                int _entriess = count;
                _dst.enc_ndr_long(_entriess);

    if (result != -1) {
      count++;
    }
    return result;
  }

  @Override
  public int read(byte[] b, int off, int len) throws IOException {
    int result = in.read(b, off, len);
    if (result != -1) {
      count += result;
    }
    return result;
  }

  @Override
  public long skip(long n) throws IOException {
    long result = in.skip(n);
    count += result;
    return result;
  }

   * UnsupportedOperationException."
   */
  abstract void setCountNoCheckReturnValue(E element, int count);

  private void assertSetCountIncreasingFailure(E element, int count) {
    try {
      setCountNoCheckReturnValue(element, count);
      fail("a call to multiset.setCount() to increase an element's count should throw");
    } catch (UnsupportedOperationException expected) {
    }
  }

            if (now - previousTime < interval) {
                throw new IllegalStateException();
            }
            previousTime = now;

            count++;
            if (count <= exceptionCount) {
                throw new CrawlerSystemException("exception " + count);
            }

            final ResponseData responseData = new ResponseData();
            responseData.setUrl(request.getUrl());

		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;

			Optional:    true,
			Type:        "duration",
		},
		config.HelpKV{
			Key:         IOCount,
			Description: `maximum IO requests allowed between objects to slow down heal operation` + defaultHelpPostfix(IOCount),
			Optional:    true,
			Type:        "int",
		},
		config.HelpKV{
			Key:         DriveWorkers,