authenticationManager.addChain(chain);

        boolean result = authenticationManager.changePassword("testuser", "newpass");

        assertTrue(result);
        assertEquals(1, chain.changePasswordCallCount);
        assertEquals("testuser", chain.lastChangePasswordUsername);
        assertEquals("newpass", chain.lastChangePasswordPassword);
    }

    // Test changePassword with single chain failure

        }

        // Perform sequential operations
        for (User user : users) {
            chain.update(user);
            chain.changePassword(user.getName(), "newpass" + user.getName());
            chain.load(user);
            if (users.indexOf(user) % 2 == 0) {
                chain.delete(user);
            }
        }

        // Verify all operations were tracked

                        final String filename = getImageFilename(docId);
                        final Path newPath = basePath.resolve(filename);
                        if (!path.equals(newPath)) {
                            try {
                                try {
                                    Files.createDirectories(newPath.getParent());
                                } catch (final FileAlreadyExistsException e) {

    Object newTable = CompactHashing.createTable(newCapacity);
    int newMask = newCapacity - 1;

    if (targetEntryIndex != UNSET) {
      // Add target first; it must be last in the chain because its entry hasn't yet been created
      CompactHashing.tableSet(newTable, targetHash & newMask, targetEntryIndex + 1);
    }

    Object oldTable = requireTable();
    int[] entries = requireEntries();

    @Override
    HashCode makeHash(Hasher[] hashers) {
      byte[] bytes = new byte[bits() / 8];
      int i = 0;
      for (Hasher hasher : hashers) {
        HashCode newHash = hasher.hash();
        i += newHash.writeBytesTo(bytes, i, newHash.bits() / 8);
      }
      return HashCode.fromBytesNoCopy(bytes);
    }

    @Override
    public int bits() {
      int bitSum = 0;

       */

      int newCount = count;
      AtomicReferenceArray<E> newTable = newEntryArray(oldCapacity << 1);
      threshold = newTable.length() * 3 / 4;
      int newMask = newTable.length() - 1;
      for (int oldIndex = 0; oldIndex < oldCapacity; ++oldIndex) {
        // We need to guarantee that any existing reads of old Map can
        // proceed. So we cannot yet null out each bin.