return values().asList().get(index + 1);
              });
    } catch (UnsupportedOperationException tolerated) {
    }
    expectUnchanged();
  }

  @MapFeature.Require(absent = SUPPORTS_PUT)
  public void testReplaceAll_unsupportedNoOpFunction() {
    try {
      getMap().replaceAll((K k, V v) -> v);
    } catch (UnsupportedOperationException tolerated) {
    }
    expectUnchanged();
  }

                    artifacts.addAll(descriptor.getExportedArtifacts());
                    packages.addAll(descriptor.getExportedPackages());
                }
            }
        } catch (IOException ignored) {
            // exports descriptors are entirely optional
        }

        return new CoreExtensionEntry(loader, artifacts, packages, null, null);
    }

    try {
      joiner.appendTo(NASTY_APPENDABLE, set);
    } catch (IOException e) {
      throw new AssertionError(e);
    }

    try {
      joiner.appendTo(NASTY_APPENDABLE, set.iterator());
    } catch (IOException e) {
      throw new AssertionError(e);
    }

    try {
      joiner.appendTo(NASTY_APPENDABLE, array);
    } catch (IOException e) {
      throw new AssertionError(e);
    }
  }

      Class<T> interfaceType,
      Function<T, ? extends T> wrapperFunction,
      String... expectedMessages) {
    try {
      tester.testForwarding(interfaceType, wrapperFunction);
    } catch (AssertionFailedError expected) {
      for (String message : expectedMessages) {
        assertThat(expected).hasMessageThat().contains(message);
      }
      return;
    }

                return parseTextSitemaps(bis);
            }
            // gz
            bis.reset();
            return parse(new GZIPInputStream(bis), false);
        } catch (final CrawlingAccessException e) {
            throw e;
        } catch (final Exception e) {
            throw new CrawlingAccessException("Could not parse Sitemaps: " + preloadDate, e);
        }
    }

    /**

        this.opad = hmac.opad;
        this.md5 = (MessageDigest) hmac.md5.clone();
    }

    @Override
    public Object clone() {
        try {
            return new HMACT64(this);
        } catch (final CloneNotSupportedException ex) {
            throw new IllegalStateException(ex.getMessage());
        }
    }

    @Override
    protected byte[] engineDigest() {

            return new Metadata();
        }

        try (InputStream input = Files.newInputStream(metadataPath)) {
            return new Metadata(new MetadataStaxReader().read(input, false));
        } catch (IOException | XMLStreamException e) {
            throw new RepositoryException("Could not parse metadata " + metadataPath + ": " + e.getMessage(), e);
        }
    }

 *   <li>Access to the type of the toolchain (e.g., JDK, compiler).</li>
 *   <li>Retrieval of the specific version of the toolchain.</li>
 *   <li>Configuration of toolchain properties to match the project's requirements.</li>
 * </ul>
 *
 * <p>Example usage:</p>
 * <pre>
 * Toolchain toolchain = ...; // Obtain a Toolchain instance
 * String type = toolchain.getType(); // Get the type of the toolchain

			if len(relations.Relations) != len(rs.Relations) {
				t.Errorf("schema relations count don't match, expects %d, got %d", len(rs.Relations), len(relations.Relations))
			}
			if len(relations.EmbeddedRelations) != len(rs.EmbeddedRelations) {
				t.Errorf("schema embedded relations count don't match, expects %d, got %d", len(rs.EmbeddedRelations), len(relations.EmbeddedRelations))
			}

            try {
                if (dirents[i].getType() == SmbConstants.TYPE_NAMED_PIPE) {
                    continue;
                }
            } catch (final SmbAuthException sae) {
                log.warn("Auth failed", sae);
            } catch (final SmbException se) {
                log.warn("Connection failed", se);
                if (se.getNtStatus() != NtStatus.NT_STATUS_UNSUCCESSFUL) {