func (w *slowClientStream) RecvMsg(m any) error {
	if w.recv > 0 {
		sleep.UntilContext(w.Context(), w.recv)
		log.Infof("delayed recv for %v", w.recv)
	}
	return w.ClientStream.RecvMsg(m)
}

func (w *slowClientStream) SendMsg(m any) error {
	if w.send > 0 {
		sleep.UntilContext(w.Context(), w.send)
		log.Infof("delayed send for %v", w.send)
	}
	return w.ClientStream.SendMsg(m)
}

	example.com/version v1.0.0 => example.com/version v1.0.1
)
-- out.txt --
path is example.com/printversion
main is example.com/printversion v0.1.0
	(replaced by example.com/printversion v1.0.0)
using example.com/version v1.0.0

    }

    // Test that 0xFFFE and 0xFFFF are replaced with 0xFFFD
    assertEscaping(xmlEscaper, "\uFFFD", '\uFFFE');
    assertEscaping(xmlEscaper, "\uFFFD", '\uFFFF');

    assertEquals(
        "0xFFFE is forbidden and should be replaced during escaping",
        "[\uFFFD]",
        xmlEscaper.escape("[\ufffe]"));
    assertEquals(
        "0xFFFF is forbidden and should be replaced during escaping",
        "[\uFFFD]",

    /**
     * Moderate trust - it was deployed directly from a partner.
     */
    public static final ArtifactStatus PARTNER = new ArtifactStatus("partner", 3);

    /**
     * Moderate trust - it was deployed directly by a user.
     */
    public static final ArtifactStatus DEPLOYED = new ArtifactStatus("deployed", 4);

    /**
     * Trusted, as it has had its data verified by hand.

	if r := info.Main.Replace; r != nil {
		fmt.Fprintf(os.Stdout, "\t(replaced by %s %s)\n", r.Path, r.Version)
	}
	for _, m := range info.Deps {
		fmt.Fprintf(os.Stdout, "using %s %s\n", m.Path, m.Version)
		if r := m.Replace; r != nil {
			fmt.Fprintf(os.Stdout, "\t(replaced by %s %s)\n", r.Path, r.Version)
		}
	}

        given:
        sourceFile << """
            #define HEADER_NAME "hello.h"
            #define _NAME do not use this
            #define HEADER HEADER ## _NAME // replaced with HEADER_NAME then "hello.h"
            #include HEADER
        """

        expect:
        resolve() == [header]
    }

	ns := NamingStrategy{
		TablePrefix:   "public.",
		SingularTable: true,
		NameReplacer: CustomReplacer{
			func(name string) string {
				replaced := "REPLACED_" + strings.ToUpper(name)
				return strings.NewReplacer("CID", "_Cid").Replace(replaced)
			},
		},
		NoLowerCase: false,
	}

	idxName := ns.IndexName("public.table", "name")
	if idxName != "idx_public_table_replaced_name" {

            if (version.isSelected()) {
                version.makeSelectable();
            }
        }

        selected = null;
        replaced = false;
    }

    /**
     * Overrides the component selection for this module, when this module has been replaced by another.
     */
    @Override
    public void replaceWith(ComponentState selected) {
        if (this.selected != null) {

  name: mock
  labels:
    app: mock
    status: replaced
spec:
  ports:
  - port: 99
    protocol: TCP
    targetPort: 9949
  selector:
    app: mock
---
apiVersion: v1
kind: ReplicationController
metadata:
  name: mock
spec:
  replicas: 1
  selector:
    app: mock
  template:
    metadata:
      labels:
        app: mock
        status: replaced
    spec:
      containers:

   "apiVersion":"v1",
   "items":[
      {
        "kind":"Service",
        "apiVersion":"v1",
        "metadata":{
          "name":"mock",
          "labels":{
            "app":"mock",
            "status":"replaced"
          }
        },
        "spec":{
          "ports": [{
            "protocol": "TCP",
            "port": 99,
            "targetPort": 9949
          }],
          "selector":{