}

        @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 {

     */
    boolean isResolveHashes();

    /**
     * Check if this referral needs to be resolved further
     *
     * @return whether this refrral needs to be resolved further
     */
    boolean isIntermediate();

    /**
     * Combine this referral with another to form a chain
     *
     * @param next the referral to combine with
     * @return new referral, combining a chain of referrals
     */

    }

    /**
     * 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

        .Builder()
        .certificateAuthority(1)
        .build()
    val intermediate =
      HeldCertificate
        .Builder()
        .certificateAuthority(0)
        .signedBy(root)
        .build()
    val certificate =
      HeldCertificate
        .Builder()
        .signedBy(intermediate)
        .build()
    val handshakeCertificates =
      HandshakeCertificates

 *    certificate and its private key). The certificate's subject alternative names must match the
 *    server's hostname. The server must also have is a (possibly-empty) chain of intermediate
 *    certificates to establish trust from a root certificate to the server's certificate. The root
 *    certificate is not included in this chain.