expectedErr:    errRestoreHDRMalformed,
		},
	}
	for i, tc := range testCases {
		actual, err := parseRestoreObjStatus(tc.restoreHdr)
		if err != tc.expectedErr {
			t.Fatalf("Test %d: got %v expected %v", i+1, err, tc.expectedErr)
		}
		if actual != tc.expectedStatus {
			t.Fatalf("Test %d: got %v expected %v", i+1, actual, tc.expectedStatus)
		}
	}
}

     * 
     * @param tc
     * @param userInfo
     */
    public NtlmPasswordAuthentication ( CIFSContext tc, String userInfo ) {
        super(
            userInfo,
            tc.getConfig().getDefaultDomain(),
            tc.getConfig().getDefaultUsername() != null ? tc.getConfig().getDefaultUsername() : "GUEST",
            tc.getConfig().getDefaultPassword() != null ? tc.getConfig().getDefaultPassword() : "");

		{"abcd", "ab", false, "cd", true},
		{"abcd", "ab", true, "cd", true},
		{"abcd", "bc", false, "", false},
		{"abcd", "bc", true, "d", true},
	}

	for i, tc := range matcherCases {
		res, ok := matcher(tc.iText, tc.iPat, tc.iHasLeadingPercent)
		if res != tc.resultExpected || ok != tc.matchExpected {
			t.Errorf("Matcher Case %d failed", i)
		}
	}

	evalCases := []struct {
		iText, iPat   string
		iEsc          rune

     * environment.
     * 
     * @param tc
     *            context to use
     */
    public Type3Message ( CIFSContext tc ) {
        setFlags(getDefaultFlags(tc));
        setDomain(tc.getConfig().getDefaultDomain());
        setUser(tc.getConfig().getDefaultUsername());
        setWorkstation(tc.getNameServiceClient().getLocalHost().getHostName());
    }


    /**

			actualFlag := checkPreconditions(context.Background(), recorder, request, tc.objInfo, ObjectOptions{})
			if tc.expectedFlag != actualFlag {
				t.Errorf("test: %s, got flag: %v, want: %v", tc.name, actualFlag, tc.expectedFlag)
			}
			if tc.expectedCode != recorder.Code {
				t.Errorf("test: %s, got code: %d, want: %d", tc.name, recorder.Code, tc.expectedCode)
			}
		})
	}
	testCases = []struct {

			skipConfirmation: false,
			error:            "",
		},
	}

	for _, tc := range tcs {
		t.Run(tc.name, func(t *testing.T) {
			var out bytes.Buffer
			client := fake.NewClientset(tc.webhooksBefore.DeepCopyObject(), tc.namespaces.DeepCopyObject())
			err := removeTag(context.Background(), client, tc.tag, tc.skipConfirmation, &out)
			if tc.error == "" && err != nil {
				t.Fatalf("expected no error, got %v", err)
			}

		},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			t.Logf("%s: Test preconf %s, expected %s", tc.name, tc.preConfFile, tc.expectedOutputFile)
			install.RunInstallCNITest(t, tc.chainedCNIPlugin, tc.preConfFile, tc.resultFileName, tc.delayedConfFile, tc.expectedOutputFile,
				tc.expectedPostCleanFile, tc.cniConfDirOrderedFiles)
		})
	}

     * environment.
     * 
     * @param tc
     *            context to use
     */
    public Type2Message ( CIFSContext tc ) {
        this(tc, getDefaultFlags(tc), null, null);
    }


    /**
     * Creates a Type-2 message in response to the given Type-1 message
     * using default values from the current environment.
     * 
     * @param tc
     *            context to use
     * @param type1

     * throw on a regular basis here.
     * 
     * @param host
     * @param tc
     * @return resolved name, null if not found
     */
    public synchronized NbtAddress getByName ( String host, CIFSContext tc ) {
        return getByName(new Name(tc.getConfig(), host, 0x20, null), tc);
    }


    synchronized NbtAddress getByName ( Name name, CIFSContext tc ) {
        NbtAddress result = null;

        try {

    /**
     * Get transport connection
     * 
     * @param tc
     *            context to use
     * @param address
     * @param port
     * @param exclusive
     *            whether to acquire an unshared connection
     * @return a transport connection to the target
     */
    SmbTransport getSmbTransport ( CIFSContext tc, Address address, int port, boolean exclusive );


    /**