transportContextField.setAccessible(true);
            transportContextField.set(ntlmServlet, cifsContext);
        } catch (Exception e) {
            throw new RuntimeException("Failed to inject mock CIFSContext", e);
        }

        when(cifsContext.getTransportPool()).thenReturn(transportPool);

        }
    }

    @Before
    public void before() throws Exception {
        try {
            runner.admin().indices().prepareDelete("DefaultContentsParserTest*", "fess_suggest*").execute().actionGet();
        } catch (Exception e) {
            // ignore
        }
        runner.refresh();
        suggester = Suggester.builder().build(runner.client(), "DefaultContentsParserTest");
        suggester.createIndexIfNothing();
    }

      }
      if (!range.hasUpperBound()) {
        effectiveRange = effectiveRange.intersection(Range.atMost(domain.maxValue()));
      }
    } catch (NoSuchElementException e) {
      throw new IllegalArgumentException(e);
    }

    boolean empty;
    if (effectiveRange.isEmpty()) {
      empty = true;
    } else {
      /*

   */
  private static int runSuppressionFailureTest(CharSource in, CharSink out) {
    try {
      in.copyTo(out);
      fail();
    } catch (IOException expected) {
      return expected.getSuppressed().length;
    }
    throw new AssertionError(); // can't happen
  }

  private static CharSource newNormalCharSource() {

            }
          };
      Runnable barrierTask =
          new Runnable() {
            @Override
            public void run() {
              try {
                barrier.await();
              } catch (Exception e) {
                throw new RuntimeException(e);
              }
            }
          };
      executor.execute(errorTask);
      service.execute(barrierTask); // submit directly to the service

      try {
        checkNoConflictInKeyBucket(key, value, nextInKeyBucket, /* throwIfDuplicateKeys= */ true);
        checkNoConflictInValueBucket(value, entry, nextInValueBucket);
      } catch (BucketOverflowException e) {
        return JdkBackedImmutableBiMap.create(n, entryArray);
      }
      ImmutableMapEntry<K, V> newEntry =
          (nextInValueBucket == null && nextInKeyBucket == null)

        if (encoding == null) {
            return new ByteArrayInputStream(contents.getBytes());
        }
        try {
            return new ByteArrayInputStream(contents.getBytes(encoding));
        } catch (final UnsupportedEncodingException ex) {
            throw new IORuntimeException(ex);
        }
    }

    /**
     * Encodes the value of an attribute.
     *
     * @param s

            return null;
        });
        try (InputStream inputStream = form.charMappingFile.getInputStream()) {
            file.update(inputStream);
        } catch (final IOException e) {
            logger.warn("Failed to process a request.", e);
            throwValidationErrorApi(messages -> messages.addErrorsFailedToUploadProtwordsFile(GLOBAL));
        }

                                }
                            }
                        }
                    }
                }
            } catch (final Exception e) {
                logger.warn("Failed to load DataStore plugin: path={}", jarFile.getAbsolutePath(), e);
            }
        }
        return nameSet.stream().sorted().collect(Collectors.toList());

   *   domainName = InternetDomainName.from(name);
   * } catch (IllegalArgumentException e) {
   *   domainName = DEFAULT_DOMAIN;
   * }
   * }
   *
   * @since 8.0 (previously named {@code isValidLenient})
   */
  public static boolean isValid(String name) {
    try {
      InternetDomainName unused = from(name);
      return true;
    } catch (IllegalArgumentException e) {
      return false;
    }
  }