return createCacheBuilder(
                (Integer) combination.get(0),
                (Integer) combination.get(1),
                (Integer) combination.get(2),
                (DurationSpec) combination.get(3),
                (DurationSpec) combination.get(4),
                (DurationSpec) combination.get(5),
                (Strength) combination.get(6),

        valve.setShowServerInfo(true);
        assertTrue(valve.isShowServerInfo());
    }

    public void test_settingsBothTrueAndFalse() {
        // Test all combinations of settings
        valve.setShowReport(true);
        valve.setShowServerInfo(true);
        assertTrue(valve.isShowReport());
        assertTrue(valve.isShowServerInfo());

        valve.setShowReport(true);

   * memory but only for as long as the user retains a reference to it. That is, the set returned by
   * {@code combinations} does not retain the individual subsets.
   *
   * @param set the set of elements to take combinations of
   * @param size the number of elements per combination
   * @return the set of all combinations of {@code size} elements from {@code set}

    if (!parentBuilder.getFeatures().contains(NoRecurse.DESCENDING)) {
      derivedSuites.add(createDescendingSuite(parentBuilder));
    }

    if (!parentBuilder.getFeatures().contains(NoRecurse.SUBMAP)) {
      // Other combinations are inherited from SortedMapTestSuiteBuilder.
      derivedSuites.add(createSubmapSuite(parentBuilder, Bound.NO_BOUND, Bound.INCLUSIVE));
      derivedSuites.add(createSubmapSuite(parentBuilder, Bound.EXCLUSIVE, Bound.NO_BOUND));

            throw new AssertionError();
          }
        };
    assertThrows(IllegalStateException.class, iter::hasNext);
  }

  // Technically we should test other reentrant scenarios (9 combinations of
  // hasNext/next/peek), but we'll cop out for now, knowing that peek() and
  // next() both start by invoking hasNext() anyway.

        PrunedTag anotherTagWithNulls = new PrunedTag("div");
        assertTrue(tagWithNulls.equals(anotherTagWithNulls));
    }

    public void test_parse_complexCombinations() {
        // Test complex parsing combinations
        PrunedTag[] tags = PrunedTag.parse("div[data-toggle=modal].modal#main-modal");
        assertEquals(1, tags.length);
        PrunedTag tag = tags[0];

    }

    // Test register method with case insensitive name
    public void test_register_caseInsensitive() {
        testScriptEngine.register();

        // Test various case combinations
        ScriptEngine lowerCase = scriptEngineFactory.getScriptEngine("testengine");
        ScriptEngine upperCase = scriptEngineFactory.getScriptEngine("TESTENGINE");

import java.lang.ref.WeakReference;
import junit.framework.TestCase;
import org.jspecify.annotations.NullUnmarked;

/**
 * Tests of basic {@link LoadingCache} operations with all possible combinations of key & value
 * strengths.
 *
 * @author mike nonemacher
 */
@NullUnmarked
public class CacheReferencesTest extends TestCase {

  private static final CacheLoader<Key, String> KEY_TO_STRING_LOADER =

        System.setProperty("java.version", "1.8.0_301");
        assertEquals(8, JvmUtil.getJavaVersion());
    }

    public void test_getJavaVersion_variousFormats() {
        // Test different separator combinations
        System.setProperty("java.version", "11.0.15.1");
        assertEquals(11, JvmUtil.getJavaVersion());

        System.setProperty("java.version", "17_0_2");
        assertEquals(17, JvmUtil.getJavaVersion());

    double actualReportedFpp = bf.expectedFpp();
    assertThat(actualReportedFpp).isWithin(0.00033).of(expectedReportedFpp);
  }

  /** Sanity checking with many combinations of false positive rates and expected insertions */
  public void testBasic() {
    for (double fpr = 0.0000001; fpr < 0.1; fpr *= 10) {