}
        };

        cookieResourceProvider = new FessCookieResourceProvider(ComponentUtil.getFessConfig(), cookieCipher);
    }

    @Override
    public void tearDown() throws Exception {
        if (originalFessConfig != null) {
            ComponentUtil.setFessConfig(originalFessConfig);
        }
        super.tearDown();
    }

    // Test provider initialization
    public void test_providerInitialization() {

        assertTrue(stackTrace.length > 0);
        // Verify that current test method appears in stack trace
        boolean foundTestMethod = false;
        for (StackTraceElement element : stackTrace) {
            if (element.getMethodName().equals("test_stackTrace")) {
                foundTestMethod = true;
                break;
            }
        }
        assertTrue(foundTestMethod);
    }

        // Verify that this test method appears in the stack trace
        boolean foundTestMethod = false;
        for (StackTraceElement element : exception.getStackTrace()) {
            if ("test_stackTrace".equals(element.getMethodName())) {
                foundTestMethod = true;
                break;
            }
        }
        assertTrue(foundTestMethod);
    }

    assertGet(key, asList(values));
  }

  protected void assertGet(K key, Collection<? extends V> values) {
    assertEqualIgnoringOrder(values, multimap().get(key));

    if (!values.isEmpty()) {
      assertEqualIgnoringOrder(values, multimap().asMap().get(key));
      assertFalse(multimap().isEmpty());
    } else {
      assertNull(multimap().asMap().get(key));
    }

    assertThat(min(2, 1, reverse)).isEqualTo(2);
    assertThat(max(1, 2, reverse)).isEqualTo(1);
    assertThat(max(2, 1, reverse)).isEqualTo(1);
  }

  /**
   * Fails compilation if the signature of min and max is changed to take {@code Comparator<T>}
   * instead of {@code Comparator<? super T>}.
   */
  public void testMinMaxWithSupertypeComparator() {

  /**
   * awaitFullGc() is not quite as reliable a way to ensure calling of a specific finalize method as
   * the more direct await* methods, but should be reliable enough in practice to avoid flakiness of
   * this test. (And if it isn't, we'd like to know about it first!)
   */
  public void testAwaitFullGc() {
    CountDownLatch finalizerRan = new CountDownLatch(1);
    WeakReference<Object> ref =
        new WeakReference<Object>(

    // skip fully
    reader = new CharSequenceReader(charSequence);
    assertEquals(expected.length(), reader.skip(Long.MAX_VALUE));
    assertFullyRead(reader);

    // skip 5 and read the rest
    if (expected.length() > 5) {
      reader = new CharSequenceReader(charSequence);
      assertEquals(5, reader.skip(5));

      buf = new char[expected.length() - 5];

        System.out.println("[ Looking for " + groupId + ":" + artifactId + " ]");
        for (Artifact a : project.getArtifacts()) {
            System.out.println(a.toString());
            if (artifactId.equals(a.getArtifactId()) && a.getGroupId().equals(groupId)) {
                System.out.println("RETURN");
                return a;
            }
        }
        System.out.println("Return null");

    }

    public static String normalizeText(final String str, final int initialCapacity, final int maxAlphanumTermSize,
            final int maxSymbolTermSize, final boolean removeDuplication) {
        if (str == null) {
            return StringUtil.EMPTY;
        }
        try (final Reader reader = new StringReader(str)) {

pods running with a service account may only reference secrets specified in the service account's secrets field. Kubernetes clusters are only affected if the ServiceAccount admission plugin and the `kubernetes.io/enforce-mountable-secrets` annotation are used together with ephemeral containers.

**Note**: This only impacts the cluster if the ServiceAccount admission plugin is used (most cluster should have this on by default as recommended in https://kubernetes.io/docs/reference/acces...