return cache.computeIfAbsent(key, k -> {
                try {
                    return supplier.load();
                } catch (PluginResolutionException | PluginContainerException e) {
                    throw new RuntimeException(e);
                }
            });
        } catch (RuntimeException e) {
            if (e.getCause() instanceof PluginResolutionException pluginResolutionException) {

            localRepositoryPath = new File(path, "repository").getAbsolutePath();
        }

        try {
            return repositorySystem.createLocalRepository(new File(localRepositoryPath));
        } catch (Exception e) {
            throw new MavenExecutionRequestPopulationException("Cannot create local repository.", e);
        }
    }

    private void baseDirectory(MavenExecutionRequest request) {

        try {
            converter.processConfiguration(
                    converterLookup, request.getBean(), classLoader, plexusConfig, evaluator, null);
        } catch (ComponentConfigurationException e) {
            throw new BeanConfigurationException(e.getMessage(), e);
        }
    }

    static class BeanExpressionEvaluator implements TypeAwareExpressionEvaluator {

    try {
      Platform.get().connectSocket(rawSocket, route.socketAddress, socketConnectTimeoutMillis)
    } catch (e: ConnectException) {
      throw ConnectException("Failed to connect to ${route.socketAddress}").apply {
        initCause(e)
      }
    }

    // The following try/catch block is a pseudo hacky way to get around a crash on Android 7.0
    // More details:

                    plugin, request.getRepositories(), request.getRepositorySession());
        } catch (PluginResolutionException e) {
            logger.debug("Ignoring unresolvable plugin version {}", version, e);
            return false;
        } catch (Exception e) {
            // ignore for now and delay failure to higher level processing
            return true;
        }

    }

    @Test
    public void testMemoryBasedCacheConstructorWithNull() {
        try {
            new ContentCache((byte[]) null);
            fail("Expected IllegalArgumentException");
        } catch (IllegalArgumentException e) {
            assertTrue(e.getMessage().contains("data must not be null"));
        }
    }

    @Test
    public void testMemoryBasedCacheDefensiveCopy() throws IOException {

            try {
                // Create SmbFile objects from cached info
                SmbFile file = createSmbFileFromCache(directoryPath, fileInfo);
                files.add(file);
            } catch (Exception e) {
                log.warn("Error creating SmbFile from cache for {}: {}", fileInfo.getName(), e.getMessage());
                // For testing purposes, continue processing other files

            field.set(obj, value);
        } catch (Exception e) {
            throw new RuntimeException("Failed to set field " + fieldName, e);
        }
    }

    private Object getFieldValue(Object obj, String fieldName) {
        try {
            Field field = findField(obj.getClass(), fieldName);
            field.setAccessible(true);
            return field.get(obj);
        } catch (Exception e) {

            assertTrue(true);
        } catch (IllegalArgumentException e) {
            fail();
        }

        try {
            settings.badword().add("");
            fail();
        } catch (IllegalArgumentException e) {
            assertTrue(true);
        }

        try {
            settings.badword().add("aaaa bbb");
            fail();
        } catch (IllegalArgumentException e) {

  }

  @MapFeature.Require(value = SUPPORTS_REMOVE, absent = ALLOWS_NULL_KEY_QUERIES)
  public void testRemove_nullKeyQueriesUnsupported() {
    try {
      assertFalse(getMap().remove(null, v3()));
    } catch (NullPointerException tolerated) {
      // since the operation would be a no-op, the exception is not required
    }
    expectUnchanged();
  }