try {
            collect.setTrace(RequestTrace.newChild(trace, depRequest));
            node = repoSystem.collectDependencies(session, collect).getRoot();
            result.setDependencyGraph(node);
        } catch (DependencyCollectionException e) {
            result.setDependencyGraph(e.getResult().getRoot());
            result.setCollectionErrors(e.getResult().getExceptions());

            throw new DependencyResolutionException(

import importlib
from unittest.mock import patch

import pytest
from fastapi.testclient import TestClient

from ...utils import needs_py310


@pytest.fixture(
    name="client",
    params=[
        "tutorial001_py39",
        pytest.param("tutorial001_py310", marks=needs_py310),
    ],
)
def get_client(request: pytest.FixtureRequest):
    mod = importlib.import_module(f"docs_src.body.{request.param}")

                break;
            }
            if (id == id0) {
                try {
                    return new String(type2token, ri, len, SmbConstants.UNI_ENCODING);
                } catch (final java.io.UnsupportedEncodingException uee) {
                    break;
                }
            }
            ri += len;
        }

        return null;
    }

    /**

            throws RepositoryMetadataStoreException {
        try {
            updateRepositoryMetadata(localRepository, remoteRepository);
        } catch (IOException | XMLStreamException e) {
            throw new RepositoryMetadataStoreException("Error updating group repository metadata", e);
        }
    }

    getMap().putAll(emptyMap());
    expectUnchanged();
  }

  @MapFeature.Require(absent = SUPPORTS_PUT)
  public void testPutAll_unsupportedNothing() {
    try {
      getMap().putAll(emptyMap());
    } catch (UnsupportedOperationException tolerated) {
    }
    expectUnchanged();
  }

  @MapFeature.Require(SUPPORTS_PUT)
  public void testPutAll_supportedNonePresent() {
    putAll(createDisjointCollection());

            .isNotEqualTo(paramType);
      } catch (IllegalArgumentException notSubtype1) {
        // The raw class isn't even a subclass.
      }
    }
    if (!spec.suppressGetSupertype()) {
      try {
        assertThat(getSupertype(paramType, TypeToken.of(returnType).getRawType()))
            .isNotEqualTo(returnType);
      } catch (IllegalArgumentException notSubtype2) {

            try {
                final Instant instant = Instant.from(DateTimeFormatter.ISO_INSTANT.parse(value.toString()));
                return LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
            } catch (final DateTimeParseException e) {
                logger.debug("Invalid date format: {}", value, e);
            }
        }
        return DfTypeUtil.toLocalDateTime(value);
    }

 *     ExecutionException}, {@code UncheckedExecutionException}, and {@code ExecutionError}. Any
 *     code that is still catching {@code ComputationException} may need to be updated to catch some
 *     of those types instead. (Note that this type, though deprecated, is not planned to be removed
 *     from Guava.)
 */
@Deprecated
@GwtCompatible
public class ComputationException extends RuntimeException {

*-----------------------+---------------+------------+-----------+-----------------------+-----------------------+
| <<<test-jar>>>        | <<<tests>>>   | <<<jar>>>  | java      | classes, patch module |                       |
*-----------------------+---------------+------------+-----------+-----------------------+-----------------------+

        getLabelType(form).ifPresent(entity -> {
            try {
                labelTypeService.store(entity);
                saveInfo(messages -> messages.addSuccessCrudCreateCrudTable(GLOBAL));
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);
                throwValidationError(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)),