}.build()

    executeSynchronously(request)
      .assertBody("body")

    assertThat(client.routeDatabase.failedRoutes).isEmpty()
    // TODO check if we expect a second request to server1, before attempting server2
    assertThat(server1.requestCount).isEqualTo(2)
    assertThat(server2.requestCount).isEqualTo(1)

    assertThat(clientTestRule.recordedConnectionEventTypes()).containsExactly(

	"github.com/minio/minio/internal/logger"
	"github.com/minio/minio/internal/once"
	"github.com/minio/minio/internal/store"
	xnet "github.com/minio/pkg/v3/net"
)

const (
	reconnectInterval = 5 * time.Second
	storePrefix       = "minio"
)

// MQTT input constants
const (
	MqttBroker            = "broker"
	MqttTopic             = "topic"
	MqttQoS               = "qos"
	MqttUsername          = "username"

		if err := e.EncodeElement(d.StorageClass, xml.StartElement{Name: xml.Name{Local: "StorageClass"}}); err != nil {
			return err
		}
	}
	return e.EncodeToken(xml.EndElement{Name: start.Name})
}

// UnmarshalXML - decodes XML data.
func (d *Destination) UnmarshalXML(dec *xml.Decoder, start xml.StartElement) (err error) {
	// Make subtype to avoid recursive UnmarshalXML().
	type destination Destination
	dest := destination{}

crawler.ignore.robots.tags=false
# Whether to ignore content exceptions during crawling.
crawler.ignore.content.exception=true
# HTTP status codes considered as failure URLs.
crawler.failure.url.status.codes=404
# Interval (seconds) for system monitor during crawling.
crawler.system.monitor.interval=60
# Whether to ignore idle threads in hot thread monitoring.
crawler.hotthread.ignore_idle_threads=true
# Interval for hot thread monitoring (e.g., 500ms).

        this.scope = scope;
        this.createTime = System.currentTimeMillis();
        this.lastUpdateTime = createTime;
        this.lastAccessTime = createTime;
        this.maxAge = 30000; // 30 seconds default

        this.children = new ConcurrentHashMap<>();
        this.lock = new ReentrantReadWriteLock();
        this.isComplete = false;
        this.hasChanges = false;
    }

    /**

  STATUS=$? ;
  until [ $STATUS = 0 ]
  do
    ATTEMPTS=`expr $ATTEMPTS + 1` ;
    echo \"Failed attempts: $ATTEMPTS\" ;
    if [ $ATTEMPTS -gt $LIMIT ]; then
      exit 1 ;
    fi ;
    sleep 2 ; # 1 second intervals between attempts
    $MC_COMMAND ;
    STATUS=$? ;
  done ;
  set -e ; # reset `e` as active
  return 0
}

# checkUserExists ()

func (t *apiConfig) init(cfg api.Config, setDriveCounts []int, legacy bool) {
	t.mu.Lock()
	defer t.mu.Unlock()

	clusterDeadline := cfg.ClusterDeadline
	if clusterDeadline == 0 {
		clusterDeadline = 10 * time.Second
	}
	t.clusterDeadline = clusterDeadline
	corsAllowOrigin := cfg.CorsAllowOrigin
	if len(corsAllowOrigin) == 0 {
		corsAllowOrigin = []string{"*"}
	}
	t.corsAllowOrigins = corsAllowOrigin

     *
     * @return the security identifier of the owner user
     */
    public final SID getOwnerUserSid() {
        return this.ownerUserSid;
    }

    /**
     * Decodes a security descriptor from a byte buffer.
     *
     * @param buffer the byte buffer containing the security descriptor data
     * @param bufferIndex the starting offset in the buffer

        // Create first index with alias
        client.admin().indices().prepareCreate(index1).addAlias(new Alias(aliasName)).execute().actionGet();

        // Create second index and add to same alias
        client.admin().indices().prepareCreate(index2).execute().actionGet();
        client.admin().indices().prepareAliases().addAlias(index2, aliasName).execute().actionGet();

        assertDoesNotThrow(() -> outputStream.write(data, 0, 10)); // valid - will consume first mock (10)
        assertDoesNotThrow(() -> outputStream.write(data, 5, 5)); // valid - will consume second mock (5)
    }

    @Test
    void testAppendMode() throws IOException, CIFSException {
        // Given
        when(mockTreeHandle.isSMB2()).thenReturn(true);