put(key, calculatedValue);
    } catch (RuntimeException e) {
      statsCounter.recordLoadException(ticker.read() - startTime);
      throw new UncheckedExecutionException(e);
    } catch (Exception e) {
      statsCounter.recordLoadException(ticker.read() - startTime);
      throw new ExecutionException(e);
    } catch (Error e) {
      statsCounter.recordLoadException(ticker.read() - startTime);

        multiExceptionListIterator.promoteToNext(targetReturnValueFromNext);
      }

      referenceReturnValue = method.execute(reference);
    } catch (PermittedMetaException e) {
      referenceException = e;
    } catch (UnknownElementException e) {
      throw new AssertionError(e);
    }

    if (referenceException == null) {
      if (targetException != null) {

        try {
            return SingletonLaContainer.getComponent(clazz);
        } catch (final NullPointerException e) {
            if (logger.isDebugEnabled()) {
                throw new ContainerNotAvailableException(clazz.getCanonicalName(), e);
            }
            throw new ContainerNotAvailableException(clazz.getCanonicalName());
        } catch (final ComponentNotFoundException | AutoBindingFailureException e) {

        // Execute and verify
        CIFSException thrown = assertThrows(CIFSException.class, () -> {
            watchHandle.watch();
        });

        assertEquals("Watch operation failed", thrown.getMessage());
        verify(watchHandle, times(1)).watch();
    }

    /**
     * Test call() method delegates to watch()
     */
    @Test

    boolean androidMorEarlier = Build.VERSION.SDK_INT <= 23;
    try {
      sendRequest(client, "https://valid-isrgrootx1.letsencrypt.org/robots.txt");
      if (androidMorEarlier) {
        fail();
      }
    } catch (SSLHandshakeException sslhe) {
      assertTrue(androidMorEarlier);
    }
  }

  @Test public void getPassesAdditionalCert() throws IOException, CertificateException {

          ? directoryToResponse(path, file)
          : fileToResponse(path, file);
    } catch (FileNotFoundException e) {
      return new MockResponse()
          .setStatus("HTTP/1.1 404")
          .addHeader("content-type: text/plain; charset=utf-8")
          .setBody("NOT FOUND: " + path);
    } catch (IOException e) {
      return new MockResponse()
          .setStatus("HTTP/1.1 500")

      list.add("5");
      fail("transformed list is addable");
    } catch (UnsupportedOperationException expected) {
    }
    list.remove(0);
    assertEquals(asList("2", "3", "4"), list);
    list.remove("3");
    assertEquals(asList("2", "4"), list);
    try {
      list.set(0, "5");
      fail("transformed list is setable");
    } catch (UnsupportedOperationException expected) {
    }
    list.clear();

                languageHelper.getReindexScriptSource());
    }

    public void test_init() {
        try {
            languageHelper.init();
            // Should not throw exception
        } catch (Exception e) {
            fail("init() should not throw an exception: " + e.getMessage());
        }
    }

    public void test_updateDocument_withExistingLang() {
        Map<String, Object> doc = new HashMap<>();

    assertEquals(
        "Shouldn't catch any more events when unregistered.", expectedEvents, catcher1.getEvents());
    assertEquals("Two correct events should be delivered.", expectedEvents, catcher2.getEvents());

    assertThrows(IllegalArgumentException.class, () -> bus.unregister(catcher1));

    bus.unregister(catcher2);
    bus.post(EVENT);
    assertEquals(

                CopyUtil.copy(is, os);
            } catch (final IOException e) {
                throw new CrawlerSystemException("Could not store " + file.getAbsolutePath(), e);
            }
        }
        try {
            resultData.setData(path.getBytes(charsetName));
        } catch (final UnsupportedEncodingException e) {
            if (logger.isInfoEnabled()) {