}

        @Test
        @DisplayName("Should check if intermediate")
        void testIsIntermediate() {
            // Test with mock
            when(mockReferralData.isIntermediate()).thenReturn(false);
            assertFalse(mockReferralData.isIntermediate());
            verify(mockReferralData, times(1)).isIntermediate();

            // Test with concrete implementation

        }

        @Test
        @DisplayName("Should get and set intermediate flag")
        void testIntermediate() {
            assertFalse(referralData.isIntermediate());
            referralData.intermediate();
            assertTrue(referralData.isIntermediate());
        }
    }

    @Nested
    @DisplayName("Cache Management Tests")
    class CacheManagementTests {

    }

    /**
     * Mark this referral as intermediate (requires further resolution)
     */
    public void intermediate() {
        this.intermediate = true;
    }

    /**
     * @return the intermediate
     */
    @Override
    public boolean isIntermediate() {
        return this.intermediate;
    }

    @Override
    public String toString() {

                }
            }
        }

        if (dr == null && path != null) {
            dr = getStandaloneCached(domain, root, path, now);
        }

        if (dr != null && dr.isIntermediate()) {
            dr = resolveIntermediates(tf, path, depthLimit, dr);
        }

        return dr;

    }

    /**
     * @param tf
     * @param path
     * @param depthLimit

    assertThrows(IllegalArgumentException.class, () -> intermediate.indexes(1, -1, 3));
  }

  public void testScale_indexes_varargs_tooHigh() {
    Quantiles.Scale intermediate = Quantiles.scale(10);
    assertThrows(IllegalArgumentException.class, () -> intermediate.indexes(1, 11, 3));
  }

  public void testScale_indexes_collection_negative() {

    assertThrows(IllegalArgumentException.class, () -> intermediate.indexes(1, -1, 3));
  }

  public void testScale_indexes_varargs_tooHigh() {
    Quantiles.Scale intermediate = Quantiles.scale(10);
    assertThrows(IllegalArgumentException.class, () -> intermediate.indexes(1, 11, 3));
  }

  public void testScale_indexes_collection_negative() {

   * intermediate. This is business as usual.
   *
   * ```
   *   pinnedRoot (trusted by CertificatePinner)
   *     -> pinnedIntermediate (trusted by CertificatePinner)
   *       -> realVictim
   * ```
   *
   * The attacker compromises a CA. They take the public key from an intermediate certificate

    void testExceptionChaining() {
        // Given
        Exception rootCause = new IllegalStateException("Root error");
        RuntimeCIFSException intermediateCause = new RuntimeCIFSException("Intermediate", rootCause);

        // When
        RuntimeCIFSException finalException = new RuntimeCIFSException("Final error", intermediateCause);

        // Then

 *
 * In this example the HTTP client already knows and trusts the last certificate, "Entrust Root
 * Certification Authority - G2". That certificate is used to verify the signature of the
 * intermediate certificate, "Entrust Certification Authority - L1M". The intermediate certificate
 * is used to verify the signature of the "www.squareup.com" certificate.
 *
 * This roles are reversed for client authentication. In that case the client has a private key and

   *
   * <p>This uses an efficient binary recursive algorithm to compute the factorial with balanced
   * multiplies. It also removes all the 2s from the intermediate products (shifting them back in at
   * the end).
   *
   * @throws IllegalArgumentException if {@code n < 0}
   */
  public static BigInteger factorial(int n) {
    checkNonNegative("n", n);