},
					},
				},
			},
			wantErr: nil,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if _, wanted2 := NewAnalyzer(tt.input); wanted2 != nil {
				t.Errorf("Wanted %v, got %v", tt.wantErr, wanted2)
			}
		})
	}
}

func TestPrint(t *testing.T) {
	a := &Analyzer{
		listenerDump: &envoy_admin.ListenersConfigDump{

			},
			existingTaints: []v1.Taint{kubeadmconstants.ControlPlaneTaint},
			newTaints:      []v1.Taint{kubeadmconstants.ControlPlaneTaint},
			expectedPatch:  `{}`,
		},
		{
			name: "has taint and no new taints wanted",
			existingLabels: []string{
				kubeadmconstants.LabelNodeRoleControlPlane,
				kubeadmconstants.LabelExcludeFromExternalLB,
			},
			existingTaints: []v1.Taint{
				{

			zb0002, err = dc.ReadArrayHeader()
			if err != nil {
				err = msgp.WrapError(err, "ObjSizes")
				return
			}
			if zb0002 != uint32(dataUsageBucketLen) {
				err = msgp.ArrayError{Wanted: uint32(dataUsageBucketLen), Got: zb0002}
				return
			}
			for za0001 := range z.ObjSizes {
				z.ObjSizes[za0001], err = dc.ReadUint64()
				if err != nil {

	if nf != 0 {
		t.Errorf("dec.NumFuncs(): got %d want %d", nf, 0)
	}
	pp := dec.PackagePath()
	if pp != p {
		t.Errorf("dec.PackagePath(): got %s want %s", pp, p)
	}
	ppn := dec.PackageName()
	if ppn != pn {
		t.Errorf("dec.PackageName(): got %s want %s", ppn, pn)
	}
	pmp := dec.ModulePath()
	if pmp != mp {
		t.Errorf("dec.ModulePath(): got %s want %s", pmp, mp)
	}
}

	log.SetPrefix("emitToUnwritableDir: ")

	want := "permission denied"

	if err := coverage.WriteMetaDir(*outdirflag); err == nil {
		log.Fatal("expected error from WriteMetaDir to unwritable dir")
	} else {
		got := fmt.Sprintf("%v", err)
		if !strings.Contains(got, want) {
			log.Fatalf("meta-data emit to unwritable dir: wanted error containing %q got %q", want, got)
		}
	}

			current:       nil,
		},
		{
			name:           "priority level configuration not wanted, auto update is enabled",
			bootstrapName:  "pl0",
			current:        newPLConfiguration("pl1").WithAutoUpdateAnnotation("true").Object(),
			removeExpected: true,
		},
		{
			name:           "priority level configuration not wanted, auto update is disabled",
			bootstrapName:  "pl0",

			cd, _ := os.ReadFile(tt.inputFile)
			err := cw.Prime(cd)
			if cw.configDump == nil {
				if tt.wantConfigs != 0 {
					t.Errorf("wanted some configs loaded but config dump was nil")
				}
			} else if len(cw.configDump.Configs) != tt.wantConfigs {
				t.Errorf("wanted %v configs loaded in got %v", tt.wantConfigs, len(cw.configDump.Configs))
			}
			if tt.wantErr {
				assert.Error(t, err)
			} else {

func CompareTrace(t framework.TestContext, got, want zipkin.Span) bool {
	t.Helper()
	if got.Name != want.Name || got.ServiceName != want.ServiceName {
		t.Logf("got span %+v, want span %+v", got, want)
		return false
	}
	if len(got.ChildSpans) < len(want.ChildSpans) {
		t.Logf("got %d child spans from, want %d child spans, maybe trace has not be fully reported",
			len(got.ChildSpans), len(want.ChildSpans))
		return false

			}
		}

		// Check logs.
		if len(want.logs) != len(summary.Logs) {
			t.Errorf("wanted %d logs for task %d, got %d logs instead", len(want.logs), id, len(summary.Logs))
		} else {
			for i := range want.logs {
				if want.logs[i] != summary.Logs[i].Log() {
					t.Errorf("log mismatch: want %#v, got %#v", want.logs[i], summary.Logs[i].Log())
				}
			}
		}

		// Check goroutines.

	certData, err := requestNodeCertificate(context.TODO(), newClientset(fakeClient{}), []byte{}, "fake-node-name")
	if err == nil {
		t.Errorf("Got no error, wanted error an error because there was an empty private key passed in.")
	}
	if certData != nil {
		t.Errorf("Got cert data, wanted nothing as there should have been an error.")
	}
}

func TestRequestNodeCertificateErrorCreatingCSR(t *testing.T) {