tests := map[string]struct {
		version Version
		want    string
	}{
		"with suffix": {
			version: NewVersion(1, 2, 3, "xyz"),
			want:    "1.2.3-xyz",
		},
		"without suffix": {
			version: NewVersion(1, 5, 0, ""),
			want:    "1.5.0",
		},
	}
	for name, tt := range tests {
		t.Run(name, func(t *testing.T) {
			got := tt.version.String()
			if got != tt.want {

	g := NewWithT(t)

	m := Metadata{
		FullName: NewFullName("ns1", "rs1"),
		Version:  Version("v1"),
	}

	c := m.Clone()
	g.Expect(m).To(Equal(c))
}

func TestMetadata_Clone_NonNilMaps(t *testing.T) {
	g := NewWithT(t)

	m := Metadata{
		FullName:    NewFullName("ns1", "rs1"),
		Version:     Version("v1"),
		Annotations: map[string]string{"foo": "bar"},
		Labels:      map[string]string{"l1": "l2"},

		statusKey     = "revision.status"
		sslVersionKey = "ssl.version"
	)

	var (
		buildVersion = bootstrapDump.GetBootstrap().GetNode().GetUserAgentBuildVersion()
		version      = buildVersion.GetVersion()
		md           = buildVersion.GetMetadata().GetFields()

		sb strings.Builder
	)

	fmt.Fprintf(&sb, "%d.%d.%d", version.GetMajorNumber(), version.GetMinorNumber(), version.GetPatch())
	if label, ok := md[buildLabelKey]; ok {

	RawContent string
	// ID is a unique identifier of the resource in the response
	ID string
	// URL is the url the request is sent to
	URL string
	// Version is the version of the resource in the response
	Version string
	// Port is the port of the resource in the response
	Port string
	// Code is the response code
	Code string
	// Host is the host called by the request
	Host string

// limitations under the License.

package version

import (
	"testing"

	"istio.io/istio/pkg/monitoring/monitortest"
)

func TestRecordComponentBuildTag(t *testing.T) {
	cases := []struct {
		name    string
		in      BuildInfo
		wantTag string
	}{
		{
			"record",
			BuildInfo{
				Version:       "VER",
				GitRevision:   "GITREV",
				GolangVersion: "GOLANGVER",

// Copyright Istio Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,

}

func TestSetIstioVersion(t *testing.T) {
	test.SetForTest(t, &version.Info.Version, "binary")

	testCases := []struct {
		name            string
		meta            *model.BootstrapNodeMetadata
		binaryVersion   string
		expectedVersion string
	}{
		{
			name:            "if IstioVersion is not specified, set it from binary version",
			meta:            &model.BootstrapNodeMetadata{},

// Copyright Istio Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,

	cases := []struct {
		version  *version.Info
		expected int
		errMsg   error
		isValid  bool
	}{
		{
			version:  version1_17,
			expected: 17,
			errMsg:   nil,
			isValid:  true,
		},
		{
			version:  version1_8,
			expected: 8,
			errMsg:   nil,
			isValid:  true,
		},
		{
			version:  version1_18,
			expected: 18,
			errMsg:   nil,

// Copyright Istio Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,