*
     * @see jcifs.CIFSContext#get(java.lang.String)
     */
    @Override
    public SmbResource get(final String url) throws CIFSException {
        try {
            return new SmbFile(url, this);
        } catch (final MalformedURLException e) {
            throw new CIFSException("Invalid URL " + url, e);
        }
    }

    /**
     *
     * {@inheritDoc}
     *

     */
    public static String getCanonicalPath(final File file) {
        assertArgumentNotNull("file", file);

        try {
            return file.getCanonicalPath();
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

    /**
     * Converts this abstract pathname to a <code>file:</code> URL.
     *

                }
                lastTime.set(currentTime);
            }
        } catch (final InterruptedException e) {
            throw new InterruptedRuntimeException(e);
        } catch (final Exception e) {
            throw new CrawlerSystemException(e);
        }
    }

        try (final XContentBuilder builder = func.apply(mediaType.contentBuilder(), ToXContent.EMPTY_PARAMS)) {
            builder.flush();
            return builder.getOutputStream();
        } catch (final IOException e) {
            if (logger.isDebugEnabled()) {
                logger.debug("Failed to print the output.", e);
            }
            return new ByteArrayOutputStream();
        }
    }

                        map.put("lastModified", new Date(Files.getLastModifiedTime(filePath).toMillis()));
                    } catch (final IOException e) {
                        throw new IORuntimeException(e);
                    }
                    logFileItems.add(map);
                });
            } catch (final Exception e) {
                throw new FessSystemException("Failed to access log files.", e);
            }

          getMap()
              .computeIfAbsent(
                  k0(),
                  k -> {
                    assertEquals(k0(), k);
                    return v0();
                  }));
    } catch (UnsupportedOperationException tolerated) {
    }
    expectUnchanged();
  }

  @MapFeature.Require(absent = SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)

        body.crudMode = CrudMode.CREATE;
        final DataConfig dataConfig = getDataConfig(body).map(entity -> {
            try {
                dataConfigService.store(entity);
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);
                throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)));

              references.remove(this);
              if (!serverSocket.isClosed()) {
                try {
                  serverSocket.close();
                  finalizeReferentRan.set(true);
                } catch (IOException e) {
                  throw new UncheckedIOException(e);
                }
              }
            }
          };
      references.add(reference);
      return myServer;
    }

                processedClasses.add(className);
            }
        }

        if (roundEnv.processingOver()) {
            try {
                updateFileIfChanged();
            } catch (Exception e) {
                logError("Error updating file", e);
            }
        }

        return true;
    }

    /**

            zipExtractor.getText(in, null);
            fail();
        } catch (MaxLengthExceededException e) {
            // pass
        }
        zipExtractor.setMaxContentSize(-1);
    }

    public void test_getText_null() {
        try {
            zipExtractor.getText(null, null);
            fail();
        } catch (final CrawlerSystemException e) {
            // NOP
        }
    }