*/

package flexvolume

import (
	"testing"
)

func TestHandleResponseDefaults(t *testing.T) {
	ds, err := handleCmdResponse("test", []byte(`{"status": "Success"}`))
	if err != nil {
		t.Error("error: ", err)
	}

	if *ds.Capabilities != *defaultCapabilities() {
		t.Error("wrong default capabilities: ", *ds.Capabilities)
	}

		svc := svci.(*service)
		ds := debugService{svc, snamei.(string), make([]debugMethod, 0, len(svc.method))}
		for mname, method := range svc.method {
			ds.Method = append(ds.Method, debugMethod{method, mname})
		}
		slices.SortFunc(ds.Method, func(a, b debugMethod) int {
			return strings.Compare(a.Name, b.Name)
		})
		services = append(services, ds)
		return true
	})

func AllowsSurge(ds *apps.DaemonSet) bool {
	maxSurge, err := SurgeCount(ds, 1)
	return err == nil && maxSurge > 0
}

// SurgeCount returns 0 if surge is not requested, the expected surge number to allow
// out of numberToSchedule if surge is configured, or an error if the surge percentage
// requested is invalid.
func SurgeCount(ds *apps.DaemonSet, numberToSchedule int) (int, error) {

            try {
                ss.setReuseAddress(true)
            } finally {
                ss.close()
            }
            DatagramSocket ds = new DatagramSocket(port)
            try {
                ds.setReuseAddress(true)
            } finally {
                ds.close()
            }
            return true
        } catch (IOException e) {
            return false
        }
    }

			ds = s
			break
		}
	}

	// didn't find a section, so no import libraries were found
	if ds == nil {
		return nil, nil
	}

	d, err := ds.Data()
	if err != nil {
		return nil, err
	}

	// seek to the virtual address specified in the import data directory
	d = d[idd.VirtualAddress-ds.VirtualAddress:]

	// start decoding the import directory

<!DOCTYPE components PUBLIC "-//DBFLUTE//DTD LastaDi 1.0//EN"
	"http://dbflute.org/meta/lastadi10.dtd">
<components>
	<component name="dataStoreFactory" class="org.codelibs.fess.ds.DataStoreFactory">
	</component>
	<component name="indexUpdateCallback" class="org.codelibs.fess.ds.callback.IndexUpdateCallbackImpl" instance="prototype">
	</component>

	//  - 1 IP gateway for network1
	//  - 1 DNS gateway for network2
	//  - 1 IP gateway for network3
	//  - 0 gateways for network4
	ds := environment(t)
	origServices := ds.Env().Services()
	origGateways := ds.Env().NetworkGateways()
	ds.MemRegistry.AddService(&model.Service{
		Hostname: "istio-ingressgateway.istio-system.svc.cluster.local",
		Attributes: model.ServiceAttributes{

		is string
		u  string
		f  string
		bn string
		s  string
		x  string
		ds string
		p  = &is
		d  time.Duration
	)
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		is = Int64("key", 1).String()
		u = Uint64("key", 1).String()
		f = Float64("key", 1).String()
		bn = Bool("key", true).String()
		s = String("key", "foo").String()
		ds = Duration("key", d).String()
		x = Any("key", p).String()
	}
	_ = u
	_ = f

                    return ds.getRuleDescriptors();
                }

                @Override
                public boolean isUpdated() {
                    return ds.isUpdated();
                }

                @Override
                public ArtifactSelectionDetailsInternal getArtifactSelectionDetails() {
                    return ds.getArtifactSelectionDetails();
                }

        }
        DiagnosticCollector<JavaFileObject> ds = new DiagnosticCollector<>();
        try (StandardJavaFileManager mgr = compiler.getStandardFileManager(ds, null, null)) {
            List<String> options = buildOptions(dstDir, classPath);
            List<File> filesToCompile = outputSourceFilesToSourceDir(srcDir, classes);