outAttach := output.Spec.AttachRequired
	if outAttach == nil {
		t.Errorf("Expected AttachRequired to be defaulted to: %+v, got: nil", defaultAttach)
	} else if *outAttach != defaultAttach {
		t.Errorf("Expected AttachRequired to be defaulted to: %+v, got: %+v", defaultAttach, outAttach)
	}
	outPodInfo := output.Spec.PodInfoOnMount
	if outPodInfo == nil {
		t.Errorf("Expected PodInfoOnMount to be defaulted to: %+v, got: nil", defaultPodInfo)

			expected: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			LocalIPAddrs = tt.lipas
			_, isV6, err := getLocalIP(tt.isDS)
			if err != nil {
				t.Errorf("getLocalIP err: %s", err)
			}
			if isV6 != tt.expected {
				t.Errorf("unexpected EnableIPv6 result, expected: %t got: %t", tt.expected, isV6)
			}
		})
	}

// by the expected CA
func AssertCertificateIsSignedByCa(t *testing.T, cert *x509.Certificate, signingCa *x509.Certificate) {
	if err := cert.CheckSignatureFrom(signingCa); err != nil {
		t.Error("cert is not signed by signing CA as expected")
	}
}

func (sr *statsResults) checkSimilarDistribution(expected *statsResults) error {
	if !nearEqual(sr.mean, expected.mean, expected.closeEnough, expected.maxError) {
		s := fmt.Sprintf("mean %v != %v (allowed error %v, %v)", sr.mean, expected.mean, expected.closeEnough, expected.maxError)
		fmt.Println(s)
		return errors.New(s)
	}
	if !nearEqual(sr.stddev, expected.stddev, expected.closeEnough, expected.maxError) {

		if test.err {
			if err == nil {
				t.Errorf("%v: expected error, got nil", test.name)
			}
			continue
		} else {
			if err != nil {
				t.Errorf("%v: expected no error, got %v", test.name, err)
				continue
			}
		}
		actual := sets.New[string](dirs...)
		if !test.expected.Equal(actual) {

		expected string
	}{
		{
			name:     "no certs",
			certs:    []string{},
			expected: "",
		},
		{
			name:     "single cert",
			certs:    []string{"a"},
			expected: "a",
		},
		{
			name:     "multiple certs",
			certs:    []string{"a", "b"},
			expected: "a\nb",
		},
		{
			name:     "existing newline",
			certs:    []string{"a\n", "b"},
			expected: "a\nb",
		},

			t.Errorf("Expected podTemplateSpec to have no hash label, got: %s", val)
		}
	}
}

func TestReplaceDaemonSetPodNodeNameNodeAffinity(t *testing.T) {
	tests := []struct {
		affinity *v1.Affinity
		hostname string
		expected *v1.Affinity
	}{
		{
			affinity: nil,
			hostname: "host_1",
			expected: &v1.Affinity{
				NodeAffinity: &v1.NodeAffinity{

		assert.NoError(t, err)
		assert.Equal(t, test.expected.CpuPeriod, linuxConfig.GetResources().CpuPeriod, test.name)
		assert.Equal(t, test.expected.CpuQuota, linuxConfig.GetResources().CpuQuota, test.name)
		assert.Equal(t, test.expected.CpuShares, linuxConfig.GetResources().CpuShares, test.name)
		assert.Equal(t, test.expected.MemoryLimitInBytes, linuxConfig.GetResources().MemoryLimitInBytes, test.name)
	}
}

    @Override
    void assertApiDependencies(String... expected) {
        features.each { feature ->
            assertDependencies(feature, 'apiElements', 'compile', [], expected)
            assert parsedModuleMetadata.variant('runtimeElements').dependencies*.coords.containsAll(expected)
        }
    }

    @Override
    void assertRuntimeDependencies(String... expected) {
        features.each { feature ->

			if len(tt.expected) != len(nodes) {
				t.Errorf("number of nodes is not the same as expected. exptectd: %d, got: %d. Nodes: %v", len(tt.expected), len(nodes), nodes)
			}
			for _, node := range nodes {
				name := node.Node().Name
				if _, found := tt.expected[name]; !found {
					t.Errorf("node %v is not expected.", name)
				}
			}
		})
	}
}