Thread.sleep(10000);
                } catch (InterruptedException e) {
                    throw new CrawlingAccessException(e);
                }
                return null;
            }
        };
        client.setAccessTimeout(1);
        try {
            client.doGet("http://localhost/");
            fail();
        } catch (CrawlingAccessException e) {

   * despite the @IgnoreJRERequirement annotation there. For details, see ImmutableSortedMultiset.
   */
  private static void closeUnchecked(Closeable closeable) {
    try {
      closeable.close();
    } catch (IOException e) {
      throw new UncheckedIOException(e);
    }
  }

  /**
   * Returns the size of this source in chars, if the size can be easily determined without actually
   * opening the data stream.

                                new DefaultModelBuildingRequest(request).setModelSource(source);
                        return defaultModelBuilder.readRawModel(gaBuildingRequest, problems);
                    } catch (ModelBuildingException e) {
                        // gathered with problem collector
                    }
                }
                return null;
            }

        if (!Constants.T.equals(scheduledJob.getAvailable())) {
            logger.info("Inactive Job {}:{}", id, scheduledJob.getName());
            try {
                unregister(scheduledJob);
            } catch (final Exception e) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Failed to delete Job {}", scheduledJob, e);
                }
            }
            return;
        }

            if (StringUtils.isEmpty(nonce) || !nonce.equals(stateData.getNonce())) {
                throw new SsoLoginException("could not validate nonce");
            }
        } catch (final SsoLoginException e) {
            throw e;
        } catch (final Exception e) {
            throw new SsoLoginException("could not validate nonce", e);
        }
    }

                                -1,
                                null));
                    }
                    server.setPassword(securityDispatcher.decrypt(password));
                } catch (SecDispatcherException | IOException e) {
                    problems.add(new DefaultSettingsProblem(
                            "Failed to decrypt password for server " + server.getId() + ": " + e.getMessage(),

        if (propertyType == java.util.Date.class) {
            try {
                return TimestampConversionUtil.toDate(arg);
            } catch (final ParseRuntimeException ex) {
                try {
                    return DateConversionUtil.toDate(arg);
                } catch (final ParseRuntimeException ex2) {
                    return TimeConversionUtil.toDate(arg);
                }
            }

            }
        } catch (XMLStreamException | IOException e) {
            throw new PlexusConfigurationException(e.getMessage(), e);
        }
    }

    private static BufferedInputStream reset(StreamSupplier inputSupplier, BufferedInputStream bis) throws IOException {
        try {
            bis.reset();
            return bis;
        } catch (IOException e) {

        final String value = System.getProperty("corelib.timeout_task.num_of_threads");
        if (StringUtil.isNotBlank(value)) {
            try {
                nThreads = Integer.parseInt(value);
            } catch (final NumberFormatException e) {
                logger.warn("Failed to parse " + value, e);
            }
        }
        if (nThreads < 1) {
            nThreads = 1;
        }

                cr.createNewFile();
                assertNotified(w, FileNotifyInformation.FILE_ACTION_ADDED, "created", null);
            }
        }
        catch ( TimeoutException e ) {
            log.info("Timeout waiting", e);
            fail("Did not recieve notification");
        }
    }


    @Test