} catch (final Exception ex) {}
                        if (handlerClass == null) {
                            handlerClass = ClassLoader.getSystemClassLoader().loadClass(className);
                        }
                        handler = (URLStreamHandler) handlerClass.newInstance();
                        break;
                    } catch (final Exception ex) {}
                }

			}

			if c.before != "" {
				callMethod(v, "Before", c.before)
			}

			if c.after != "" {
				callMethod(v, "After", c.after)
			}

			if c.match != nil {
				callMethod(v, "Match", c.match)
			}

			if c.remove {
				callMethod(v, "Remove", c.name)
			} else if c.replace {
				callMethod(v, "Replace", c.name, c.h)
			} else {
				callMethod(v, "Register", c.name, c.h)

            intervalControlHelper.delayByRules();
        } catch (final Exception e) {
            if (logger.isDebugEnabled()) {
                logger.debug("Failed to apply interval control rules", e);
            }
        }

        try {
            super.delayForWaitingNewUrl();
        } catch (final Exception e) {
            if (logger.isDebugEnabled()) {

          v0(),
          getMap().putIfAbsent(k0(), v0()));
    } catch (UnsupportedOperationException tolerated) {
    }
    expectUnchanged();
  }

  @MapFeature.Require(absent = SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)
  public void testPutIfAbsent_unsupportedPresentDifferentValue() {
    try {
      getMap().putIfAbsent(k0(), v3());
    } catch (UnsupportedOperationException tolerated) {
    }

                try {
                    startLatch.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                // wait for all thread to end
                try {
                    endLatch.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

        MavenExecutionResult result;

        try {
            result = doExecute(request);
        } catch (OutOfMemoryError e) {
            result = addExceptionToResult(new DefaultMavenExecutionResult(), e);
        } catch (RuntimeException e) {
            // TODO Hack to make the cycle detection the same for the new graph builder

            if (failureUrl != null) {
                failureUrlId = failureUrl.getId();
            }
        } catch (final ContainerNotAvailableException e) {
            if (logger.isDebugEnabled()) {
                logger.debug("container was destroyed.");
            }
            return;
        } catch (final Exception e) {
            if (!ComponentUtil.available()) {
                if (logger.isDebugEnabled()) {

        while (true) {
          val socket = serverSocket!!.accept()
          connectionCount.incrementAndGet()
          service(socket)
        }
      } catch (e: SocketException) {
        logger.info("$threadName done accepting connections: ${e.message}")
      } catch (e: IOException) {
        logger.log(Level.WARNING, "$threadName failed unexpectedly", e)
      } finally {
        for (socket in openSockets) {

  }

  @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();
  }

        }

        @Override
        public void run() {
            try {
                ans = NbtAddress.getByName(host, type, scope, svr);
            } catch (final UnknownHostException uhe) {
                this.uhe = uhe;
            } catch (final Exception ex) {
                this.uhe = new UnknownHostException(ex.getMessage());
            } finally {
                synchronized (sem) {