if r == nil {
		return nil
	}
	r.Lock()
	defer r.Unlock()
	r.tags = append(r.tags, KeyVal{key, val})
	return r
}

// SetTags - sets key/val to ReqInfo.tags
func (r *ReqInfo) SetTags(key string, val interface{}) *ReqInfo {
	if r == nil {
		return nil
	}
	r.Lock()
	defer r.Unlock()
	// Search of tag key already exists in tags
	var updated bool

	}

	if err := validateProfileOutputFormatFlag(pdArgs.outputFormat); err != nil {
		return err
	}

	setFlags := applyFlagAliases(make([]string, 0), pdArgs.manifestsPath, "")
	if len(args) == 1 {
		setFlags = append(setFlags, "profile="+args[0])
	}

	y, _, err := manifest.GenerateConfig(pdArgs.inFilenames, setFlags, true, nil, l)
	if err != nil {
		return err
	}
	y, err = tpath.GetConfigSubtree(y, "spec")

	l := clog.NewConsoleLogger(cmd.OutOrStdout(), cmd.OutOrStderr(), nil)
	setFlags := make([]string, 0)
	if pfArgs.manifestsPath != "" {
		setFlags = append(setFlags, fmt.Sprintf("installPackagePath=%s", pfArgs.manifestsPath))
	}
	return profileDiffInternal(args[0], args[1], setFlags, cmd.OutOrStdout(), l)
}

func profileDiffInternal(profileA, profileB string, setFlags []string, writer io.Writer, l clog.Logger) (bool, error) {

     */
    public int getFlags() {
        return flags;
    }

    /**
     * Sets the flags for this message.
     *
     * @param flags The flags for this message.
     */
    public void setFlags(int flags) {
        this.flags = flags;
    }

    /**
     * Returns the status of the specified flag.
     *
     * @param flag The flag to test (i.e., <code>NTLMSSP_NEGOTIATE_OEM</code>).

        return this.flags;
    }


    /**
     * Sets the flags for this message.
     *
     * @param flags
     *            The flags for this message.
     */
    public void setFlags ( int flags ) {
        this.flags = flags;
    }


    /**
     * Returns the status of the specified flag.
     *
     * @param flag

     * @param suppliedWorkstation
     *            The supplied workstation name.
     */
    public Type1Message ( CIFSContext tc, int flags, String suppliedDomain, String suppliedWorkstation ) {
        setFlags(getDefaultFlags(tc) | flags);
        setSuppliedDomain(suppliedDomain);
        setSuppliedWorkstation(suppliedWorkstation);
    }


    /**
     * Creates a Type-1 message using the given raw Type-1 material.

	"log"
	"os"
	"path/filepath"
	"strings"
)

func usage() {
	fmt.Fprintf(os.Stderr, "usage: go run mkzip.go zoneinfo.zip\n")
	os.Exit(2)
}

func main() {
	log.SetPrefix("mkzip: ")
	log.SetFlags(0)
	flag.Usage = usage
	flag.Parse()
	args := flag.Args()
	if len(args) != 1 || !strings.HasSuffix(args[0], ".zip") {
		usage()
	}

	var zb bytes.Buffer
	zw := zip.NewWriter(&zb)

	GoldenFilename string         // Expected output stored in golden file

	WantException bool
}

func VerifyOutput(t *testing.T, cmd *cobra.Command, c TestCase) {
	t.Helper()

	cmd.SetArgs(c.Args)

	var out bytes.Buffer
	cmd.SetOut(&out)
	cmd.SetErr(&out)
	cmd.SilenceUsage = true

	fErr := cmd.Execute()
	output := out.String()

	if c.ExpectedOutput != "" && c.ExpectedOutput != output {

     * @param suppliedWorkstation The supplied workstation name.
     */
    public Type1Message(int flags, String suppliedDomain,
            String suppliedWorkstation) {
        setFlags(getDefaultFlags() | flags);
        setSuppliedDomain(suppliedDomain);
        if (suppliedWorkstation == null)
            suppliedWorkstation = getDefaultWorkstation();
        setSuppliedWorkstation(suppliedWorkstation);

	mac := hmac.New(sha256.New, key[:])
	mac.Write(bin[:])
	mac.Sum(partKey[:0])
	return partKey
}

// SealETag seals the etag using the object key.
// It does not encrypt empty ETags because such ETags indicate
// that the S3 client hasn't sent an ETag = MD5(object) and
// the backend can pick an ETag value.
func (key ObjectKey) SealETag(etag []byte) []byte {