filled := 0
						missing := 0
						for i, v := range combineFilled {
							if v == 1 {
								m.filled[i] = 1
								m.mapped[i] = combineShared[i]
								filled++
							} else {
								missing++
							}
						}
						fmt.Println("Missing", missing, "bytes. Filled", filled, "bytes.")
						break
					}
					if key == otherKey {
						continue
					}

        JobNotFoundException exception = new JobNotFoundException("Fill stack trace test");

        Throwable filled = exception.fillInStackTrace();

        assertNotNull(filled);
        assertEquals(exception, filled);
        assertNotNull(filled.getStackTrace());
        assertTrue(filled.getStackTrace().length > 0);
    }

    public void test_getMessage_consistency() {

        DataStoreException exception = new DataStoreException("Stack trace test");
        Throwable filled = exception.fillInStackTrace();

        assertNotNull(filled);
        assertEquals(exception, filled);
        assertNotNull(filled.getStackTrace());
        assertTrue(filled.getStackTrace().length > 0);
    }

       */
      byte[] hashTable = new byte[tableSize];
      Arrays.fill(hashTable, ABSENT);

      int outI = 0;
      entries:
      for (int i = 0; i < n; i++) {
        int keyIndex = 2 * i + keyOffset;
        int outKeyIndex = 2 * outI + keyOffset;
        // requireNonNull is safe because the first `2*n` elements have been filled in.
        Object key = requireNonNull(alternatingKeysAndValues[keyIndex]);

        StackTraceElement[] originalStackTrace = exception.getStackTrace();
        assertNotNull(originalStackTrace);

        Throwable filled = exception.fillInStackTrace();
        assertSame(exception, filled);

        StackTraceElement[] newStackTrace = exception.getStackTrace();
        assertNotNull(newStackTrace);
    }

    public void test_multipleInstances() {

    @Nullable ImmutableMapEntry<K, V>[] keyTable = createEntryArray(tableSize);
    @Nullable ImmutableMapEntry<K, V>[] valueTable = createEntryArray(tableSize);
    /*
     * The cast is safe: n==entryArray.length means that we have filled the whole array with Entry
     * instances, in which case it is safe to cast it from an array of nullable entries to an array
     * of non-null entries.
     */
    @SuppressWarnings("nullness")
    Entry<K, V>[] entries =

      int n, @Nullable Entry<K, V>[] entryArray, boolean throwIfDuplicateKeys)
      throws BucketOverflowException {
    /*
     * The cast is safe: n==entryArray.length means that we have filled the whole array with Entry
     * instances, in which case it is safe to cast it from an array of nullable entries to an array
     * of non-null entries.
     */
    @SuppressWarnings("nullness")

abstract class AbstractStreamingHasher extends AbstractHasher {
  /** Buffer via which we pass data to the hash algorithm (the implementor) */
  private final ByteBuffer buffer;

  /** Number of bytes to be filled before process() invocation(s). */
  private final int bufferSize;

  /** Number of bytes processed per process() invocation. */
  private final int chunkSize;

  /**

	ResumeItemsSkipped uint64 `json:"-"`
	ResumeBytesDone    uint64 `json:"-"`
	ResumeBytesFailed  uint64 `json:"-"`
	ResumeBytesSkipped uint64 `json:"-"`

	// Filled on startup/restarts.
	QueuedBuckets []string

	// Filled during heal.
	HealedBuckets []string

	// ID of the current healing operation
	HealID string

	ItemsSkipped uint64
	BytesSkipped uint64

	RetryAttempts uint64

        info.setCapability(capability);

        return info;
    }

    private void encodeSockaddr(byte[] buffer, int offset) {
        // MS-SMB2: SockAddr_Storage field is 128 bytes
        // Clear the entire field first
        for (int i = 0; i < 128; i++) {
            buffer[offset + i] = 0;
        }

        if (ipv6) {
            // IPv6 sockaddr_in6 structure (Windows AF_INET6 = 23)