github.com/vmware/govmomi@v0.51.0/vim25/types/hardware_version_test.go (about)

     1  // © Broadcom. All Rights Reserved.
     2  // The term “Broadcom” refers to Broadcom Inc. and/or its subsidiaries.
     3  // SPDX-License-Identifier: Apache-2.0
     4  
     5  package types
     6  
     7  import (
     8  	"fmt"
     9  	"sort"
    10  	"strconv"
    11  	"testing"
    12  )
    13  
    14  func TestParseHardwareVersion(t *testing.T) {
    15  	testCases := []struct {
    16  		name                string
    17  		in                  string
    18  		expectedIsValid     bool
    19  		expectedIsSupported bool
    20  		expectedVersion     HardwareVersion
    21  		expectedString      string
    22  	}{
    23  		{
    24  			name:                "EmptyString",
    25  			in:                  "",
    26  			expectedIsValid:     false,
    27  			expectedIsSupported: false,
    28  			expectedVersion:     0,
    29  			expectedString:      "",
    30  		},
    31  		{
    32  			name:                "PrefixSansNumber",
    33  			in:                  "vmx-",
    34  			expectedIsValid:     false,
    35  			expectedIsSupported: false,
    36  			expectedVersion:     0,
    37  			expectedString:      "",
    38  		},
    39  		{
    40  			name:                "NumberSansPrefix",
    41  			in:                  "13",
    42  			expectedIsValid:     true,
    43  			expectedIsSupported: true,
    44  			expectedVersion:     VMX13,
    45  			expectedString:      "vmx-13",
    46  		},
    47  		{
    48  			name:                "PrefixAndNumber",
    49  			in:                  "vmx-13",
    50  			expectedIsValid:     true,
    51  			expectedIsSupported: true,
    52  			expectedVersion:     VMX13,
    53  			expectedString:      "vmx-13",
    54  		},
    55  		{
    56  			name:                "UpperPrefixAndNumber",
    57  			in:                  "VMX-18",
    58  			expectedIsValid:     true,
    59  			expectedIsSupported: true,
    60  			expectedVersion:     VMX18,
    61  			expectedString:      "vmx-18",
    62  		},
    63  		{
    64  			name:                "vmx-99",
    65  			in:                  "vmx-99",
    66  			expectedIsValid:     true,
    67  			expectedIsSupported: false,
    68  			expectedVersion:     HardwareVersion(99),
    69  			expectedString:      "vmx-99",
    70  		},
    71  		{
    72  			name:                "ETooLarge",
    73  			in:                  "vmx-512",
    74  			expectedIsValid:     false,
    75  			expectedIsSupported: false,
    76  			expectedVersion:     0,
    77  			expectedString:      "",
    78  		},
    79  		{
    80  			name:                "ETooLarge2",
    81  			in:                  "512",
    82  			expectedIsValid:     false,
    83  			expectedIsSupported: false,
    84  			expectedVersion:     0,
    85  			expectedString:      "",
    86  		},
    87  	}
    88  
    89  	t.Run("ParseHardwareVersion", func(t *testing.T) {
    90  		for i := range testCases {
    91  			tc := testCases[i]
    92  			t.Run(tc.name, func(t *testing.T) {
    93  				v, err := ParseHardwareVersion(tc.in)
    94  				if err != nil && tc.expectedIsValid {
    95  					t.Fatalf("unexpected error: %v", err)
    96  				}
    97  				if a, e := v.IsValid(), tc.expectedIsValid; a != e {
    98  					t.Errorf("unexpected invalid value: a=%v, e=%v", a, e)
    99  				}
   100  				if a, e := v.IsSupported(), tc.expectedIsSupported; a != e {
   101  					t.Errorf("unexpected supported value: a=%v, e=%v", a, e)
   102  				}
   103  				if a, e := v, tc.expectedVersion; a != e {
   104  					t.Errorf("unexpected value: a=%v, e=%v", a, e)
   105  				}
   106  				if a, e := v.String(), tc.expectedString; a != e {
   107  					t.Errorf("unexpected string: a=%v, e=%v", a, e)
   108  				}
   109  			})
   110  		}
   111  	})
   112  
   113  }
   114  
   115  func TestHardwareVersion(t *testing.T) {
   116  
   117  	var uniqueExpectedVersions []HardwareVersion
   118  
   119  	type testCase struct {
   120  		name                string
   121  		in                  string
   122  		expectedIsValid     bool
   123  		expectedIsSupported bool
   124  		expectedVersion     HardwareVersion
   125  		expectedString      string
   126  	}
   127  
   128  	testCasesForVersion := func(
   129  		version int,
   130  		expectedVersion HardwareVersion,
   131  		expectedString string) []testCase {
   132  
   133  		uniqueExpectedVersions = append(uniqueExpectedVersions, MustParseHardwareVersion(expectedString))
   134  
   135  		szVersion := strconv.Itoa(version)
   136  		return []testCase{
   137  			{
   138  				name:                szVersion,
   139  				in:                  szVersion,
   140  				expectedIsValid:     true,
   141  				expectedIsSupported: true,
   142  				expectedVersion:     expectedVersion,
   143  				expectedString:      expectedString,
   144  			},
   145  			{
   146  				name:                "vmx-" + szVersion,
   147  				in:                  "vmx-" + szVersion,
   148  				expectedIsValid:     true,
   149  				expectedIsSupported: true,
   150  				expectedVersion:     expectedVersion,
   151  				expectedString:      expectedString,
   152  			},
   153  			{
   154  				name:                "VMX-" + szVersion,
   155  				in:                  "VMX-" + szVersion,
   156  				expectedIsValid:     true,
   157  				expectedIsSupported: true,
   158  				expectedVersion:     expectedVersion,
   159  				expectedString:      expectedString,
   160  			},
   161  		}
   162  	}
   163  
   164  	testCases := []testCase{
   165  		{
   166  			name:                "EmptyString",
   167  			in:                  "",
   168  			expectedIsValid:     false,
   169  			expectedIsSupported: false,
   170  			expectedVersion:     0,
   171  			expectedString:      "",
   172  		},
   173  		{
   174  			name:                "PrefixSansVersion",
   175  			in:                  "vmx-",
   176  			expectedIsValid:     false,
   177  			expectedIsSupported: false,
   178  			expectedVersion:     0,
   179  			expectedString:      "",
   180  		},
   181  		{
   182  			name:                "PrefixAndInvalidVersion",
   183  			in:                  "vmx-0",
   184  			expectedIsValid:     false,
   185  			expectedIsSupported: false,
   186  			expectedVersion:     0,
   187  			expectedString:      "",
   188  		},
   189  		{
   190  			name:                "UnsupportedVersion",
   191  			in:                  "1",
   192  			expectedIsValid:     true,
   193  			expectedIsSupported: false,
   194  			expectedVersion:     HardwareVersion(1),
   195  			expectedString:      "vmx-1",
   196  		},
   197  	}
   198  
   199  	testCases = append(testCases, testCasesForVersion(3, VMX3, "vmx-3")...)
   200  	testCases = append(testCases, testCasesForVersion(4, VMX4, "vmx-4")...)
   201  	testCases = append(testCases, testCasesForVersion(6, VMX6, "vmx-6")...)
   202  	testCases = append(testCases, testCasesForVersion(7, VMX7, "vmx-7")...)
   203  	testCases = append(testCases, testCasesForVersion(8, VMX8, "vmx-8")...)
   204  	testCases = append(testCases, testCasesForVersion(9, VMX9, "vmx-9")...)
   205  	testCases = append(testCases, testCasesForVersion(10, VMX10, "vmx-10")...)
   206  	testCases = append(testCases, testCasesForVersion(11, VMX11, "vmx-11")...)
   207  	testCases = append(testCases, testCasesForVersion(12, VMX12, "vmx-12")...)
   208  	testCases = append(testCases, testCasesForVersion(13, VMX13, "vmx-13")...)
   209  	testCases = append(testCases, testCasesForVersion(14, VMX14, "vmx-14")...)
   210  	testCases = append(testCases, testCasesForVersion(15, VMX15, "vmx-15")...)
   211  	testCases = append(testCases, testCasesForVersion(16, VMX16, "vmx-16")...)
   212  	testCases = append(testCases, testCasesForVersion(17, VMX17, "vmx-17")...)
   213  	testCases = append(testCases, testCasesForVersion(18, VMX18, "vmx-18")...)
   214  	testCases = append(testCases, testCasesForVersion(19, VMX19, "vmx-19")...)
   215  	testCases = append(testCases, testCasesForVersion(20, VMX20, "vmx-20")...)
   216  	testCases = append(testCases, testCasesForVersion(21, VMX21, "vmx-21")...)
   217  
   218  	t.Run("GetHardwareVersions", func(t *testing.T) {
   219  		a, e := uniqueExpectedVersions, GetHardwareVersions()
   220  		sort.Slice(a, func(i, j int) bool { return a[i] < a[j] })
   221  		sort.Slice(e, func(i, j int) bool { return e[i] < e[j] })
   222  		if a, e := len(a), len(e); a != e {
   223  			t.Errorf("unexpected number of versions: a=%d, e=%d", a, e)
   224  		}
   225  		for i := range a {
   226  			if a[i] != e[i] {
   227  				t.Errorf("unexpected version: i=%d, a=%s, e=%s", i, a, e)
   228  			}
   229  		}
   230  	})
   231  
   232  	t.Run("ParseHardwareVersion", func(t *testing.T) {
   233  		for i := range testCases {
   234  			tc := testCases[i]
   235  			t.Run(tc.name, func(t *testing.T) {
   236  				v, err := ParseHardwareVersion(tc.in)
   237  				if err != nil && tc.expectedIsValid {
   238  					t.Fatalf("unexpected error: %v", err)
   239  				}
   240  				if a, e := v.IsValid(), tc.expectedIsValid; a != e {
   241  					t.Errorf("unexpected invalid value: a=%v, e=%v", a, e)
   242  				}
   243  				if tc.expectedIsValid {
   244  					if a, e := v, tc.expectedVersion; a != e {
   245  						t.Errorf("unexpected value: a=%v, e=%v", a, e)
   246  					}
   247  					if a, e := v.String(), tc.expectedString; a != e {
   248  						t.Errorf("unexpected string: a=%v, e=%v", a, e)
   249  					}
   250  				}
   251  			})
   252  		}
   253  	})
   254  	t.Run("MarshalText", func(t *testing.T) {
   255  		for i := range testCases {
   256  			tc := testCases[i]
   257  			t.Run(tc.name, func(t *testing.T) {
   258  				data, err := tc.expectedVersion.MarshalText()
   259  				if err != nil {
   260  					t.Fatalf("unexpected error marshaling text: %v", err)
   261  				}
   262  				if a, e := string(data), tc.expectedString; a != e {
   263  					t.Errorf("unexpected data marshaling text: %s", a)
   264  				}
   265  			})
   266  		}
   267  	})
   268  
   269  	t.Run("UnmarshalText", func(t *testing.T) {
   270  		for i := range testCases {
   271  			tc := testCases[i]
   272  			t.Run(tc.name, func(t *testing.T) {
   273  				var (
   274  					data = []byte(tc.in)
   275  					v    HardwareVersion
   276  				)
   277  				if err := v.UnmarshalText(data); err != nil {
   278  					if !tc.expectedIsValid {
   279  						if a, e := err.Error(), fmt.Sprintf("invalid version: %q", tc.in); a != e {
   280  							t.Errorf("unexpected error unmarshaling text: %q", a)
   281  						}
   282  					} else {
   283  						t.Errorf("unexpected error unmarshaling text: %v", err)
   284  					}
   285  				} else if a, e := v, v; a != e {
   286  					t.Errorf("unexpected data unmarshaling text: %s", a)
   287  				}
   288  			})
   289  		}
   290  	})
   291  }