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),

        // Test attribute combinations
        int readOnlyHidden = SmbConstants.ATTR_READONLY | SmbConstants.ATTR_HIDDEN;
        assertEquals(0x03, readOnlyHidden);
    }

    @Test
    @DisplayName("Should validate access mask combinations")
    void testAccessMaskCombinations() {
        // Test common access combinations

        .isWithin(ALLOWED_ERROR)
        .of(MANY_VALUES_SUM_OF_PRODUCTS_OF_DELTAS / MANY_VALUES_COUNT);
    // For datasets of many double values, we test many combinations of finite and non-finite
    // x-values:
    for (ManyValues values : ALL_MANY_VALUES) {
      PairedStatsAccumulator accumulator =
          createFilledPairedStatsAccumulator(values.asIterable(), OTHER_MANY_VALUES);

        ace.flags = ACE.FLAGS_INHERITED | ACE.FLAGS_OBJECT_INHERIT;
        assertTrue(ace.isInherited());
    }

    @ParameterizedTest
    @DisplayName("Test getApplyToText with different flag combinations")
    @CsvSource({ "0x00, This folder only", "'0x03', 'This folder, subfolders and files'", "0x0B, Subfolders and files only",

      "SETTINGS",
      "PUSH_PROMISE",
      "PING",
      "GOAWAY",
      "WINDOW_UPDATE",
      "CONTINUATION",
    )

  /**
   * Lookup table for valid flags for DATA, HEADERS, CONTINUATION. Invalid combinations are
   * represented in binary.
   */
  private val FLAGS = arrayOfNulls<String>(0x40) // Highest bit flag is 0x20.
  private val BINARY =
    Array(256) {

        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);

        assertEquals(disconnected, transport.isDisconnected());
        verify(transport, times(1)).isDisconnected();
    }

    // Happy path + edge: disconnect with all flag combinations
    @ParameterizedTest
    @DisplayName("disconnect returns expected for flag combinations")
    @CsvSource({
            // hard, inuse, expected
            "true,true,false", "true,false,true", "false,true,true", "false,false,false" })

    assertThat(manyValuesAccumulatorByAddAllStatsAccumulator.mean())
        .isWithin(ALLOWED_ERROR)
        .of(MANY_VALUES_MEAN);
    // For datasets of many double values created from an iterable, we test many combinations of
    // finite and non-finite values:
    for (ManyValues values : ALL_MANY_VALUES) {
      StatsAccumulator accumulator = new StatsAccumulator();
      StatsAccumulator accumulatorByAddAllStats = new StatsAccumulator();

        assertEquals(Smb2LeaseState.SMB2_LEASE_FULL, fullLease);
    }

    @Test
    @DisplayName("Should handle custom state combinations")
    void testCustomStateCombinations() {
        int customState = 0x06; // Write + Handle but no Read

        assertFalse(Smb2LeaseState.hasReadCaching(customState));

                    Arguments.of("\\\\server.domain.com", 0));
        }

        @ParameterizedTest
        @MethodSource("provideParameters")
        @DisplayName("should accept various parameter combinations")
        void testConstructorSucceeds(String systemName, int accessMask) {
            // Arrange
            SamrPolicyHandle ph = createMockPolicyHandle();

            // Act & Assert - constructor should not throw