mockCadvisor := cadvisortest.NewMockInterface(mockCtrl)
	rootfs := cadvisorapiv2.FsInfo{
		Capacity: 8000,
	}
	mockCadvisor.EXPECT().RootFsInfo().Return(rootfs, nil)
	mockCadvisorError := cadvisortest.NewMockInterface(mockCtrlError)
	mockCadvisorError.EXPECT().RootFsInfo().Return(cadvisorapiv2.FsInfo{}, errors.New("Unable to get rootfs data from cAdvisor interface"))
	cases := []struct {

 */
package org.codelibs.fess.util;

import java.util.Collections;
import java.util.Locale;
import java.util.Map;

import org.codelibs.fess.entity.FacetInfo;
import org.codelibs.fess.entity.GeoInfo;
import org.codelibs.fess.entity.HighlightInfo;
import org.codelibs.fess.entity.SearchRequestParams;
import org.codelibs.fess.unit.UnitFessTestCase;

public class QueryStringBuilderTest extends UnitFessTestCase {

*/

package fs

import (
	"fmt"
)

type UsageInfo struct {
	Bytes  int64
	Inodes int64
}

// Info unsupported returns 0 values for available and capacity and an error.
func Info(path string) (int64, int64, int64, int64, int64, int64, error) {
	return 0, 0, 0, 0, 0, 0, fmt.Errorf("fsinfo not supported for this build")
}

// DiskUsage gets disk usage of specified path.
func DiskUsage(path string) (UsageInfo, error) {

	tests := []struct {
		name                string
		podEtcHostsPathFunc PodEtcHostsPathFunc
		podUID              types.UID
		rootFsInfo          *cadvisorapiv2.FsInfo
		want                *statsapi.FsStats
		wantErr             bool
	}{
		{
			name: "Should return nil for runtimes that do not support etc host file",
			podEtcHostsPathFunc: func(podUID types.UID) string {
				return ""
			},
			podUID:     "fake0001",

                append("<dispatch receiver>: ${dispatchReceiverType.render()}")
                if (valueParameters.isNotEmpty()) append(", ")
            }
            valueParameters.joinTo(this) { stringRepresentation(it) }
            append(")")
            append(": ${returnType.render()}")
        }
        is KaValueParameterSymbol -> "${if (isVararg) "vararg " else ""}$name: ${returnType.render()}"

	cadvisor.EXPECT().MachineInfo().Return(&cadvisorapi.MachineInfo{}, nil).AnyTimes()
	cadvisor.EXPECT().ImagesFsInfo().Return(cadvisorapiv2.FsInfo{
		Usage:     400,
		Capacity:  1000,
		Available: 600,
	}, nil).AnyTimes()
	cadvisor.EXPECT().RootFsInfo().Return(cadvisorapiv2.FsInfo{
		Usage:    9,
		Capacity: 10,
	}, nil).AnyTimes()
	fakeSecretManager := secret.NewFakeManager()

        public SearchConditionBuilder size(final int size) {
            this.size = size;
            return this;
        }

        public SearchConditionBuilder geoInfo(final GeoInfo geoInfo) {
            this.geoInfo = geoInfo;
            return this;
        }

        public SearchConditionBuilder highlightInfo(final HighlightInfo highlightInfo) {
            this.highlightInfo = highlightInfo;

	istiod  map[string]istiokube.PortForwarder
	values  OperatorValues
	workDir string
	iopFiles
}

type iopInfo struct {
	file string
	spec *opAPI.IstioOperatorSpec
}

type iopFiles struct {
	primaryIOP  iopInfo
	configIOP   iopInfo
	remoteIOP   iopInfo
	gatewayIOP  iopInfo
	eastwestIOP iopInfo
}

// ID implements resource.Instance
func (i *istioImpl) ID() resource.ID {
	return i.id
}

	goTool, err := testenv.GoTool()
	if err != nil {
		t.Fatalf("testenv.GoTool(): %v", err)
	}
	t.Logf("testenv.GoTool() = %q", goTool)

	gotInfo, err := os.Stat(goTool)
	if err != nil {
		t.Fatal(err)
	}
	if !os.SameFile(wantInfo, gotInfo) {
		t.Fatalf("%q is not the same file as %q", absWant, goTool)
	}
}

func TestHasGoBuild(t *testing.T) {
	if !testenv.HasGoBuild() {
		switch runtime.GOOS {

}

// NewFsInfoFailedError creates a new MetricsError with code FsInfoFailed.
func NewFsInfoFailedError(err error) *MetricsError {
	return &MetricsError{
		Code: ErrCodeFsInfoFailed,
		Msg:  fmt.Sprintf("failed to get FsInfo due to error %v", err),
	}
}

// MetricsError to distinguish different Metrics Errors.
type MetricsError struct {
	Code int
	Msg  string
}

func (e *MetricsError) Error() string {
	return e.Msg
}