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

    if (parentBuilder.getFeatures().contains(SERIALIZABLE)) {
      derivedSuites.add(createReserializedSuite(parentBuilder));
    }

    if (!parentBuilder.getFeatures().contains(NoRecurse.SUBMULTISET)) {

        return System.getProperty("os.name").toLowerCase(Locale.ROOT).contains("windows");
    }

    private static boolean isMacOS() {
        return System.getProperty("os.name").toLowerCase(Locale.ROOT).contains("mac");
    }

    private static boolean isAlpine() {
        return System.getProperty("java.vm.vendor").toLowerCase(Locale.ROOT).contains("alpine");
    }

    private static class ExecResult {

        target.close();
        CIFSException e1 = assertThrows(SmbException.class, target::getInput);
        assertTrue(e1.getMessage().contains("Already closed"));
        CIFSException e2 = assertThrows(SmbException.class, target::getOutput);
        assertTrue(e2.getMessage().contains("Already closed"));
    }

    @Test
    @DisplayName("ensureOpen throws after close() is called")

            circuitBreaker.executeWithCircuitBreaker(() -> "should not execute");
        }, "Circuit breaker should throw CIFSException when open");

        assertTrue(exception.getMessage().contains("Circuit breaker 'test' is open"), "Exception message should indicate circuit is open");
    }

    @Test
    public void testCircuitResetsAfterTimeout() throws Exception {
        // Open the circuit

//go:generate stringer -type=TargetType -trimprefix=Target $GOFILE

// Constants for target types
const (
	_ TargetType = iota
	TargetConsole
	TargetHTTP
	TargetKafka
)

// TargetStats contains statistics for a target.
type TargetStats struct {
	// QueueLength is the queue length if any messages are queued.
	QueueLength int

	// TotalMessages is the total number of messages sent in the lifetime of the target

        List<MetadataGraphEdge> exList = excidentEdges.computeIfAbsent(vFrom, k -> new ArrayList<>());

        if (!exList.contains(e)) {
            exList.add(e);
        }

        List<MetadataGraphEdge> inList = incidentEdges.computeIfAbsent(vTo, k -> new ArrayList<>());

        if (!inList.contains(e)) {
            inList.add(e);
        }

        return this;
    }

            smbComTreeDisconnect = new SmbComTreeDisconnect(null);
        });

        // Verify the exception message indicates the config is null
        assertTrue(exception.getMessage().contains("config"));
    }

    /**
     * Test constructor with mock configuration
     */
    @Test
    @DisplayName("Test constructor with mock configuration")
    public void testConstructorWithMockConfig() {

            // Note: There's a typo in the original code - "Opblock" instead of "Oplock"
            assertTrue(result.startsWith("Smb2OpblockBreakNotification["));
            assertTrue(result.contains("oplockLevel=" + oplockLevel));
            assertTrue(result.contains("fileId=" + Hexdump.toHexString(fileId)));
            assertTrue(result.endsWith("]"));
        }

        @Test
        @DisplayName("Should handle null fileId in toString")

    return Collections.unmodifiableMap(map);
  }

  /** Returns true if this map contains a mapping for the specified key. */
  public boolean containsKey(Object key) {
    return map.containsKey(key);
  }

  /**
   * Returns the number of key-value mappings in this map. If the map contains more than {@code
   * Integer.MAX_VALUE} elements, returns {@code Integer.MAX_VALUE}.
   */
  public int size() {

            throw new IllegalArgumentException(msg);
        }
    }

    protected String toRangeDateString(Date date, String format) {
        if (format.contains("epoch_millis")) {
            return Long.toString(date.getTime());
        } else if (format.contains("date_optional_time")) {
            final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
            sdf.setTimeZone(TimeZone.getTimeZone("UTC"));