if (line.contains(text)) {
                    return true;
                }
            }
        } catch (IOException e) {
            // ignore
        }
        return false;
    }

    private String getFileName(String match, File currentFile) {
        if (match.isEmpty()) {
            return currentFile.getName();
        } else {

    assertThat(stats.loadSuccessCount()).isEqualTo(4);
    assertThat(stats.loadExceptionCount()).isEqualTo(0);
    assertThat(stats.hitCount()).isEqualTo(3);

    // duplicate keys are ignored, and don't impact stats
    assertThat(cache.getAll(asList(4, 5))).containsExactly(4, 4, 5, 5);
    stats = cache.stats();
    assertThat(stats.missCount()).isEqualTo(5);
    assertThat(stats.loadSuccessCount()).isEqualTo(5);

   *
   * <p>will return {@code Stream.of("foo1:bar1", "foo2:bar2")}.
   *
   * <p>The resulting stream will only be as long as the shorter of the two input streams; if one
   * stream is longer, its extra elements will be ignored.
   *
   * <p>Note that if you are calling {@link Stream#forEach} on the resulting stream, you might want
   * to consider using {@link #forEachPair} instead of this method.
   *

          continue;
        }
        responseQueue.put(new Response(request.methodName, result, null));
      }
    } catch (ThreadDeath death) {
      return;
    } catch (InterruptedException ignored) {
      // SynchronousQueue sometimes throws InterruptedException while the threads are stopping.
    } catch (Throwable uncaught) {
      this.uncaughtThrowable = uncaught;
    }
  }

        if self.realm:
            return {"WWW-Authenticate": f'Basic realm="{self.realm}"'}
        return {"WWW-Authenticate": "Basic"}

    async def __call__(  # type: ignore
        self, request: Request
    ) -> Optional[HTTPBasicCredentials]:
        authorization = request.headers.get("Authorization")
        scheme, param = get_authorization_scheme_param(authorization)

        } finally {
            if (fos != null) {
                try {
                    fos.close();
                } catch (final IOException e) {
                    // ignore
                }
            }
        }
        lastModified = propertiesFile.lastModified();
    }

    /**
     * Returns the current properties, reloading them if the file has been updated.

                            try {
                                keyManager.rotateSessionKey(sid);
                            } catch (GeneralSecurityException e) {
                                // Ignore in concurrent test
                            }
                        }
                    }
                } finally {
                    latch.countDown();
                }
            });

                if (buf.length() > 0) {
                    buf.append(" : ");
                }
                buf.append(ip);
            }
        } catch (final Exception e) {
            // ignore
        }
        return buf.toString();
    }

    /**
     * Checks if the given filename is a log file based on its extension.
     *
     * @param name the filename to check

	if err := checkListObjsArgs(ctx, o.Bucket, o.Prefix, o.Marker); err != nil {
		return entries, err
	}

	// Marker points to before the prefix, just ignore it.
	if o.Marker < o.Prefix {
		o.Marker = ""
	}

	// Marker is set validate pre-condition.
	if o.Marker != "" && o.Prefix != "" {
		// Marker not common with prefix is not implemented. Send an empty response

   *
   * If a challenge uses the `token68` variant instead of auth params, there is exactly one
   * auth param in the challenge at key null. Invalid headers and challenges are ignored.
   * No semantic validation is done, for example that `Basic` auth must have a `realm`
   * auth param, this is up to the caller that interprets these challenges.
   */
  fun challenges(): List<Challenge> {